diff --git a/.github/workflows/cpplint.yml b/.github/workflows/cpplint.yml
index 979b5f0a..4c5fbd63 100644
--- a/.github/workflows/cpplint.yml
+++ b/.github/workflows/cpplint.yml
@@ -19,7 +19,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install cpplint==1.6.1
+          pip install cpplint
       - name: Linting
         run: |
           cpplint --repository=. --recursive \
diff --git a/README.md b/README.md
index 0d44c596..7ccf9522 100644
--- a/README.md
+++ b/README.md
@@ -1,30 +1,49 @@
-- [OpenDTU-OnBattery](#opendtu-onbattery)
-  - [What is OpenDTU-OnBattery](#what-is-opendtu-onbattery)
-  - [Documentation](#documentation)
-  - [State of the project](#state-of-the-project)
-  - [History of the project](#history-of-the-project)
-  - [Acknowledgments](#acknowledgments)
-
-# OpenDTU-OnBattery
-
-This is a fork of [OpenDTU](https://github.com/tbnobody/OpenDTU).
-
+[![OpenDTU-OnBattery Build](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/build.yml/badge.svg)](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/build.yml)
+[![cpplint](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/cpplint.yml/badge.svg)](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/cpplint.yml)
+[![Yarn Linting](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/yarnlint.yml/badge.svg)](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/yarnlint.yml)
 <!---
 disabled while "create release badge" action is broken, see .github/build.yml
 ![GitHub tag (latest SemVer)](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/helgeerbe/68b47cc8c8994d04ab3a4fa9d8aee5e6/raw/openDTUcoreRelease.json)
 --->
 
-[![OpenDTU-OnBattery Build](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/build.yml/badge.svg)](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/build.yml)
-[![cpplint](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/cpplint.yml/badge.svg)](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/cpplint.yml)
-[![Yarn Linting](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/yarnlint.yml/badge.svg)](https://github.com/hoylabs/OpenDTU-OnBattery/actions/workflows/yarnlint.yml)
+- [OpenDTU-OnBattery](#opendtu-onbattery)
+  - [Getting Started](#getting-started)
+  - [Important Differences](#important-differences)
+  - [Documentation](#documentation)
+  - [Project State](#project-state)
+  - [Project History](#project-history)
+  - [Acknowledgments](#acknowledgments)
 
-## What is OpenDTU-OnBattery
+# OpenDTU-OnBattery
 
-OpenDTU-OnBattery is an extension of the original OpenDTU to support battery
-chargers, battery management systems (BMS) and power meters on a single ESP32.
-With the help of a Dynamic Power Limiter, the power production can be adjusted
-to the actual consumption. In this way, it is possible to implement a zero
-export policy.
+OpenDTU-OnBattery is a fork of [OpenDTU](https://github.com/tbnobody/OpenDTU),
+which adds support for battery chargers, battery management systems (BMS), and
+power meters on a single ESP32. Its Dynamic Power Limiter can adjust the
+inverter's power production to the actual houshold consumption. In this way, it
+is possible to implement a zero export policy.
+
+## Getting Started
+
+See the documentation to learn [what hardware](https://opendtu-onbattery.net/hardware/)
+to acquire, how to [initialize](https://opendtu-onbattery.net/firmware/) it
+with OpenDTU-OnBattery firmware, and how to
+[configure](https://opendtu-onbattery.net/firmware/device_profiles/)
+OpenDTU-OnBattery for your hardware.
+
+## Important Differences
+
+Generally speaking, OpenDTU-OnBattery and the upstream project are compatible
+with each other, because OpenDTU-OnBattery mostly only extends the upstream
+project. However, there are a few notable differences aside from the added functionality:
+
+* OpenDTU-OnBattery, due to its code footprint, cannot offer support for
+  over-the-air (OTA) updates on ESP32 with only 4MB of flash memory. Consult
+  the [documentation](https://opendtu-onbattery.net/firmware/howto/upgrade_8mb/#background)
+  to learn more.
+* Unlike in the upstream project, you **must** compile the web application
+  yourself when attempting to build your own firmware blob. See the
+  [documentation](https://opendtu-onbattery.net/firmware/compile_webapp/) for
+  details.
 
 ## Documentation
 
@@ -35,37 +54,40 @@ You may find additional helpful information in the project's
 community-maintained [Github
 Wiki](https://github.com/hoylabs/OpenDTU-OnBattery/wiki).
 
-To find out what's new or improved have a look at the changelog of the
+To find out what's new or improved have a look at the
 [releases](https://github.com/hoylabs/OpenDTU-OnBattery/releases).
 
-## State of the project
+## Project State
 
 OpenDTU-OnBattery is actively maintained. Please note that OpenDTU-OnBattery
 may change significantly during its development. Bug reports, comments, feature
 requests and pull requests are welcome!
 
-## History of the project
+## Project History
 
 The original OpenDTU project was started from [a discussion on
-Mikrocontroller.net](https://www.mikrocontroller.net/topic/525778). It was the
-goal to replace the original Hoymiles DTU (Telemetry Gateway) to avoid using
-Hoymile's cloud. With a lot of reverse engineering the Hoymiles protocol was
-decrypted and analyzed.
+Mikrocontroller.net](https://www.mikrocontroller.net/topic/525778). The
+original ambition was to replace the original Hoymiles DTU (Telemetry Gateway)
+to avoid using Hoymile's cloud. With a lot of reverse engineering, the Hoymiles
+protocol was decrypted and analyzed.
 
-In the summer of 2022 @helgeerbe bought a Victron MPPT charge cntroller, and
-didn't like the idea to set up a separate ESP32 to receive the charger's data.
-He decided to fork OpenDTU and extend it with battery charger support and a
-Dynamic Power Limiter.
+In the summer of 2022 [@helgeerbe](https://github.com/helgeerbe) bought a
+Victron MPPT charge controller, and didn't like the idea to set up a separate
+ESP32 to receive the charger's data. He decided to fork OpenDTU and extend it
+with battery charger support and a Dynamic Power Limiter.
 
 In early October 2024, the project moved to the newly founded GitHub
 organisation `hoylabs` and is since maintained by multiple community members.
 
 ## Acknowledgments
 
-* Special thanks to Thomas Basler (@tbnobody), the author of the [upstream
-  project](https://github.com/tbnobody/OpenDTU), for hist continued effort!
-* Thanks to @helgeerbe for starting OpenDTU-OnBattery and his dedication to the
-  project, as well as his trust in the current maintainers of the project,
-  which act as part of the `hoylabs` GitHub organisation.
+* Special thanks to Thomas Basler ([@tbnobody](https://github.com/tbnobody)),
+  the author of the [upstream project](https://github.com/tbnobody/OpenDTU),
+  for his continued effort!
+* Thanks to [@helgeerbe](https://github.com/helgeerbe) for starting
+  OpenDTU-OnBattery, for his dedication to the project, as well as for his
+  trust in the current maintainers of the project, which act as part of the
+  `hoylabs` GitHub organisation.
 * We like to thank all contributors. With your ideas and enhancements, you have
-  made OpenDTU-OnBattery much more than @helgeerbe originally had in mind.
+  made OpenDTU-OnBattery much more than
+  [@helgeerbe](https://github.com/helgeerbe) originally had in mind.
diff --git a/include/BatteryStats.h b/include/BatteryStats.h
index bcf7cedc..cfce8ea8 100644
--- a/include/BatteryStats.h
+++ b/include/BatteryStats.h
@@ -6,6 +6,7 @@
 #include "AsyncJson.h"
 #include "Arduino.h"
 #include "JkBmsDataPoints.h"
+#include "JbdBmsDataPoints.h"
 #include "VeDirectShuntController.h"
 #include <cfloat>
 
@@ -159,7 +160,6 @@ class SBSBatteryStats : public BatteryStats {
 
         float _chargeVoltage;
         float _chargeCurrentLimitation;
-        float _dischargeCurrentLimitation;
         uint16_t _stateOfHealth;
         float _current;
         float _temperature;
@@ -284,6 +284,35 @@ class JkBmsBatteryStats : public BatteryStats {
         uint32_t _cellVoltageTimestamp = 0;
 };
 
+class JbdBmsBatteryStats : public BatteryStats {
+    public:
+        void getLiveViewData(JsonVariant& root) const final {
+            getJsonData(root, false);
+        }
+
+        void getInfoViewData(JsonVariant& root) const {
+            getJsonData(root, true);
+        }
+
+        void mqttPublish() const final;
+
+        uint32_t getMqttFullPublishIntervalMs() const final { return 60 * 1000; }
+
+        void updateFrom(JbdBms::DataPointContainer const& dp);
+
+    private:
+        void getJsonData(JsonVariant& root, bool verbose) const;
+
+        JbdBms::DataPointContainer _dataPoints;
+        mutable uint32_t _lastMqttPublish = 0;
+        mutable uint32_t _lastFullMqttPublish = 0;
+
+        uint16_t _cellMinMilliVolt = 0;
+        uint16_t _cellAvgMilliVolt = 0;
+        uint16_t _cellMaxMilliVolt = 0;
+        uint32_t _cellVoltageTimestamp = 0;
+};
+
 class VictronSmartShuntStats : public BatteryStats {
     public:
         void getLiveViewData(JsonVariant& root) const final;
diff --git a/include/Configuration.h b/include/Configuration.h
index 3b99c38b..79d3e61c 100644
--- a/include/Configuration.h
+++ b/include/Configuration.h
@@ -4,9 +4,12 @@
 #include "PinMapping.h"
 #include <cstdint>
 #include <ArduinoJson.h>
+#include <TaskSchedulerDeclarations.h>
+#include <mutex>
+#include <condition_variable>
 
 #define CONFIG_FILENAME "/config.json"
-#define CONFIG_VERSION 0x00011c00 // 0.1.28 // make sure to clean all after change
+#define CONFIG_VERSION 0x00011d00 // 0.1.29 // make sure to clean all after change
 
 #define WIFI_MAX_SSID_STRLEN 32
 #define WIFI_MAX_PASSWORD_STRLEN 64
@@ -33,6 +36,7 @@
 #define CHAN_MAX_NAME_STRLEN 31
 
 #define DEV_MAX_MAPPING_NAME_STRLEN 63
+#define LOCALE_STRLEN 2
 
 #define HTTP_REQUEST_MAX_URL_STRLEN 1024
 #define HTTP_REQUEST_MAX_USERNAME_STRLEN 64
@@ -128,6 +132,43 @@ struct POWERMETER_HTTP_SML_CONFIG_T {
 };
 using PowerMeterHttpSmlConfig = struct POWERMETER_HTTP_SML_CONFIG_T;
 
+struct POWERLIMITER_INVERTER_CONFIG_T {
+    uint64_t Serial;
+    bool IsGoverned;
+    bool IsBehindPowerMeter;
+    bool IsSolarPowered;
+    bool UseOverscalingToCompensateShading;
+    uint16_t LowerPowerLimit;
+    uint16_t UpperPowerLimit;
+};
+using PowerLimiterInverterConfig = struct POWERLIMITER_INVERTER_CONFIG_T;
+
+struct POWERLIMITER_CONFIG_T {
+    bool Enabled;
+    bool VerboseLogging;
+    bool SolarPassThroughEnabled;
+    uint8_t SolarPassThroughLosses;
+    bool BatteryAlwaysUseAtNight;
+    int16_t TargetPowerConsumption;
+    uint16_t TargetPowerConsumptionHysteresis;
+    uint16_t BaseLoadLimit;
+    bool IgnoreSoc;
+    uint16_t BatterySocStartThreshold;
+    uint16_t BatterySocStopThreshold;
+    float VoltageStartThreshold;
+    float VoltageStopThreshold;
+    float VoltageLoadCorrectionFactor;
+    uint16_t FullSolarPassThroughSoc;
+    float FullSolarPassThroughStartVoltage;
+    float FullSolarPassThroughStopVoltage;
+    uint64_t InverterSerialForDcVoltage;
+    uint8_t InverterChannelIdForDcVoltage;
+    int8_t RestartHour;
+    uint16_t TotalUpperPowerLimit;
+    PowerLimiterInverterConfig Inverters[INV_MAX_COUNT];
+};
+using PowerLimiterConfig = struct POWERLIMITER_CONFIG_T;
+
 enum BatteryVoltageUnit { Volts = 0, DeciVolts = 1, CentiVolts = 2, MilliVolts = 3 };
 
 enum BatteryAmperageUnit { Amps = 0, MilliAmps = 1 };
@@ -145,6 +186,8 @@ struct BATTERY_CONFIG_T {
     BatteryVoltageUnit MqttVoltageUnit;
     bool EnableDischargeCurrentLimit;
     float DischargeCurrentLimit;
+    float DischargeCurrentLimitBelowSoc;
+    float DischargeCurrentLimitBelowVoltage;
     bool UseBatteryReportedDischargeCurrentLimit;
     char MqttDischargeCurrentTopic[MQTT_MAX_TOPIC_STRLEN + 1];
     char MqttDischargeCurrentJsonPath[BATTERY_JSON_MAX_PATH_STRLEN + 1];
@@ -251,7 +294,7 @@ struct CONFIG_T {
         bool ScreenSaver;
         uint8_t Rotation;
         uint8_t Contrast;
-        uint8_t Language;
+        char Locale[LOCALE_STRLEN + 1];
         struct {
             uint32_t Duration;
             uint8_t Mode;
@@ -278,34 +321,7 @@ struct CONFIG_T {
         PowerMeterHttpSmlConfig HttpSml;
     } PowerMeter;
 
-    struct {
-        bool Enabled;
-        bool VerboseLogging;
-        bool SolarPassThroughEnabled;
-        uint8_t SolarPassThroughLosses;
-        bool BatteryAlwaysUseAtNight;
-        uint32_t Interval;
-        bool IsInverterBehindPowerMeter;
-        bool IsInverterSolarPowered;
-        bool UseOverscalingToCompensateShading;
-        uint64_t InverterId;
-        uint8_t InverterChannelId;
-        int32_t TargetPowerConsumption;
-        int32_t TargetPowerConsumptionHysteresis;
-        int32_t LowerPowerLimit;
-        int32_t BaseLoadLimit;
-        int32_t UpperPowerLimit;
-        bool IgnoreSoc;
-        uint32_t BatterySocStartThreshold;
-        uint32_t BatterySocStopThreshold;
-        float VoltageStartThreshold;
-        float VoltageStopThreshold;
-        float VoltageLoadCorrectionFactor;
-        int8_t RestartHour;
-        uint32_t FullSolarPassThroughSoc;
-        float FullSolarPassThroughStartVoltage;
-        float FullSolarPassThroughStopVoltage;
-    } PowerLimiter;
+    PowerLimiterConfig PowerLimiter;
 
     BatteryConfig Battery;
 
@@ -331,11 +347,23 @@ struct CONFIG_T {
 
 class ConfigurationClass {
 public:
-    void init();
+    void init(Scheduler& scheduler);
     bool read();
     bool write();
     void migrate();
-    CONFIG_T& get();
+    CONFIG_T const& get();
+
+    class WriteGuard {
+    public:
+        WriteGuard();
+        CONFIG_T& getConfig();
+        ~WriteGuard();
+
+    private:
+        std::unique_lock<std::mutex> _lock;
+    };
+
+    WriteGuard getWriteGuard();
 
     INVERTER_CONFIG_T* getFreeInverterSlot();
     INVERTER_CONFIG_T* getInverterConfig(const uint64_t serial);
@@ -347,6 +375,7 @@ public:
     static void serializePowerMeterHttpJsonConfig(PowerMeterHttpJsonConfig const& source, JsonObject& target);
     static void serializePowerMeterHttpSmlConfig(PowerMeterHttpSmlConfig const& source, JsonObject& target);
     static void serializeBatteryConfig(BatteryConfig const& source, JsonObject& target);
+    static void serializePowerLimiterConfig(PowerLimiterConfig const& source, JsonObject& target);
 
     static void deserializeHttpRequestConfig(JsonObject const& source, HttpRequestConfig& target);
     static void deserializePowerMeterMqttConfig(JsonObject const& source, PowerMeterMqttConfig& target);
@@ -354,6 +383,12 @@ public:
     static void deserializePowerMeterHttpJsonConfig(JsonObject const& source, PowerMeterHttpJsonConfig& target);
     static void deserializePowerMeterHttpSmlConfig(JsonObject const& source, PowerMeterHttpSmlConfig& target);
     static void deserializeBatteryConfig(JsonObject const& source, BatteryConfig& target);
+    static void deserializePowerLimiterConfig(JsonObject const& source, PowerLimiterConfig& target);
+
+private:
+    void loop();
+
+    Task _loopTask;
 };
 
 extern ConfigurationClass Configuration;
diff --git a/include/DataPoints.h b/include/DataPoints.h
new file mode 100644
index 00000000..91f19d92
--- /dev/null
+++ b/include/DataPoints.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#include <Arduino.h>
+#include <map>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+using tCellVoltages = std::map<uint8_t, uint16_t>;
+
+template<typename... V>
+class DataPoint {
+    template<typename, typename L, template<L> class>
+    friend class DataPointContainer;
+
+    public:
+        using tValue = std::variant<V...>;
+
+        DataPoint() = delete;
+
+        DataPoint(DataPoint const& other)
+            : _strLabel(other._strLabel)
+            , _strValue(other._strValue)
+            , _strUnit(other._strUnit)
+            , _value(other._value)
+            , _timestamp(other._timestamp) { }
+
+        DataPoint(std::string const& strLabel, std::string const& strValue,
+                std::string const& strUnit, tValue value, uint32_t timestamp)
+            : _strLabel(strLabel)
+            , _strValue(strValue)
+            , _strUnit(strUnit)
+            , _value(std::move(value))
+            , _timestamp(timestamp) { }
+
+        std::string const& getLabelText() const { return _strLabel; }
+        std::string const& getValueText() const { return _strValue; }
+        std::string const& getUnitText() const { return _strUnit; }
+        uint32_t getTimestamp() const { return _timestamp; }
+
+        bool operator==(DataPoint const& other) const {
+            return _value == other._value;
+        }
+
+    private:
+        std::string _strLabel;
+        std::string _strValue;
+        std::string _strUnit;
+        tValue _value;
+        uint32_t _timestamp;
+};
+
+template<typename T> std::string dataPointValueToStr(T const& v);
+
+template<typename DataPoint, typename Label, template<Label> class Traits>
+class DataPointContainer {
+    public:
+        DataPointContainer() = default;
+
+        //template<Label L> using Traits = LabelTraits<L>;
+
+        template<Label L>
+        void add(typename Traits<L>::type val) {
+            _dataPoints.emplace(
+                    L,
+                    DataPoint(
+                        Traits<L>::name,
+                        dataPointValueToStr(val),
+                        Traits<L>::unit,
+                        typename DataPoint::tValue(std::move(val)),
+                        millis()
+                    )
+            );
+        }
+
+        // make sure add() is only called with the type expected for the
+        // respective label, no implicit conversions allowed.
+        template<Label L, typename T>
+        void add(T) = delete;
+
+        template<Label L>
+        std::optional<DataPoint const> getDataPointFor() const {
+            auto it = _dataPoints.find(L);
+            if (it == _dataPoints.end()) { return std::nullopt; }
+            return it->second;
+        }
+
+        template<Label L>
+        std::optional<typename Traits<L>::type> get() const {
+            auto optionalDataPoint = getDataPointFor<L>();
+            if (!optionalDataPoint.has_value()) { return std::nullopt; }
+            return std::get<typename Traits<L>::type>(optionalDataPoint->_value);
+        }
+
+        using tMap = std::unordered_map<Label, DataPoint const>;
+        typename tMap::const_iterator cbegin() const { return _dataPoints.cbegin(); }
+        typename tMap::const_iterator cend() const { return _dataPoints.cend(); }
+
+        // copy all data points from source into this instance, overwriting
+        // existing data points in this instance.
+        void updateFrom(DataPointContainer const& source)
+        {
+            for (auto iter = source.cbegin(); iter != source.cend(); ++iter) {
+                auto pos = _dataPoints.find(iter->first);
+
+                if (pos != _dataPoints.end()) {
+                    // do not update existing data points with the same value
+                    if (pos->second == iter->second) { continue; }
+
+                    _dataPoints.erase(pos);
+                }
+                _dataPoints.insert(*iter);
+            }
+        }
+
+    private:
+        tMap _dataPoints;
+};
diff --git a/include/Display_Graphic.h b/include/Display_Graphic.h
index e49bf9f6..ab47836d 100644
--- a/include/Display_Graphic.h
+++ b/include/Display_Graphic.h
@@ -40,7 +40,7 @@ public:
     void setContrast(const uint8_t contrast);
     void setStatus(const bool turnOn);
     void setOrientation(const uint8_t rotation = DISPLAY_ROTATION);
-    void setLanguage(const uint8_t language);
+    void setLocale(const String& locale);
     void setDiagramMode(DiagramMode_t mode);
     void setStartupDisplay();
 
@@ -65,7 +65,7 @@ private:
 
     DisplayType_t _display_type = DisplayType_t::None;
     DiagramMode_t _diagram_mode = DiagramMode_t::Off;
-    uint8_t _display_language = DISPLAY_LANGUAGE;
+    String _display_language = DISPLAY_LOCALE;
     uint8_t _mExtra;
     const uint16_t _period = 1000;
     const uint16_t _interval = 60000; // interval at which to power save (milliseconds)
@@ -73,6 +73,17 @@ private:
     char _fmtText[32];
     bool _isLarge = false;
     uint8_t _lineOffsets[5];
+
+    String _i18n_offline;
+    String _i18n_yield_today_kwh;
+    String _i18n_yield_today_wh;
+    String _i18n_date_format;
+    String _i18n_current_power_kw;
+    String _i18n_current_power_w;
+    String _i18n_meter_power_w;
+    String _i18n_meter_power_kw;
+    String _i18n_yield_total_mwh;
+    String _i18n_yield_total_kwh;
 };
 
 extern DisplayGraphicClass Display;
diff --git a/include/I18n.h b/include/I18n.h
new file mode 100644
index 00000000..04dcb843
--- /dev/null
+++ b/include/I18n.h
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <TaskSchedulerDeclarations.h>
+#include <WString.h>
+#include <list>
+
+struct LanguageInfo_t {
+    String code;
+    String name;
+    String filename;
+};
+
+class I18nClass {
+public:
+    I18nClass();
+    void init(Scheduler& scheduler);
+    std::list<LanguageInfo_t> getAvailableLanguages();
+    String getFilenameByLocale(const String& locale) const;
+    void readDisplayStrings(
+        const String& locale,
+        String& date_format,
+        String& offline,
+        String& power_w, String& power_kw,
+        String& meter_power_w, String& meter_power_kw,
+        String& yield_today_wh, String& yield_today_kwh,
+        String& yield_total_kwh, String& yield_total_mwh);
+
+private:
+    void readLangPacks();
+    void readConfig(String file);
+
+    std::list<LanguageInfo_t> _availLanguages;
+};
+
+extern I18nClass I18n;
diff --git a/include/JbdBmsController.h b/include/JbdBmsController.h
new file mode 100644
index 00000000..98764771
--- /dev/null
+++ b/include/JbdBmsController.h
@@ -0,0 +1,87 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <frozen/string.h>
+
+#include "Battery.h"
+#include "JbdBmsDataPoints.h"
+#include "JbdBmsSerialMessage.h"
+#include "JbdBmsController.h"
+
+namespace JbdBms {
+
+class Controller : public BatteryProvider {
+    public:
+        Controller() = default;
+
+        bool init(bool verboseLogging) final;
+        void deinit() final;
+        void loop() final;
+        std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
+
+    private:
+        static char constexpr _serialPortOwner[] = "JBD BMS";
+
+#ifdef JBDBMS_DUMMY_SERIAL
+        std::unique_ptr<DummySerial> _upSerial;
+#else
+        std::unique_ptr<HardwareSerial> _upSerial;
+#endif
+
+        enum class Status : unsigned {
+            Initializing,
+            Timeout,
+            WaitingForPollInterval,
+            HwSerialNotAvailableForWrite,
+            BusyReading,
+            RequestSent,
+            FrameCompleted
+        };
+
+        frozen::string const& getStatusText(Status status);
+        void announceStatus(Status status);
+        void sendRequest(uint8_t pollInterval);
+        void rxData(uint8_t inbyte);
+        void reset();
+        void frameComplete();
+        void processDataPoints(DataPointContainer const& dataPoints);
+
+        enum class Interface : unsigned {
+            Invalid,
+            Uart,
+            Transceiver
+        };
+
+        Interface getInterface() const;
+
+        enum class ReadState : unsigned {
+            Idle,
+            WaitingForFrameStart,
+            FrameStartReceived, // 1 Byte: 0xDD
+            StateReceived,
+            CommandCodeReceived,
+            ReadingDataContent,
+            DataContentReceived,
+            ReadingCheckSum,
+            CheckSumReceived,
+        };
+
+        ReadState _readState;
+        void setReadState(ReadState state) {
+            _readState = state;
+        }
+
+        bool _verboseLogging = true;
+        int8_t _rxEnablePin = -1;
+        int8_t _txEnablePin = -1;
+        Status _lastStatus = Status::Initializing;
+        uint32_t _lastStatusPrinted = 0;
+        uint32_t _lastRequest = 0;
+        uint8_t _dataLength = 0;
+        JbdBms::SerialResponse::tData _buffer = {};
+        std::shared_ptr<JbdBmsBatteryStats> _stats =
+            std::make_shared<JbdBmsBatteryStats>();
+};
+
+} /* namespace JbdBms */
diff --git a/include/JbdBmsDataPoints.h b/include/JbdBmsDataPoints.h
new file mode 100644
index 00000000..009558af
--- /dev/null
+++ b/include/JbdBmsDataPoints.h
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <Arduino.h>
+#include <map>
+#include <frozen/map.h>
+#include <frozen/string.h>
+
+#include "DataPoints.h"
+
+namespace JbdBms {
+
+#define JBD_PROTECTION_STATUS(fnc) \
+    fnc(CellOverVoltage, (1<<0)) \
+    fnc(CellUnderVoltage, (1<<1)) \
+    fnc(PackOverVoltage, (1<<2)) \
+    fnc(PackUnderVoltage, (1<<3)) \
+    fnc(ChargingOverTemperature, (1<<4)) \
+    fnc(ChargingLowTemperature, (1<<5)) \
+    fnc(DischargingOverTemperature, (1<<6)) \
+    fnc(DischargingLowTemperature, (1<<7)) \
+    fnc(ChargingOverCurrent, (1<<8)) \
+    fnc(DischargeOverCurrent, (1<<9)) \
+    fnc(ShortCircuit, (1<<10)) \
+    fnc(IcFrontEndError, (1<<11)) \
+    fnc(MosSotwareLock, (1<<12)) \
+    fnc(Reserved1, (1<<13)) \
+    fnc(Reserved2, (1<<14)) \
+    fnc(Reserved3, (1<<15))
+
+enum class AlarmBits : uint16_t {
+#define ALARM_ENUM(name, value) name = value,
+    JBD_PROTECTION_STATUS(ALARM_ENUM)
+#undef ALARM_ENUM
+};
+
+static const frozen::map<AlarmBits, frozen::string, 16> AlarmBitTexts = {
+#define ALARM_TEXT(name, value) { AlarmBits::name, #name },
+    JBD_PROTECTION_STATUS(ALARM_TEXT)
+#undef ALARM_TEXT
+};
+
+enum class DataPointLabel : uint8_t {
+    CellsMilliVolt,
+    BatteryTempOneCelsius,
+    BatteryTempTwoCelsius,
+    BatteryVoltageMilliVolt,
+    BatteryCurrentMilliAmps,
+    BatterySoCPercent,
+    BatteryTemperatureSensorAmount,
+    BatteryCycles,
+    BatteryCellAmount,
+    AlarmsBitmask,
+    BalancingEnabled,
+    CellAmountSetting,
+    BatteryCapacitySettingAmpHours,
+    BatteryChargeEnabled,
+    BatteryDischargeEnabled,
+    DateOfManufacturing,
+    BmsSoftwareVersion,
+    BmsHardwareVersion,
+    ActualBatteryCapacityAmpHours
+};
+
+using tCells = tCellVoltages;
+
+template<DataPointLabel> struct DataPointLabelTraits;
+
+#define LABEL_TRAIT(n, t, u) template<> struct DataPointLabelTraits<DataPointLabel::n> { \
+    using type = t; \
+    static constexpr char const name[] = #n; \
+    static constexpr char const unit[] = u; \
+};
+
+/**
+ * the types associated with the labels are the types for the respective data
+ * points in the JbdBms::DataPoint class. they are *not* always equal to the
+ * type used in the serial message.
+ *
+ * it is unfortunate that we have to repeat all enum values here to define the
+ * traits. code generation could help here (labels are defined in a single
+ * source of truth and this code is generated -- no typing errors, etc.).
+ * however, the compiler will complain if an enum is misspelled or traits are
+ * defined for a removed enum, so we will notice. it will also complain when a
+ * trait is missing and if a data point for a label without traits is added to
+ * the DataPointContainer class, because the traits must be available then.
+ * even though this is tedious to maintain, human errors will be caught.
+ */
+LABEL_TRAIT(CellsMilliVolt,                         tCells,      "mV");
+LABEL_TRAIT(BatteryTempOneCelsius,                  int16_t,     "°C");
+LABEL_TRAIT(BatteryTempTwoCelsius,                  int16_t,     "°C");
+LABEL_TRAIT(BatteryVoltageMilliVolt,                uint32_t,    "mV");
+LABEL_TRAIT(BatteryCurrentMilliAmps,                int32_t,     "mA");
+LABEL_TRAIT(BatterySoCPercent,                      uint8_t,     "%");
+LABEL_TRAIT(BatteryTemperatureSensorAmount,         uint8_t,     "");
+LABEL_TRAIT(BatteryCycles,                          uint16_t,    "");
+LABEL_TRAIT(BatteryCellAmount,                      uint16_t,    "");
+LABEL_TRAIT(AlarmsBitmask,                          uint16_t,    "");
+LABEL_TRAIT(BalancingEnabled,                       bool,        "");
+LABEL_TRAIT(CellAmountSetting,                      uint8_t,     "");
+LABEL_TRAIT(BatteryCapacitySettingAmpHours,         uint32_t,    "Ah");
+LABEL_TRAIT(BatteryChargeEnabled,                   bool,        "");
+LABEL_TRAIT(BatteryDischargeEnabled,                bool,        "");
+LABEL_TRAIT(DateOfManufacturing,                    std::string, "");
+LABEL_TRAIT(BmsSoftwareVersion,                     std::string, "");
+LABEL_TRAIT(BmsHardwareVersion,                     std::string, "");
+LABEL_TRAIT(ActualBatteryCapacityAmpHours,          uint32_t,    "Ah");
+#undef LABEL_TRAIT
+
+} /* namespace JbdBms */
+
+using JbdBmsDataPoint = DataPoint<bool, uint8_t, uint16_t, uint32_t,
+              int16_t, int32_t, std::string, JbdBms::tCells>;
+
+template class DataPointContainer<JbdBmsDataPoint, JbdBms::DataPointLabel, JbdBms::DataPointLabelTraits>;
+
+namespace JbdBms {
+    using DataPointContainer = DataPointContainer<JbdBmsDataPoint, DataPointLabel, DataPointLabelTraits>;
+} /* namespace JbdBms */
diff --git a/include/JbdBmsSerialMessage.h b/include/JbdBmsSerialMessage.h
new file mode 100644
index 00000000..6376ca31
--- /dev/null
+++ b/include/JbdBmsSerialMessage.h
@@ -0,0 +1,96 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <Arduino.h>
+
+#include "JbdBmsDataPoints.h"
+
+namespace JbdBms {
+
+// Only valid for receiving messages
+class SerialMessage {
+    public:
+        using tData = std::vector<uint8_t>;
+
+        SerialMessage() = delete;
+
+        enum class Command : uint8_t {
+            Init = 0x00,
+            ReadBasicInformation = 0x03,
+            ReadCellVoltages = 0x04,
+            ReadHardwareVersionNumber = 0x05,
+            ControlMosInstruction = 0xE1,
+        };
+
+        uint8_t getStartMarker() const { return _raw[0]; }
+        virtual Command getCommand() const = 0;
+        uint8_t getDataLength() const { return _raw[3]; }
+        uint16_t getChecksum() const { return get<uint16_t>(_raw.cend()-3); }
+        uint8_t getEndMarker() const { return *(_raw.cend()-1); }
+        void printMessage();
+
+        bool isValid() const;
+
+        uint8_t const* data() { return _raw.data(); }
+        size_t size() { return _raw.size(); }
+
+        static constexpr uint8_t startMarker = 0xDD;
+        static constexpr uint8_t endMarker = 0x77;
+
+    protected:
+        template <typename... Args>
+        explicit SerialMessage(Args&&... args) : _raw(std::forward<Args>(args)...) { }
+
+        template<typename T, typename It> T get(It&& pos) const;
+        template<typename It> bool getBool(It&& pos) const;
+        template<typename It> int16_t getTemperature(It&& pos) const;
+        template<typename It> std::string getString(It&& pos, size_t len, bool replaceZeroes = false) const;
+        template<typename It> std::string getProductionDate(It&& pos) const;
+        template<typename T> void set(tData::iterator const& pos, T val);
+        uint16_t calcChecksum() const;
+        void updateChecksum();
+
+        tData _raw;
+        JbdBms::DataPointContainer _dp;
+};
+
+class SerialResponse : public SerialMessage {
+    public:
+        enum class Status : uint8_t {
+            Ok = 0x00,
+            Error = 0x80
+        };
+
+        using tData = SerialMessage::tData;
+        explicit SerialResponse(tData&& raw);
+
+        Command getCommand() const { return static_cast<Command>(_raw[1]); }
+        Status getStatus() const { return static_cast<Status>(_raw[2]); }
+
+        bool isValid() const;
+
+        DataPointContainer const& getDataPoints() const { return _dp; }
+};
+
+class SerialCommand : public SerialMessage {
+    public:
+        enum class Status : uint8_t {
+            Read = 0xA5,
+            Write = 0x5A,
+        };
+
+        explicit SerialCommand(Status status, Command cmd);
+
+        Status getStatus() const { return static_cast<Status>(_raw[1]); }
+        Command getCommand() const { return static_cast<Command>(_raw[2]); }
+        static Command getLastCommand() { return _lastCmd; }
+
+        bool isValid() const;
+
+    private:
+        static Command _lastCmd;
+};
+
+
+} /* namespace JbdBms */
diff --git a/include/JkBmsController.h b/include/JkBmsController.h
index 1c31c6e3..b2c71c45 100644
--- a/include/JkBmsController.h
+++ b/include/JkBmsController.h
@@ -5,13 +5,12 @@
 #include <frozen/string.h>
 
 #include "Battery.h"
+#include "JkBmsDataPoints.h"
 #include "JkBmsSerialMessage.h"
 #include "JkBmsDummy.h"
 
 //#define JKBMS_DUMMY_SERIAL
 
-class DataPointContainer;
-
 namespace JkBms {
 
 class Controller : public BatteryProvider {
diff --git a/include/JkBmsDataPoints.h b/include/JkBmsDataPoints.h
index b8c1a0b5..cd9923b5 100644
--- a/include/JkBmsDataPoints.h
+++ b/include/JkBmsDataPoints.h
@@ -2,13 +2,11 @@
 
 #include <Arduino.h>
 #include <map>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <variant>
 #include <frozen/map.h>
 #include <frozen/string.h>
 
+#include "DataPoints.h"
+
 namespace JkBms {
 
 #define ALARM_BITS(fnc) \
@@ -121,7 +119,7 @@ enum class DataPointLabel : uint8_t {
     ProtocolVersion = 0xc0
 };
 
-using tCells = std::map<uint8_t, uint16_t>;
+using tCells = tCellVoltages;
 
 template<DataPointLabel> struct DataPointLabelTraits;
 
@@ -206,99 +204,13 @@ LABEL_TRAIT(ProductId,                              std::string, "");
 LABEL_TRAIT(ProtocolVersion,                        uint8_t,     "");
 #undef LABEL_TRAIT
 
-class DataPoint {
-    friend class DataPointContainer;
-
-    public:
-        using tValue = std::variant<bool, uint8_t, uint16_t, uint32_t,
-              int16_t, int32_t, std::string, tCells>;
-
-        DataPoint() = delete;
-
-        DataPoint(DataPoint const& other)
-            : _strLabel(other._strLabel)
-            , _strValue(other._strValue)
-            , _strUnit(other._strUnit)
-            , _value(other._value)
-            , _timestamp(other._timestamp) { }
-
-        DataPoint(std::string const& strLabel, std::string const& strValue,
-                std::string const& strUnit, tValue value, uint32_t timestamp)
-            : _strLabel(strLabel)
-            , _strValue(strValue)
-            , _strUnit(strUnit)
-            , _value(std::move(value))
-            , _timestamp(timestamp) { }
-
-        std::string const& getLabelText() const { return _strLabel; }
-        std::string const& getValueText() const { return _strValue; }
-        std::string const& getUnitText() const { return _strUnit; }
-        uint32_t getTimestamp() const { return _timestamp; }
-
-        bool operator==(DataPoint const& other) const {
-            return _value == other._value;
-        }
-
-    private:
-        std::string _strLabel;
-        std::string _strValue;
-        std::string _strUnit;
-        tValue _value;
-        uint32_t _timestamp;
-};
-
-template<typename T> std::string dataPointValueToStr(T const& v);
-
-class DataPointContainer {
-    public:
-        DataPointContainer() = default;
-
-        using Label = DataPointLabel;
-        template<Label L> using Traits = JkBms::DataPointLabelTraits<L>;
-
-        template<Label L>
-        void add(typename Traits<L>::type val) {
-            _dataPoints.emplace(
-                    L,
-                    DataPoint(
-                        Traits<L>::name,
-                        dataPointValueToStr(val),
-                        Traits<L>::unit,
-                        DataPoint::tValue(std::move(val)),
-                        millis()
-                    )
-            );
-        }
-
-        // make sure add() is only called with the type expected for the
-        // respective label, no implicit conversions allowed.
-        template<Label L, typename T>
-        void add(T) = delete;
-
-        template<Label L>
-        std::optional<DataPoint const> getDataPointFor() const {
-            auto it = _dataPoints.find(L);
-            if (it == _dataPoints.end()) { return std::nullopt; }
-            return it->second;
-        }
-
-        template<Label L>
-        std::optional<typename Traits<L>::type> get() const {
-            auto optionalDataPoint = getDataPointFor<L>();
-            if (!optionalDataPoint.has_value()) { return std::nullopt; }
-            return std::get<typename Traits<L>::type>(optionalDataPoint->_value);
-        }
-
-        using tMap = std::unordered_map<Label, DataPoint const>;
-        tMap::const_iterator cbegin() const { return _dataPoints.cbegin(); }
-        tMap::const_iterator cend() const { return _dataPoints.cend(); }
-
-        // copy all data points from source into this instance, overwriting
-        // existing data points in this instance.
-        void updateFrom(DataPointContainer const& source);
-
-    private:
-        tMap _dataPoints;
-};
-
+} /* namespace JkBms */
+
+using JkBmsDataPoint = DataPoint<bool, uint8_t, uint16_t, uint32_t,
+              int16_t, int32_t, std::string, JkBms::tCells>;
+
+template class DataPointContainer<JkBmsDataPoint, JkBms::DataPointLabel, JkBms::DataPointLabelTraits>;
+
+namespace JkBms {
+    using DataPointContainer = DataPointContainer<JkBmsDataPoint, DataPointLabel, DataPointLabelTraits>;
 } /* namespace JkBms */
diff --git a/include/PowerLimiter.h b/include/PowerLimiter.h
index c55d1d4b..e7cd3063 100644
--- a/include/PowerLimiter.h
+++ b/include/PowerLimiter.h
@@ -2,9 +2,11 @@
 #pragma once
 
 #include "Configuration.h"
+#include "PowerLimiterInverter.h"
 #include <espMqttClient.h>
 #include <Arduino.h>
-#include <Hoymiles.h>
+#include <atomic>
+#include <deque>
 #include <memory>
 #include <functional>
 #include <optional>
@@ -18,6 +20,8 @@
 
 class PowerLimiterClass {
 public:
+    PowerLimiterClass() = default;
+
     enum class Status : unsigned {
         Initializing,
         DisabledByConfig,
@@ -25,25 +29,19 @@ public:
         WaitingForValidTimestamp,
         PowerMeterPending,
         InverterInvalid,
-        InverterChanged,
-        InverterOffline,
-        InverterCommandsDisabled,
-        InverterLimitPending,
-        InverterPowerCmdPending,
-        InverterDevInfoPending,
+        InverterCmdPending,
+        ConfigReload,
         InverterStatsPending,
-        CalculatedLimitBelowMinLimit,
+        FullSolarPassthrough,
         UnconditionalSolarPassthrough,
-        NoVeDirect,
-        NoEnergy,
-        HuaweiPsu,
         Stable,
     };
 
     void init(Scheduler& scheduler);
-    uint8_t getInverterUpdateTimeouts() const { return _inverterUpdateTimeouts; }
+    void triggerReloadingConfig() { _reloadConfigFlag = true; }
+    uint8_t getInverterUpdateTimeouts() const;
     uint8_t getPowerLimiterState();
-    int32_t getLastRequestedPowerLimit() { return _lastRequestedPowerLimit; }
+    int32_t getInverterOutput() { return _lastExpectedInverterOutput; }
     bool getFullSolarPassThroughEnabled() const { return _fullSolarPassThroughEnabled; }
 
     enum class Mode : unsigned {
@@ -54,54 +52,54 @@ public:
 
     void setMode(Mode m) { _mode = m; }
     Mode getMode() const { return _mode; }
-    void calcNextInverterRestart();
+    bool usesBatteryPoweredInverter();
+    bool isGovernedInverterProducing();
 
 private:
     void loop();
 
     Task _loopTask;
 
-    int32_t _lastRequestedPowerLimit = 0;
-    bool _shutdownPending = false;
-    std::optional<uint32_t> _oInverterStatsMillis = std::nullopt;
-    std::optional<uint32_t> _oUpdateStartMillis = std::nullopt;
-    std::optional<int32_t> _oTargetPowerLimitWatts = std::nullopt;
-    std::optional<bool> _oTargetPowerState = std::nullopt;
+    std::atomic<bool> _reloadConfigFlag = true;
+    uint16_t _lastExpectedInverterOutput = 0;
     Status _lastStatus = Status::Initializing;
     uint32_t _lastStatusPrinted = 0;
     uint32_t _lastCalculation = 0;
     static constexpr uint32_t _calculationBackoffMsDefault = 128;
     uint32_t _calculationBackoffMs = _calculationBackoffMsDefault;
     Mode _mode = Mode::Normal;
-    std::shared_ptr<InverterAbstract> _inverter = nullptr;
+
+    std::deque<std::unique_ptr<PowerLimiterInverter>> _inverters;
     bool _batteryDischargeEnabled = false;
     bool _nighttimeDischarging = false;
-    uint32_t _nextInverterRestart = 0; // Values: 0->not calculated / 1->no restart configured / >1->time of next inverter restart in millis()
-    uint32_t _nextCalculateCheck = 5000; // time in millis for next NTP check to calulate restart
+    std::pair<bool, uint32_t> _nextInverterRestart = { false, 0 };
     bool _fullSolarPassThroughEnabled = false;
     bool _verboseLogging = true;
-    uint8_t _inverterUpdateTimeouts = 0;
 
     frozen::string const& getStatusText(Status status);
     void announceStatus(Status status);
     bool shutdown(Status status);
-    bool shutdown() { return shutdown(_lastStatus); }
+    void reloadConfig();
+    std::pair<float, char const*> getInverterDcVoltage();
     float getBatteryVoltage(bool log = false);
-    int32_t inverterPowerDcToAc(std::shared_ptr<InverterAbstract> inverter, int32_t dcPower);
-    void unconditionalSolarPassthrough(std::shared_ptr<InverterAbstract> inverter);
-    bool canUseDirectSolarPower();
-    bool calcPowerLimit(std::shared_ptr<InverterAbstract> inverter, int32_t solarPower, int32_t batteryPowerLimit, bool batteryPower);
-    bool updateInverter();
-    bool setNewPowerLimit(std::shared_ptr<InverterAbstract> inverter, int32_t newPowerLimit);
-    int32_t getSolarPower();
-    int32_t getBatteryDischargeLimit();
+    uint16_t solarDcToInverterAc(uint16_t dcPower);
+    void fullSolarPassthrough(PowerLimiterClass::Status reason);
+    int16_t calcHouseholdConsumption();
+    using inverter_filter_t = std::function<bool(PowerLimiterInverter const&)>;
+    uint16_t updateInverterLimits(uint16_t powerRequested, inverter_filter_t filter, std::string const& filterExpression);
+    uint16_t calcBatteryAllowance(uint16_t powerRequested);
+    bool updateInverters();
+    uint16_t getSolarPassthroughPower();
+    std::optional<uint16_t> getBatteryDischargeLimit();
+    float getBatteryInvertersOutputAcWatts();
     float getLoadCorrectedVoltage();
     bool testThreshold(float socThreshold, float voltThreshold,
             std::function<bool(float, float)> compare);
     bool isStartThresholdReached();
     bool isStopThresholdReached();
     bool isBelowStopThreshold();
-    bool useFullSolarPassthrough();
+    void calcNextInverterRestart();
+    bool isFullSolarPassthroughActive();
 };
 
 extern PowerLimiterClass PowerLimiter;
diff --git a/include/PowerLimiterBatteryInverter.h b/include/PowerLimiterBatteryInverter.h
new file mode 100644
index 00000000..348a41f9
--- /dev/null
+++ b/include/PowerLimiterBatteryInverter.h
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include "PowerLimiterInverter.h"
+
+class PowerLimiterBatteryInverter : public PowerLimiterInverter {
+public:
+    PowerLimiterBatteryInverter(bool verboseLogging, PowerLimiterInverterConfig const& config);
+
+    uint16_t getMaxReductionWatts(bool allowStandby) const final;
+    uint16_t getMaxIncreaseWatts() const final;
+    uint16_t applyReduction(uint16_t reduction, bool allowStandby) final;
+    uint16_t applyIncrease(uint16_t increase) final;
+    uint16_t standby() final;
+    bool isSolarPowered() const final { return false; }
+
+private:
+    void setAcOutput(uint16_t expectedOutputWatts) final;
+};
diff --git a/include/PowerLimiterInverter.h b/include/PowerLimiterInverter.h
new file mode 100644
index 00000000..ccd1db12
--- /dev/null
+++ b/include/PowerLimiterInverter.h
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include "Configuration.h"
+#include <Hoymiles.h>
+#include <optional>
+#include <memory>
+
+class PowerLimiterInverter {
+public:
+    static std::unique_ptr<PowerLimiterInverter> create(bool verboseLogging, PowerLimiterInverterConfig const& config);
+
+    // send command(s) to inverter to reach desired target state (limit and
+    // production). return true if an update is pending, i.e., if the target
+    // state is NOT yet reached, false otherwise.
+    bool update();
+
+    // returns the timestamp of the oldest stats received for this inverter
+    // *after* its last command completed. return std::nullopt if new stats
+    // are pending after the last command completed.
+    std::optional<uint32_t> getLatestStatsMillis() const;
+
+    // the amount of times an update command issued to the inverter timed out
+    uint8_t getUpdateTimeouts() const { return _updateTimeouts; }
+
+    // maximum amount of AC power the inverter is able to produce
+    // (not regarding the configured upper power limit)
+    uint16_t getInverterMaxPowerWatts() const;
+
+    // maximum amount of AC power the inverter is allowed to produce as per
+    // upper power limit (additionally restricted by inverter's absolute max)
+    uint16_t getConfiguredMaxPowerWatts() const;
+
+    uint16_t getCurrentOutputAcWatts() const;
+
+    // this differs from current output power if new limit was assigned
+    uint16_t getExpectedOutputAcWatts() const;
+
+    // the maximum reduction of power output the inverter
+    // can achieve with or withouth going into standby.
+    virtual uint16_t getMaxReductionWatts(bool allowStandby) const = 0;
+
+    // the maximum increase of power output the inverter can achieve
+    // (is expected to achieve), possibly coming out of standby.
+    virtual uint16_t getMaxIncreaseWatts() const = 0;
+
+    // change the target limit such that the requested change becomes effective
+    // on the expected AC power output. returns the change in the range
+    // [0..reduction] that will become effective (once update() returns false).
+    virtual uint16_t applyReduction(uint16_t reduction, bool allowStandby) = 0;
+    virtual uint16_t applyIncrease(uint16_t increase) = 0;
+
+    // stop producing AC power. returns the change in power output
+    // that will become effective (once update() returns false).
+    virtual uint16_t standby() = 0;
+
+    // wake the inverter from standby and set it to produce
+    // as much power as permissible by its upper power limit.
+    void setMaxOutput();
+
+    void restart();
+
+    float getDcVoltage(uint8_t input);
+    bool isSendingCommandsEnabled() const { return _spInverter->getEnableCommands(); }
+    bool isReachable() const { return _spInverter->isReachable(); }
+    bool isProducing() const { return _spInverter->isProducing(); }
+
+    uint64_t getSerial() const { return _config.Serial; }
+    char const* getSerialStr() const { return _serialStr; }
+    bool isBehindPowerMeter() const { return _config.IsBehindPowerMeter; }
+    virtual bool isSolarPowered() const = 0;
+
+    void debug() const;
+
+protected:
+    PowerLimiterInverter(bool verboseLogging, PowerLimiterInverterConfig const& config);
+
+    // returns false if the inverter cannot participate
+    // in achieving the requested change in power output
+    bool isEligible() const;
+
+    uint16_t getCurrentLimitWatts() const;
+
+    void setTargetPowerLimitWatts(uint16_t power) { _oTargetPowerLimitWatts = power; }
+    void setTargetPowerState(bool enable) { _oTargetPowerState = enable; }
+    void setExpectedOutputAcWatts(uint16_t power) { _expectedOutputAcWatts = power; }
+
+    // copied to avoid races with web UI
+    PowerLimiterInverterConfig _config;
+
+    // Hoymiles lib inverter instance
+    std::shared_ptr<InverterAbstract> _spInverter = nullptr;
+
+    bool _verboseLogging;
+    char _logPrefix[32];
+
+private:
+    virtual void setAcOutput(uint16_t expectedOutputWatts) = 0;
+
+    char _serialStr[16];
+
+    // track (target) state
+    uint8_t _updateTimeouts = 0;
+    std::optional<uint32_t> _oUpdateStartMillis = std::nullopt;
+    std::optional<uint16_t> _oTargetPowerLimitWatts = std::nullopt;
+    std::optional<bool> _oTargetPowerState = std::nullopt;
+    mutable std::optional<uint32_t> _oStatsMillis = std::nullopt;
+
+    // the expected AC output (possibly is different from the target limit)
+    uint16_t _expectedOutputAcWatts = 0;
+};
diff --git a/include/PowerLimiterSolarInverter.h b/include/PowerLimiterSolarInverter.h
new file mode 100644
index 00000000..72023211
--- /dev/null
+++ b/include/PowerLimiterSolarInverter.h
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include "PowerLimiterInverter.h"
+
+class PowerLimiterSolarInverter : public PowerLimiterInverter {
+public:
+    PowerLimiterSolarInverter(bool verboseLogging, PowerLimiterInverterConfig const& config);
+
+    uint16_t getMaxReductionWatts(bool allowStandby) const final;
+    uint16_t getMaxIncreaseWatts() const final;
+    uint16_t applyReduction(uint16_t reduction, bool allowStandby) final;
+    uint16_t applyIncrease(uint16_t increase) final;
+    uint16_t standby() final;
+    bool isSolarPowered() const final { return true; }
+
+private:
+    uint16_t scaleLimit(uint16_t expectedOutputWatts);
+    void setAcOutput(uint16_t expectedOutputWatts) final;
+};
diff --git a/include/Utils.h b/include/Utils.h
index 150294fb..51ab5a48 100644
--- a/include/Utils.h
+++ b/include/Utils.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include <ArduinoJson.h>
+#include <LittleFS.h>
 #include <cstdint>
 #include <utility>
 
@@ -12,6 +13,8 @@ public:
     static int getTimezoneOffset();
     static bool checkJsonAlloc(const JsonDocument& doc, const char* function, const uint16_t line);
     static void removeAllFiles();
+    static String generateMd5FromFile(String file);
+    static void skipBom(File& f);
 
     /* OpenDTU-OnBatter-specific utils go here: */
     template<typename T>
diff --git a/include/VictronMppt.h b/include/VictronMppt.h
index 963a46cd..e79564e8 100644
--- a/include/VictronMppt.h
+++ b/include/VictronMppt.h
@@ -42,6 +42,17 @@ public:
     // minimum of all MPPT charge controllers' output voltages in V
     float getOutputVoltage() const;
 
+    // returns the state of operation from the first available controller
+    std::optional<uint8_t> getStateOfOperation() const;
+
+    // returns the requested value from the first available controller in mV
+    enum class MPPTVoltage : uint8_t {
+            ABSORPTION = 0,
+            FLOAT = 1,
+            BATTERY = 2
+    };
+    std::optional<float> getVoltage(MPPTVoltage kindOf) const;
+
 private:
     void loop();
     VictronMpptClass(VictronMpptClass const& other) = delete;
diff --git a/include/WebApi.h b/include/WebApi.h
index c995ecfc..07ffaa22 100644
--- a/include/WebApi.h
+++ b/include/WebApi.h
@@ -2,14 +2,15 @@
 #pragma once
 
 #include "WebApi_battery.h"
-#include "WebApi_config.h"
 #include "WebApi_device.h"
 #include "WebApi_devinfo.h"
 #include "WebApi_dtu.h"
 #include "WebApi_errors.h"
 #include "WebApi_eventlog.h"
+#include "WebApi_file.h"
 #include "WebApi_firmware.h"
 #include "WebApi_gridprofile.h"
+#include "WebApi_i18n.h"
 #include "WebApi_inverter.h"
 #include "WebApi_limit.h"
 #include "WebApi_maintenance.h"
@@ -55,13 +56,14 @@ private:
     AsyncWebServer _server;
 
     WebApiBatteryClass _webApiBattery;
-    WebApiConfigClass _webApiConfig;
     WebApiDeviceClass _webApiDevice;
     WebApiDevInfoClass _webApiDevInfo;
     WebApiDtuClass _webApiDtu;
     WebApiEventlogClass _webApiEventlog;
+    WebApiFileClass _webApiFile;
     WebApiFirmwareClass _webApiFirmware;
     WebApiGridProfileClass _webApiGridprofile;
+    WebApiI18nClass _webApiI18n;
     WebApiInverterClass _webApiInverter;
     WebApiLimitClass _webApiLimit;
     WebApiMaintenanceClass _webApiMaintenance;
diff --git a/include/WebApi_config.h b/include/WebApi_config.h
deleted file mode 100644
index f29dc8fc..00000000
--- a/include/WebApi_config.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include <ESPAsyncWebServer.h>
-#include <TaskSchedulerDeclarations.h>
-
-class WebApiConfigClass {
-public:
-    void init(AsyncWebServer& server, Scheduler& scheduler);
-
-private:
-    void onConfigGet(AsyncWebServerRequest* request);
-    void onConfigDelete(AsyncWebServerRequest* request);
-    void onConfigListGet(AsyncWebServerRequest* request);
-    void onConfigUploadFinish(AsyncWebServerRequest* request);
-    void onConfigUpload(AsyncWebServerRequest* request, String filename, size_t index, uint8_t* data, size_t len, bool final);
-};
diff --git a/include/WebApi_errors.h b/include/WebApi_errors.h
index 89118c4d..de74b976 100644
--- a/include/WebApi_errors.h
+++ b/include/WebApi_errors.h
@@ -18,9 +18,10 @@ enum WebApiError {
     DtuInvalidCmtFrequency,
     DtuInvalidCmtCountry,
 
-    ConfigBase = 3000,
-    ConfigNotDeleted,
-    ConfigSuccess,
+    FileBase = 3000,
+    FileNotDeleted,
+    FileSuccess,
+    FileDeleteSuccess,
 
     InverterBase = 4000,
     InverterSerialZero,
diff --git a/include/WebApi_file.h b/include/WebApi_file.h
new file mode 100644
index 00000000..ce958b05
--- /dev/null
+++ b/include/WebApi_file.h
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <ESPAsyncWebServer.h>
+#include <TaskSchedulerDeclarations.h>
+
+class WebApiFileClass {
+public:
+    void init(AsyncWebServer& server, Scheduler& scheduler);
+
+private:
+    void onFileGet(AsyncWebServerRequest* request);
+    void onFileDelete(AsyncWebServerRequest* request);
+    void onFileDeleteAll(AsyncWebServerRequest* request);
+    void onFileListGet(AsyncWebServerRequest* request);
+    void onFileUploadFinish(AsyncWebServerRequest* request);
+    void onFileUpload(AsyncWebServerRequest* request, String filename, size_t index, uint8_t* data, size_t len, bool final);
+};
diff --git a/include/WebApi_i18n.h b/include/WebApi_i18n.h
new file mode 100644
index 00000000..237e4473
--- /dev/null
+++ b/include/WebApi_i18n.h
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <ESPAsyncWebServer.h>
+#include <TaskSchedulerDeclarations.h>
+
+class WebApiI18nClass {
+public:
+    void init(AsyncWebServer& server, Scheduler& scheduler);
+
+private:
+    void onI18nLanguages(AsyncWebServerRequest* request);
+    void onI18nLanguage(AsyncWebServerRequest* request);
+};
diff --git a/include/defaults.h b/include/defaults.h
index 2ab8ec9e..b1bd81a1 100644
--- a/include/defaults.h
+++ b/include/defaults.h
@@ -102,7 +102,7 @@
 #define DISPLAY_SCREENSAVER true
 #define DISPLAY_ROTATION 2U
 #define DISPLAY_CONTRAST 60U
-#define DISPLAY_LANGUAGE 0U
+#define DISPLAY_LOCALE "en"
 #define DISPLAY_DIAGRAM_DURATION (10UL * 60UL * 60UL)
 #define DISPLAY_DIAGRAM_MODE 1U
 
@@ -112,6 +112,8 @@
 
 #define MAX_INVERTER_LIMIT 2250
 
+#define LANG_PACK_SUFFIX ".lang.json"
+
 // values specific to downstream project OpenDTU-OnBattery start here:
 #define VEDIRECT_ENABLED false
 #define VEDIRECT_VERBOSE_LOGGING false
@@ -128,18 +130,16 @@
 #define POWERLIMITER_SOLAR_PASSTHROUGH_ENABLED true
 #define POWERLIMITER_SOLAR_PASSTHROUGH_LOSSES 3
 #define POWERLIMITER_BATTERY_ALWAYS_USE_AT_NIGHT false
-#define POWERLIMITER_INTERVAL 10
 #define POWERLIMITER_IS_INVERTER_BEHIND_POWER_METER true
 #define POWERLIMITER_IS_INVERTER_SOLAR_POWERED false
 #define POWERLIMITER_USE_OVERSCALING_TO_COMPENSATE_SHADING false
-#define POWERLIMITER_INVERTER_ID 0ULL
 #define POWERLIMITER_INVERTER_CHANNEL_ID 0
 #define POWERLIMITER_TARGET_POWER_CONSUMPTION 0
 #define POWERLIMITER_TARGET_POWER_CONSUMPTION_HYSTERESIS 0
 #define POWERLIMITER_LOWER_POWER_LIMIT 10
 #define POWERLIMITER_BASE_LOAD_LIMIT 100
 #define POWERLIMITER_UPPER_POWER_LIMIT 800
-#define POWERLIMITER_IGNORE_SOC false
+#define POWERLIMITER_IGNORE_SOC true
 #define POWERLIMITER_BATTERY_SOC_START_THRESHOLD 80
 #define POWERLIMITER_BATTERY_SOC_STOP_THRESHOLD 20
 #define POWERLIMITER_VOLTAGE_START_THRESHOLD 50.0
@@ -156,6 +156,8 @@
 #define BATTERY_JKBMS_POLLING_INTERVAL 5
 #define BATTERY_ENABLE_DISCHARGE_CURRENT_LIMIT false
 #define BATTERY_DISCHARGE_CURRENT_LIMIT 0.0
+#define BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_SOC 100.0
+#define BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_VOLTAGE 60.0
 #define BATTERY_USE_BATTERY_REPORTED_DISCHARGE_CURRENT_LIMIT false
 
 #define HUAWEI_ENABLED false
diff --git a/lang/README.md b/lang/README.md
new file mode 100644
index 00000000..530e87e2
--- /dev/null
+++ b/lang/README.md
@@ -0,0 +1,9 @@
+# Language Packs
+
+This folder contains language packs for OpenDTU which can be uploaded to the
+device using the "Config Management" function.
+Select "Language Pack" in the restore section, select a `.json` file containing
+your language and press "Restore". Afterwards all language selection drop down
+menues contain the new language.
+
+Create a pull to request to share your own language pack (or corrections) with the community.
diff --git a/lang/es.lang.json b/lang/es.lang.json
new file mode 100644
index 00000000..629b9799
--- /dev/null
+++ b/lang/es.lang.json
@@ -0,0 +1,690 @@
+{
+    "meta": {
+        "name": "Español",
+        "code": "es"
+    },
+    "display": {
+        "date_format": "%d/%m/%Y %H:%M",
+        "offline": "Apagado",
+        "power_w": "%.0f W",
+        "power_kw": "%.1f kW",
+        "yield_today_wh": "Hoy: %4.0f Wh",
+        "yield_today_kwh": "Hoy: %.1f kWh",
+        "yield_total_kwh": "Total: %.1f kWh",
+        "yield_total_mwh": "Total: %.0f kWh"
+    },
+    "webapp": {
+        "menu": {
+            "LiveView": "Vista en directo",
+            "Settings": "Ajustes",
+            "NetworkSettings": "Ajustes de Red",
+            "NTPSettings": "Ajustes NTP",
+            "MQTTSettings": "Ajustes MQTT",
+            "InverterSettings": "Ajustes Inversor",
+            "SecuritySettings": "Ajustes Seguridad",
+            "DTUSettings": "Ajustes DTU",
+            "DeviceManager": "Administrador Dispositivos",
+            "ConfigManagement": "Gestión configuración",
+            "FirmwareUpgrade": "Actualización Firmware",
+            "DeviceReboot": "Reinicio Dispositivo",
+            "Info": "Info",
+            "System": "Sistema",
+            "Network": "Red",
+            "NTP": "NTP",
+            "MQTT": "MQTT",
+            "Console": "Consola",
+            "About": "Acerca",
+            "Logout": "Logout",
+            "Login": "Login"
+        },
+        "base": {
+            "Loading": "Cargando...",
+            "Reload": "Recargar",
+            "Cancel": "Cancelar",
+            "Save": "Guardar",
+            "Refreshing": "Refrescando",
+            "Pull": "Tira hacia abajo para refrescar",
+            "Release": "Soltar para refrescar",
+            "Close": "Cerrar"
+        },
+        "wait": {
+            "NotReady": "OpenDTU is not yet ready",
+            "PleaseWait": "Please wait. You will be automatically redirected to the home page."
+        },
+        "Error": {
+            "Oops": "Oops!"
+        },
+        "localeswitcher": {
+            "Dark": "Oscuro",
+            "Light": "Claro",
+            "Auto": "Automático"
+        },
+        "apiresponse": {
+            "1001": "¡Opciones guardadas!",
+            "1002": "No se encontraron valores",
+            "1003": "Datos demasiado grandes",
+            "1004": "Fallo al procesar los datos",
+            "1005": "Faltan valores",
+            "1006": "Fallo en la escritura",
+            "2001": "¡El número de serie no puede ser cero!",
+            "2002": "Intervalo de Poll interval debe ser mayor que cero!",
+            "2003": "Configuración de potencia incorrecta!",
+            "2004": "La frecuencia debe estar entre {min} y {max} kHz y debe ser un múltiplo de 250 kHz!",
+            "2005": "Modelo desconocido! Por favor, informe el \"Modelo de pieza de hardware\" y el modelo (por ejemplo, HM-350) como un problema en <a href=\"https://github.com/tbnobody/OpenDTU/issues\" target=\"_blank\">aquí</a>.",
+            "3001": "No se eliminó nada",
+            "3002": "Configuración borrada. Reinicio en curso...",
+            "4001": "@:apiresponse.2001",
+            "4002": "El nombre debe tener entre 1 y {max} caracteres de longitud!",
+            "4003": "Solo se admiten {max} inversores!",
+            "4004": "Inversor creado!",
+            "4005": "ID no válido especificado",
+            "4006": "Cantidad de canales máxima incorrecta dada!",
+            "4007": "Inversor modificado!",
+            "4008": "Inversor eliminado!",
+            "4009": "Orden de inversores guardado!",
+            "5001": "@:apiresponse.2001",
+            "5002": "Límite debe estar entre 1 y {max}!",
+            "5003": "Tipo incorrecto especificado!",
+            "5004": "Inversor incorrecto especificado!",
+            "6001": "Reinicio desencadenado!",
+            "6002": "Reinicio cancelado!",
+            "7001": "¡El servidor MQTT debe tener entre 1 y {max} caracteres de longitud!",
+            "7002": "¡El nombre de usuario debe no tener más de {max} caracteres!",
+            "7003": "¡La contraseña debe no tener más de {max} caracteres!",
+            "7004": "¡El tema debe tener entre 1 y {max} caracteres de longitud!",
+            "7005": "¡El tema no debe contener caracteres de espacio!",
+            "7006": "¡El tema debe terminar con barra inclinada (/)!",
+            "7007": "¡El puerto debe ser un número entre 1 y 65535!",
+            "7008": "¡El certificado debe tener entre 1 y {max} caracteres de longitud!",
+            "7009": "¡El tema LWT debe tener entre 1 y {max} caracteres de longitud!",
+            "7010": "¡El tema LWT no debe contener caracteres de espacio!",
+            "7011": "¡El valor LWT en línea debe tener entre 1 y {max} caracteres de longitud!",
+            "7012": "¡El valor LWT fuera de línea debe tener entre 1 y {max} caracteres de longitud!",
+            "7013": "¡El intervalo de publicación debe ser un número entre {min} y {max}!",
+            "7014": "¡El tema Hass debe tener entre 1 y {max} caracteres de longitud!",
+            "7015": "¡El tema Hass no debe contener caracteres de espacio!",
+            "7016": "¡La QoS LWT no debe ser mayor que {max}!",
+            "7017": "Client ID must not longer then {max} characters!",
+            "8001": "¡La dirección IP no es válida!",
+            "8002": "¡La máscara de red no es válida!",
+            "8003": "¡El gateway no es válido!",
+            "8004": "¡La dirección IP del servidor DNS 1 no es válida!",
+            "8005": "¡La dirección IP del servidor DNS 2 no es válida!",
+            "8006": "¡El valor de tiempo de espera del punto de acceso administrativo es inválido!",
+            "9001": "¡El servidor NTP debe tener entre 1 y {max} caracteres de longitud!",
+            "9002": "¡La zona horaria debe tener entre 1 y {max} caracteres de longitud!",
+            "9003": "¡La descripción de la zona horaria debe tener entre 1 y {max} caracteres de longitud!",
+            "9004": "¡El año debe ser un número entre {min} y {max}!",
+            "9005": "¡El mes debe ser un número entre {min} y {max}!",
+            "9006": "¡El día debe ser un número entre {min} y {max}!",
+            "9007": "¡La hora debe ser un número entre {min} y {max}!",
+            "9008": "¡Los minutos deben ser un número entre {min} y {max}!",
+            "9009": "¡Los segundos deben ser un número entre {min} y {max}!",
+            "9010": "¡Hora actualizada!",
+            "10001": "¡La contraseña debe tener entre 8 y {max} caracteres de longitud!",
+            "10002": "¡Autenticación exitosa!",
+            "11001": "¡@:apiresponse.2001",
+            "11002": "¡@:apiresponse:5004",
+            "12001": "¡El perfil debe tener entre 1 y {max} caracteres de longitud!"
+        },
+        "home": {
+            "LiveData": "Datos en Vivo",
+            "SerialNumber": "Número de Serie: ",
+            "CurrentLimit": "Límite de Corriente: ",
+            "DataAge": "Edad de los Datos: ",
+            "Seconds": "{val} segundos",
+            "ShowSetInverterLimit": "Ver / Establecer Límite del Inversor",
+            "TurnOnOff": "Encender/Apagar el Inversor",
+            "ShowInverterInfo": "Ver Información del Inversor",
+            "ShowEventlog": "Ver Registro de Eventos",
+            "UnreadMessages": "mensajes sin leer",
+            "Loading": "@:base.Cargando",
+            "EventLog": "Registro de Eventos",
+            "InverterInfo": "Información del Inversor",
+            "LimitSettings": "Configuración de Límites",
+            "LastLimitSetStatus": "Último Estado de Configuración del Límite:",
+            "SetLimit": "Establecer Límite:",
+            "Relative": "Relativo (%)",
+            "Absolute": "Absoluto (W)",
+            "LimitHint": "<b>Consejo:</b> Si establece el límite como un valor absoluto, la visualización del valor actual solo se actualizará después de ~4 minutos.",
+            "SetPersistent": "Establecer Límite Permanente",
+            "SetNonPersistent": "Establecer Límite No Permanente",
+            "PowerSettings": "Configuración de Energía",
+            "LastPowerSetStatus": "Último Estado de Configuración de Energía:",
+            "TurnOn": "Encender",
+            "TurnOff": "Apagar",
+            "Restart": "Reiniciar",
+            "Failure": "Fallo",
+            "Pending": "Pendiente",
+            "Ok": "Aceptar",
+            "Unknown": "Desconocido",
+            "ShowGridProfile": "Ver Perfil de la Red",
+            "GridProfile": "Perfil de la Red",
+            "LoadingInverter": "Waiting for data... (can take up to 10 seconds)",
+            "RadioStats": "Radio Statistics",
+            "TxRequest": "TX Request Count",
+            "RxSuccess": "RX Success",
+            "RxFailNothing": "RX Fail: Receive Nothing",
+            "RxFailPartial": "RX Fail: Receive Partial",
+            "RxFailCorrupt": "RX Fail: Receive Corrupt",
+            "TxReRequest": "TX Re-Request Fragment",
+            "StatsReset": "Reset Statistics",
+            "StatsResetting": "Resetting...",
+            "Rssi": "RSSI of last received packet",
+            "RssiHint": "HM inverters only support RSSI values < -64 dBm and > -64 dBm. In this case, -80 dbm and -30 dbm is shown.",
+            "dBm": "{dbm} dBm"
+        },
+        "eventlog": {
+            "Start": "Iniciar",
+            "Stop": "Parar",
+            "Id": "ID",
+            "Message": "Mensaje"
+        },
+        "devinfo": {
+            "NoInfo": "Sin información disponible",
+            "NoInfoLong": "No se ha recibido ningún dato válido del inversor hasta ahora. Todavía estamos intentando...",
+            "UnknownModel": "¡Modelo desconocido! Por favor, informe el \"Número de parte de hardware\" y el modelo (por ejemplo, HM-350) como un problema <a href=\"https://github.com/tbnobody/OpenDTU/issues\" target=\"_blank\">aquí</a>.",
+            "Serial": "Número de serie",
+            "ProdYear": "Año de producción",
+            "ProdWeek": "Semana de producción",
+            "Model": "Modelo",
+            "DetectedMaxPower": "Potencia máxima detectada",
+            "BootloaderVersion": "Versión del cargador de arranque",
+            "FirmwareVersion": "Versión del firmware",
+            "FirmwareBuildDate": "Fecha de construcción del firmware",
+            "HardwarePartNumber": "Número de parte de hardware",
+            "HardwareVersion": "Versión de hardware"
+        },
+        "gridprofile": {
+            "NoInfo": "@:devinfo.NoInfo",
+            "NoInfoLong": "@:devinfo.NoInfoLong",
+            "Name": "Nombre",
+            "Version": "Versión",
+            "Enabled": "@:wifistationinfo.Enabled",
+            "Disabled": "@:wifistationinfo.Disabled",
+            "GridprofileSupport": "Apoyar el desarrollo",
+            "GridprofileSupportLong": "Por favor, consulte <a href=\"https://github.com/tbnobody/OpenDTU/wiki/Grid-Profile-Parser\" target=\"_blank\">aquí</a> para obtener más información."
+        },
+        "systeminfo": {
+            "SystemInfo": "Información del sistema",
+            "VersionError": "Error al obtener información de la versión",
+            "VersionNew": "¡Nueva versión disponible! ¡Mostrar cambios!",
+            "VersionOk": "¡Actualizado!"
+        },
+        "firmwareinfo": {
+            "FirmwareInformation": "Información del firmware",
+            "Hostname": "Hostname",
+            "SdkVersion": "Versión del SDK",
+            "ConfigVersion": "Versión de la configuración",
+            "FirmwareVersion": "Versión del firmware / Hash de Git",
+            "PioEnv": "Entorno PIO",
+            "FirmwareVersionHint": "Haga clic aquí para mostrar información sobre su versión actual",
+            "FirmwareUpdate": "Actualización de firmware",
+            "FirmwareUpdateHint": "Haga clic aquí para ver las diferencias entre su versión y la última versión",
+            "FrmwareUpdateAllow": "Al activar la comprobación de actualización, se envía una solicitud a GitHub.com cada vez que se llama a la página para recuperar la versión actualmente disponible. Si no está de acuerdo con esto, deje esta función desactivada.",
+            "ResetReason0": "Razón de reinicio CPU 0",
+            "ResetReason1": "Razón de reinicio CPU 1",
+            "ConfigSaveCount": "Contador de guardado de configuración",
+            "Uptime": "Tiempo de actividad",
+            "UptimeValue": "0 días {time} | 1 día {time} | {count} días {time}"
+        },
+        "hardwareinfo": {
+            "HardwareInformation": "Información del hardware",
+            "ChipModel": "Modelo de chip",
+            "ChipRevision": "Revisión de chip",
+            "ChipCores": "Núcleos del chip",
+            "CpuFrequency": "Frecuencia de la CPU",
+            "Mhz": "MHz",
+            "CpuTemperature": "CPU Temperature",
+            "FlashSize": "Flash Memory Size"
+        },
+        "memoryinfo": {
+            "MemoryInformation": "Información de la memoria",
+            "Type": "Tipo",
+            "Usage": "Uso",
+            "Free": "Libre",
+            "Used": "Usado",
+            "Size": "Tamaño",
+            "Heap": "Montón",
+            "PsRam": "PSRAM",
+            "LittleFs": "LittleFs",
+            "Sketch": "Boceto"
+        },
+        "heapdetails": {
+            "HeapDetails": "Detalles del montón",
+            "TotalFree": "Total libre",
+            "LargestFreeBlock": "Bloque libre contiguo más grande",
+            "MaxUsage": "Uso máximo desde el inicio",
+            "Fragmentation": "Nivel de fragmentación"
+        },
+        "taskdetails": {
+            "TaskDetails": "Task Details",
+            "Name": "Name",
+            "StackFree": "Stack Free",
+            "Priority": "Priority",
+            "Task_idle0": "Idle (CPU Core 0)",
+            "Task_idle1": "Idle (CPU Core 1)",
+            "Task_wifi": "Wi-Fi",
+            "Task_tit": "TCP/IP",
+            "Task_looptask": "Arduino Main Loop",
+            "Task_asynctcp": "Async TCP",
+            "Task_mqttclient": "MQTT Client",
+            "Task_huaweican0": "AC Charger CAN",
+            "Task_pmsdm": "PowerMeter (SDM)",
+            "Task_pmhttpjson": "PowerMeter (HTTP+JSON)",
+            "Task_pmsml": "PowerMeter (Serial SML)",
+            "Task_pmhttpsml": "PowerMeter (HTTP+SML)"
+        },
+        "radioinfo": {
+            "RadioInformation": "Información de la radio",
+            "Status": "Estado de {module}",
+            "ChipStatus": "Estado del chip de {module}",
+            "ChipType": "Tipo de chip de {module}",
+            "Connected": "conectado",
+            "NotConnected": "no conectado",
+            "Configured": "configurado",
+            "NotConfigured": "no configurado",
+            "Unknown": "Desconocido"
+        },
+        "networkinfo": {
+            "NetworkInformation": "Información de la red"
+        },
+        "wifistationinfo": {
+            "WifiStationInfo": "Información de WiFi (Estación)",
+            "Status": "Estado",
+            "Enabled": "habilitado",
+            "Disabled": "deshabilitado",
+            "Ssid": "SSID",
+            "Bssid": "BSSID",
+            "Quality": "Calidad",
+            "Rssi": "RSSI"
+        },
+        "wifiapinfo": {
+            "WifiApInfo": "Información de WiFi (Punto de acceso)",
+            "Status": "@:wifistationinfo.Status",
+            "Enabled": "@:wifistationinfo.Enabled",
+            "Disabled": "@:wifistationinfo.Disabled",
+            "Ssid": "@:wifistationinfo.Ssid",
+            "Stations": "# Estaciones"
+        },
+        "interfacenetworkinfo": {
+            "NetworkInterface": "Interfaz de red ({iface})",
+            "Hostname": "@:firmwareinfo.Hostname",
+            "IpAddress": "Dirección IP",
+            "Netmask": "Máscara de red",
+            "DefaultGateway": "Puerta de enlace predeterminada",
+            "Dns": "DNS {num}",
+            "MacAddress": "Dirección MAC"
+        },
+        "interfaceapinfo": {
+            "NetworkInterface": "Interfaz de red (Punto de acceso)",
+            "IpAddress": "@:interfacenetworkinfo.IpAddress",
+            "MacAddress": "@:interfacenetworkinfo.MacAddress"
+        },
+        "ntpinfo": {
+            "NtpInformation": "Información de NTP",
+            "ConfigurationSummary": "Resumen de configuración",
+            "Server": "Servidor",
+            "Timezone": "Zona horaria",
+            "TimezoneDescription": "Descripción de la zona horaria",
+            "CurrentTime": "Hora actual",
+            "Status": "Estado",
+            "Synced": "sincronizado",
+            "NotSynced": "no sincronizado",
+            "LocalTime": "Hora local",
+            "Sunrise": "Amanecer",
+            "Sunset": "Atardecer",
+            "NotAvailable": "No disponible",
+            "Mode": "Modo",
+            "Day": "Día",
+            "Night": "Noche"
+        },
+        "mqttinfo": {
+            "MqttInformation": "Información de MQTT",
+            "ConfigurationSummary": "@:ntpinfo.ConfigurationSummary",
+            "Status": "@:ntpinfo.Status",
+            "Enabled": "Habilitado",
+            "Disabled": "Deshabilitado",
+            "Server": "@:ntpinfo.Server",
+            "Port": "Puerto",
+            "ClientId": "Client ID",
+            "Username": "Nombre de usuario",
+            "BaseTopic": "Tema base",
+            "PublishInterval": "Intervalo de publicación",
+            "Seconds": "{sec} segundos",
+            "CleanSession": "Bandera CleanSession",
+            "Retain": "Retener",
+            "Tls": "TLS",
+            "RootCertifcateInfo": "Información del certificado raíz de CA",
+            "TlsCertLogin": "Iniciar sesión con certificado TLS",
+            "ClientCertifcateInfo": "Información del Certificado del Cliente",
+            "HassSummary": "Resumen de la Configuración de Descubrimiento Automático MQTT de Home Assistant",
+            "Expire": "Expirar",
+            "IndividualPanels": "Paneles Individuales",
+            "RuntimeSummary": "Resumen de Tiempo de Ejecución",
+            "ConnectionStatus": "Estado de Conexión",
+            "Connected": "conectado",
+            "Disconnected": "desconectado"
+        },
+        "console": {
+            "Console": "Consola",
+            "VirtualDebugConsole": "Consola de Depuración Virtual",
+            "EnableAutoScroll": "Habilitar Desplazamiento Automático",
+            "ClearConsole": "Limpiar Consola",
+            "CopyToClipboard": "Copiar al Portapapeles"
+        },
+        "inverterchannelinfo": {
+            "String": "Cadena {num}",
+            "Phase": "Fase {num}",
+            "General": "General"
+        },
+        "invertertotalinfo": {
+            "TotalYieldTotal": "Total de Rendimiento Acumulado",
+            "TotalYieldDay": "Total de Rendimiento del Día",
+            "TotalPower": "Potencia Total"
+        },
+        "inverterchannelproperty": {
+            "Power": "Potencia",
+            "Voltage": "Voltaje",
+            "Current": "Corriente",
+            "Power DC": "Potencia DC",
+            "YieldDay": "Rendimiento del Día",
+            "YieldTotal": "Rendimiento Total",
+            "Frequency": "Frecuencia",
+            "Temperature": "Temperatura",
+            "PowerFactor": "Factor de Potencia",
+            "ReactivePower": "Potencia Reactiva",
+            "Efficiency": "Eficiencia",
+            "Irradiation": "Irradiación"
+        },
+        "maintenancereboot": {
+            "DeviceReboot": "Reinicio del Dispositivo",
+            "PerformReboot": "Realizar Reinicio",
+            "Reboot": "¡Reiniciar!",
+            "Cancel": "@:base.Cancel",
+            "RebootOpenDTU": "Reiniciar OpenDTU",
+            "RebootQuestion": "¿Realmente desea reiniciar el dispositivo?",
+            "RebootHint": "<b>Nota:</b> Normalmente no es necesario realizar un reinicio manual. OpenDTU realiza cualquier reinicio necesario (por ejemplo, después de una actualización de firmware) automáticamente. También se adoptan configuraciones sin reiniciar. Si necesita reiniciar debido a un error, considere informarlo en <a href=\"https://github.com/tbnobody/OpenDTU/issues\" class=\"alert-link\" target=\"_blank\">https://github.com/tbnobody/OpenDTU/issues</a>."
+        },
+        "dtuadmin": {
+            "DtuSettings": "Configuración de DTU",
+            "DtuConfiguration": "Configuración de DTU",
+            "Serial": "Serial",
+            "SerialHint": "Tanto el inversor como el DTU tienen un número de serie. El número de serie del DTU se genera aleatoriamente en el primer inicio y generalmente no es necesario cambiarlo.",
+            "PollInterval": "Intervalo de Sondeo",
+            "Seconds": "Segundos",
+            "NrfPaLevel": "Potencia de Transmisión NRF24",
+            "CmtPaLevel": "Potencia de Transmisión CMT2300A",
+            "NrfPaLevelHint": "Utilizado para inversores HM. Asegúrese de que su fuente de alimentación sea lo suficientemente estable antes de aumentar la potencia de transmisión.",
+            "CmtPaLevelHint": "Utilizado para inversores HMS/HMT. Asegúrese de que su fuente de alimentación sea lo suficientemente estable antes de aumentar la potencia de transmisión.",
+            "CmtCountry": "Región/País CMT2300A",
+            "CmtCountryHint": "Cada país tiene asignaciones de frecuencia diferentes.",
+            "country_0": "Europa ({min}MHz - {max}MHz)",
+            "country_1": "América del Norte ({min}MHz - {max}MHz)",
+            "country_2": "Brasil ({min}MHz - {max}MHz)",
+            "CmtFrequency": "Frecuencia CMT2300A",
+            "CmtFrequencyHint": "¡Asegúrese de utilizar solo frecuencias permitidas en el país respectivo! Después de un cambio de frecuencia, puede tardar hasta 15 minutos en establecer una conexión.",
+            "CmtFrequencyWarning": "La frecuencia seleccionada está fuera del rango permitido en su región/país seleccionado. Asegúrese de que esta selección no infrinja ninguna regulación local.",
+            "MHz": "{mhz} MHz",
+            "dBm": "{dbm} dBm",
+            "Min": "Mínimo ({db} dBm)",
+            "Low": "Bajo ({db} dBm)",
+            "High": "Alto ({db} dBm)",
+            "Max": "Máximo ({db} dBm)"
+        },
+        "securityadmin": {
+            "SecuritySettings": "Configuración de Seguridad",
+            "AdminPassword": "Contraseña de Administrador",
+            "Password": "Contraseña",
+            "RepeatPassword": "Repetir Contraseña",
+            "PasswordHint": "<b>Consejo:</b> La contraseña de administrador se utiliza para acceder a esta interfaz web (usuario 'admin'), pero también para conectarse al dispositivo cuando está en modo AP. Debe tener 8 a 64 caracteres.",
+            "Permissions": "Permisos",
+            "ReadOnly": "Permitir acceso de solo lectura a la interfaz web sin contraseña"
+        },
+        "ntpadmin": {
+            "NtpSettings": "Configuración de NTP",
+            "NtpConfiguration": "Configuración de NTP",
+            "TimeServer": "Servidor de Tiempo",
+            "TimeServerHint": "El valor predeterminado es adecuado siempre que OpenDTU tenga acceso directo a Internet.",
+            "Timezone": "Zona Horaria",
+            "TimezoneConfig": "Configuración de Zona Horaria",
+            "LocationConfiguration": "Configuración de Ubicación",
+            "Longitude": "Longitud",
+            "Latitude": "Latitud",
+            "SunSetType": "Tipo de Atardecer",
+            "SunSetTypeHint": "Afecta al cálculo día/noche. Puede tardar hasta un minuto en aplicarse el nuevo tipo.",
+            "OFFICIAL": "Amanecer estándar (90.8°)",
+            "NAUTICAL": "Amanecer náutico (102°)",
+            "CIVIL": "Amanecer civil (96°)",
+            "ASTONOMICAL": "Amanecer astronómico (108°)",
+            "ManualTimeSynchronization": "Sincronización Manual del Tiempo",
+            "CurrentOpenDtuTime": "Hora Actual de OpenDTU",
+            "CurrentLocalTime": "Hora Local Actual",
+            "SynchronizeTime": "Sincronizar Tiempo",
+            "SynchronizeTimeHint": "<b>Consejo:</b> Puede utilizar la sincronización manual del tiempo para establecer la hora actual de OpenDTU si no hay un servidor NTP disponible. Pero tenga en cuenta que en caso de un ciclo de energía, se perderá la hora. Además, tenga en cuenta que la precisión del tiempo se verá gravemente afectada, ya que no se puede resincronizar regularmente y el microcontrolador ESP32 no tiene un reloj en tiempo real."
+        },
+        "networkadmin": {
+            "NetworkSettings": "Configuración de Red",
+            "WifiConfiguration": "Configuración de WiFi",
+            "WifiSsid": "SSID de WiFi",
+            "WifiPassword": "Contraseña de WiFi",
+            "Hostname": "Nombre de Host",
+            "HostnameHint": "<b>Consejo:</b> El texto <span class=\"font-monospace\">%06X</span> se remplazará con los últimos 6 dígitos del ChipID de ESP en formato hexadecimal.",
+            "EnableDhcp": "Habilitar DHCP",
+            "StaticIpConfiguration": "Configuración de IP Estática",
+            "IpAddress": "Dirección IP",
+            "Netmask": "Máscara de Red",
+            "DefaultGateway": "Puerta de Enlace Predeterminada",
+            "Dns": "Servidor DNS {num}",
+            "AdminAp": "Configuración de WiFi (Punto de Acceso de Administrador)",
+            "ApTimeout": "Tiempo de espera del Punto de Acceso",
+            "ApTimeoutHint": "Tiempo que se mantiene abierto el Punto de Acceso. Un valor de 0 significa infinito.",
+            "Minutes": "minutos",
+            "EnableMdns": "Habilitar mDNS",
+            "MdnsSettings": "Configuración de mDNS"
+        },
+        "mqttadmin": {
+            "MqttSettings": "Configuración de MQTT",
+            "MqttConfiguration": "Configuración de MQTT",
+            "EnableMqtt": "Habilitar MQTT",
+            "EnableHass": "Habilitar Descubrimiento Automático MQTT de Home Assistant",
+            "MqttBrokerParameter": "Parámetros del Broker MQTT",
+            "Hostname": "Nombre de Host",
+            "HostnameHint": "Nombre de host o dirección IP",
+            "Port": "Puerto",
+            "ClientId": "Client ID",
+            "Username": "Nombre de Usuario",
+            "UsernameHint": "Nombre de usuario, dejar vacío para conexión anónima",
+            "Password": "Contraseña",
+            "PasswordHint": "Contraseña, dejar vacío para conexión anónima",
+            "BaseTopic": "Tema Base",
+            "BaseTopicHint": "Tema base, se antepondrá a todos los temas publicados (por ejemplo, inverter/)",
+            "PublishInterval": "Intervalo de Publicación",
+            "Seconds": "segundos",
+            "CleanSession": "Habilitar Bandera CleanSession",
+            "EnableRetain": "Habilitar Bandera Retain",
+            "EnableTls": "Habilitar TLS",
+            "RootCa": "Certificado Raíz CA (predeterminado Letsencrypt)",
+            "TlsCertLoginEnable": "Habilitar Inicio de Sesión con Certificado TLS",
+            "ClientCert": "Certificado del Cliente TLS",
+            "ClientKey": "Clave del Cliente TLS",
+            "LwtParameters": "Parámetros de LWT",
+            "LwtTopic": "Tema de LWT",
+            "LwtTopicHint": "Tema de LWT, se añadirá al tema base",
+            "LwtOnline": "Mensaje de LWT en línea",
+            "LwtOnlineHint": "Mensaje que se publicará en el tema de LWT cuando esté en línea",
+            "LwtOffline": "Mensaje de LWT fuera de línea",
+            "LwtOfflineHint": "Mensaje que se publicará en el tema de LWT cuando esté fuera de línea",
+            "LwtQos": "QoS (Calidad de Servicio)",
+            "QOS0": "0 (Como máximo una vez)",
+            "QOS1": "1 (Al menos una vez)",
+            "QOS2": "2 (Exactamente una vez)",
+            "HassParameters": "Parámetros de Descubrimiento Automático MQTT de Home Assistant",
+            "HassPrefixTopic": "Tema de Prefijo",
+            "HassPrefixTopicHint": "El prefijo para el tema de descubrimiento",
+            "HassRetain": "Habilitar Bandera Retain",
+            "HassExpire": "Habilitar Expiración",
+            "HassIndividual": "Paneles Individuales"
+        },
+        "inverteradmin": {
+            "InverterSettings": "Configuración del Inversor",
+            "AddInverter": "Agregar un nuevo Inversor",
+            "Serial": "Serial",
+            "Name": "Nombre",
+            "Add": "Agregar",
+            "AddHint": "<b>Consejo:</b> Puede configurar parámetros adicionales después de haber creado el inversor. Use el ícono de lápiz en la lista de inversores.",
+            "InverterList": "Lista de Inversores",
+            "Status": "Estado",
+            "Send": "Enviar",
+            "Receive": "Recibir",
+            "StatusHint": "<b>Consejo:</b> El inversor se alimenta con su entrada de CC. Si no hay sol, el inversor está apagado. Aún se pueden enviar solicitudes.",
+            "Type": "Tipo",
+            "Action": "Acción",
+            "SaveOrder": "Guardar orden",
+            "DeleteInverter": "Eliminar inversor",
+            "EditInverter": "Editar inversor",
+            "General": "General",
+            "String": "Cadena",
+            "Advanced": "Avanzado",
+            "InverterSerial": "Serial del Inversor:",
+            "InverterName": "Nombre del Inversor:",
+            "InverterNameHint": "Aquí puede especificar un nombre personalizado para su inversor.",
+            "InverterStatus": "Recibir / Enviar",
+            "PollEnable": "Sondear datos del inversor",
+            "PollEnableNight": "Sondear datos del inversor por la noche",
+            "CommandEnable": "Enviar comandos",
+            "CommandEnableNight": "Enviar comandos por la noche",
+            "StringName": "Nombre de cadena {num}:",
+            "StringNameHint": "Aquí puede especificar un nombre personalizado para el puerto respectivo de su inversor.",
+            "StringMaxPower": "Potencia máxima de cadena {num}:",
+            "StringMaxPowerHint": "Ingrese la potencia máxima de los paneles solares conectados.",
+            "StringYtOffset": "Compensación total de rendimiento de cadena {num}:",
+            "StringYtOffsetHint": "Esta compensación se aplica al valor total de rendimiento leído del inversor. Esto se puede usar para ajustar el rendimiento total del inversor a cero si se utiliza un inversor usado. Pero aún puede intentar sondear datos.",
+            "InverterHint": "*) Ingrese W<sub>p</sub> del canal para calcular la irradiación.",
+            "ReachableThreshold": "Umbral de Alcanzabilidad",
+            "ReachableThresholdHint": "Define cuántas solicitudes se permiten fallar hasta que el inversor se considere no alcanzable.",
+            "ZeroRuntime": "Datos de tiempo cero",
+            "ZeroRuntimeHint": "Datos de tiempo cero (sin datos de rendimiento) si el inversor se vuelve inalcanzable.",
+            "ZeroDay": "Rendimiento diario cero a medianoche",
+            "ZeroDayHint": "Esto solo funciona si el inversor es inalcanzable. Si se leen datos del inversor, se usarán sus valores. (El reinicio solo ocurre en el ciclo de energía)",
+            "ClearEventlog": "Clear Eventlog at midnight",
+            "Cancel": "@:base.Cancel",
+            "Save": "@:base.Save",
+            "DeleteMsg": "¿Está seguro de que desea eliminar el inversor \"{name}\" con número de serie {serial}?",
+            "Delete": "Eliminar",
+            "YieldDayCorrection": "Corrección de Rendimiento Diario",
+            "YieldDayCorrectionHint": "Sumar el rendimiento diario incluso si el inversor se reinicia. El valor se restablecerá a medianoche"
+        },
+        "fileadmin": {
+            "ConfigManagement": "Gestión de Configuración",
+            "BackupHeader": "Copia de seguridad: Copia de Seguridad del Archivo de Configuración",
+            "BackupConfig": "Copia de seguridad del archivo de configuración",
+            "Backup": "Copia de seguridad",
+            "Restore": "Restaurar",
+            "NoFileSelected": "Ningún archivo seleccionado",
+            "RestoreHeader": "Restaurar: Restaurar el Archivo de Configuración",
+            "Back": "Atrás",
+            "UploadSuccess": "Carga Exitosa",
+            "RestoreHint": "<b>Nota:</b> Esta operación reemplaza el archivo de configuración con la configuración restaurada y reinicia OpenDTU para aplicar todas las configuraciones.",
+            "ResetHeader": "Inicializar: Realizar Restablecimiento de Fábrica",
+            "FactoryResetButton": "Restaurar Configuraciones Predeterminadas de Fábrica",
+            "ResetHint": "<b>Nota:</b> Haga clic en Restaurar Configuraciones Predeterminadas de Fábrica para restaurar e inicializar las configuraciones predeterminadas de fábrica y reiniciar.",
+            "FactoryReset": "Restablecimiento de Fábrica",
+            "ResetMsg": "¿Está seguro de que desea eliminar la configuración actual y restablecer todas las configuraciones a sus valores predeterminados de fábrica?",
+            "ResetConfirm": "Restablecimiento de Fábrica",
+            "Cancel": "@:base.Cancel",
+            "InvalidJson": "JSON file is formatted incorrectly.",
+            "InvalidJsonContent": "JSON file has the wrong content."
+        },
+        "login": {
+            "Login": "Iniciar Sesión",
+            "SystemLogin": "Inicio de Sesión en el Sistema",
+            "Username": "Nombre de Usuario",
+            "UsernameRequired": "Se requiere el nombre de usuario",
+            "Password": "Contraseña",
+            "PasswordRequired": "Se requiere la contraseña",
+            "LoginButton": "Iniciar Sesión"
+        },
+        "firmwareupgrade": {
+            "FirmwareUpgrade": "Actualización de Firmware",
+            "Loading": "@:base.Loading",
+            "OtaError": "Error OTA",
+            "Back": "Atrás",
+            "Retry": "Reintentar",
+            "OtaStatus": "Estado OTA",
+            "OtaSuccess": "La carga de firmware fue exitosa. El dispositivo se reinició automáticamente. Cuando el dispositivo vuelva a ser accesible, la interfaz se recargará automáticamente.",
+            "FirmwareUpload": "Carga de Firmware",
+            "UploadProgress": "Progreso de Carga"
+        },
+        "about": {
+            "AboutOpendtu": "Acerca de OpenDTU",
+            "Documentation": "Documentation",
+            "DocumentationBody": "The firmware and hardware documentation can be found here: <a href=\"https://www.opendtu.solar\" target=\"_blank\">https://www.opendtu.solar</a>",
+            "ProjectOrigin": "Origen del Proyecto",
+            "ProjectOriginBody1": "Este proyecto se inició a partir de <a href=\"https://www.mikrocontroller.net/topic/525778\" target=\"_blank\">esta discusión. (Mikrocontroller.net)</a>",
+            "ProjectOriginBody2": "El protocolo de Hoymiles fue descifrado mediante los esfuerzos voluntarios de muchos participantes. OpenDTU, entre otros, se desarrolló basado en este trabajo. El proyecto está bajo una Licencia de Código Abierto (<a href=\"https://www.gnu.de/documents/gpl-2.0.de.html\" target=\"_blank\">Licencia Pública General de GNU versión 2</a>).",
+            "ProjectOriginBody3": "El software se desarrolló según nuestro mejor conocimiento y creencia. Sin embargo, no se acepta ninguna responsabilidad por un mal funcionamiento o pérdida de garantía del inversor.",
+            "ProjectOriginBody4": "OpenDTU está disponible de forma gratuita. Si pagaste dinero por el software, probablemente te estafaron.",
+            "NewsUpdates": "Noticias y Actualizaciones",
+            "NewsUpdatesBody": "Las nuevas actualizaciones se pueden encontrar en Github: <a href=\"https://github.com/tbnobody/OpenDTU\" target=\"_blank\">https://github.com/tbnobody/OpenDTU</a>",
+            "ErrorReporting": "Reporte de Errores",
+            "ErrorReportingBody": "Por favor, informa problemas utilizando la función proporcionada por <a href=\"https://github.com/tbnobody/OpenDTU/issues\" target=\"_blank\">Github</a>",
+            "Discussion": "Discusión",
+            "DiscussionBody": "Discute con nosotros en <a href=\"https://discord.gg/WzhxEY62mB\" target=\"_blank\">Discord</a> o <a href=\"https://github.com/tbnobody/OpenDTU/discussions\" target=\"_blank\">Github</a>"
+        },
+        "hints": {
+            "RadioProblem": "No se pudo conectar a un módulo de radio configurado. Por favor, verifica la conexión.",
+            "TimeSync": "El reloj aún no ha sido sincronizado. Sin un reloj correctamente ajustado, no se realizan solicitudes al inversor. Esto es normal poco después del inicio. Sin embargo, después de un tiempo de ejecución más largo (>1 minuto), indica que el servidor NTP no es accesible.",
+            "TimeSyncLink": "Por favor, verifica la configuración de tu hora.",
+            "DefaultPassword": "Estás utilizando la contraseña predeterminada para la interfaz web y el punto de acceso de emergencia. Esto potencialmente es inseguro.",
+            "DefaultPasswordLink": "Por favor, cambia la contraseña."
+        },
+        "deviceadmin": {
+            "DeviceManager": "Administrador de Dispositivos",
+            "ParseError": "Error de análisis en 'pin_mapping.json': {error}",
+            "PinAssignment": "Configuración de Conexión",
+            "SelectedProfile": "Perfil Seleccionado",
+            "DefaultProfile": "(Configuraciones predeterminadas)",
+            "ProfileHint": "Tu dispositivo puede dejar de responder si seleccionas un perfil incompatible. En este caso, debes realizar una eliminación a través de la interfaz serial.",
+            "Display": "Pantalla",
+            "PowerSafe": "Habilitar Ahorro de Energía",
+            "PowerSafeHint": "Apaga la pantalla si no hay un inversor produciendo.",
+            "Screensaver": "Habilitar Protector de Pantalla",
+            "ScreensaverHint": "Mueve la pantalla un poco en cada actualización para evitar el quemado. (Útil especialmente para pantallas OLED)",
+            "DiagramMode": "Modo de Diagrama",
+            "off": "Apagar",
+            "small": "Pequeño",
+            "fullscreen": "Pantalla Completa",
+            "DiagramDuration": "Duración del Diagrama",
+            "DiagramDurationHint": "El período de tiempo que se muestra en el diagrama.",
+            "Seconds": "Segundos",
+            "Contrast": "Contraste ({contrast})",
+            "Rotation": "Rotación",
+            "rot0": "Sin rotación",
+            "rot90": "Rotación de 90 grados",
+            "rot180": "Rotación de 180 grados",
+            "rot270": "Rotación de 270 grados",
+            "DisplayLanguage": "Idioma de la Pantalla",
+            "en": "Inglés",
+            "de": "Alemán",
+            "fr": "Francés",
+            "Leds": "LEDs",
+            "EqualBrightness": "Brillo Equitativo",
+            "LedBrightness": "Brillo del LED {led} ({brightness})"
+        },
+        "pininfo": {
+            "Category": "Categoría",
+            "Name": "Nombre",
+            "Number": "Número",
+            "ValueSelected": "Seleccionado",
+            "ValueActive": "Activo"
+        },
+        "inputserial": {
+            "format_hoymiles": "Hoymiles serial number format",
+            "format_converted": "Already converted serial number",
+            "format_herf_valid": "E-Star HERF format (will be saved converted): {serial}",
+            "format_herf_invalid": "E-Star HERF format: Invalid checksum",
+            "format_unknown": "Unknown format"
+        }
+    }
+}
diff --git a/lang/it.lang.json b/lang/it.lang.json
new file mode 100644
index 00000000..eaafda63
--- /dev/null
+++ b/lang/it.lang.json
@@ -0,0 +1,690 @@
+{
+    "meta": {
+        "name": "Italiano",
+        "code": "it"
+    },
+    "display": {
+        "date_format": "%d/%m/%Y %H:%M",
+        "offline": "Offline",
+        "power_w": "%.0f W",
+        "power_kw": "%.1f kW",
+        "yield_today_wh": "oggi: %4.0f Wh",
+        "yield_today_kwh": "oggi: %.1f kWh",
+        "yield_total_kwh": "totale: %.1f kWh",
+        "yield_total_mwh": "totale: %.0f kWh"
+    },
+    "webapp": {
+        "menu": {
+            "LiveView": "Dati in tempo reale",
+            "Settings": "Impostazioni",
+            "NetworkSettings": "Impostazioni di rete",
+            "NTPSettings": "Impostazioni NTP",
+            "MQTTSettings": "Impostazioni MQTT",
+            "InverterSettings": "Impostazioni Inverter",
+            "SecuritySettings": "Impostazioni di Sicurezza",
+            "DTUSettings": "Impostazioni DTU",
+            "DeviceManager": "Gestione Dispositivi",
+            "ConfigManagement": "Gestione Configurazione",
+            "FirmwareUpgrade": "Aggiornamento Firmware",
+            "DeviceReboot": "Riavvio DTU",
+            "Info": "Info",
+            "System": "Sistema",
+            "Network": "Rete",
+            "NTP": "NTP",
+            "MQTT": "MQTT",
+            "Console": "Console",
+            "About": "Informazioni DTU",
+            "Logout": "Esci",
+            "Login": "Login"
+        },
+        "base": {
+            "Loading": "Caricamento...",
+            "Reload": "Ricarica",
+            "Cancel": "Cancella",
+            "Save": "Salva",
+            "Refreshing": "Aggiorna",
+            "Pull": "Trascina in basso per aggiornare",
+            "Release": "Rilascia per aggiornare",
+            "Close": "Chiudi"
+        },
+        "wait": {
+            "NotReady": "OpenDTU is not yet ready",
+            "PleaseWait": "Please wait. You will be automatically redirected to the home page."
+        },
+        "Error": {
+            "Oops": "Oops!"
+        },
+        "localeswitcher": {
+            "Dark": "Scuro",
+            "Light": "Chiaro",
+            "Auto": "Automatico"
+        },
+        "apiresponse": {
+            "1001": "Settings saved!",
+            "1002": "No values found!",
+            "1003": "Data too large!",
+            "1004": "Failed to parse data!",
+            "1005": "Values are missing!",
+            "1006": "Write failed!",
+            "2001": "Serial cannot be zero!",
+            "2002": "Poll interval must be greater zero!",
+            "2003": "Invalid power level setting!",
+            "2004": "The frequency must be set between {min} and {max} kHz and must be a multiple of 250kHz!",
+            "2005": "Invalid country selection!",
+            "3001": "Not deleted anything!",
+            "3002": "Configuration resettet. Rebooting now...",
+            "4001": "@:apiresponse.2001",
+            "4002": "Name must between 1 and {max} characters long!",
+            "4003": "Only {max} inverters are supported!",
+            "4004": "Inverter created!",
+            "4005": "Invalid ID specified!",
+            "4006": "Invalid amount of max channel setting given!",
+            "4007": "Inverter changed!",
+            "4008": "Inverter deleted!",
+            "4009": "Inverter order saved!",
+            "5001": "@:apiresponse.2001",
+            "5002": "Limit must between 1 and {max}!",
+            "5003": "Invalid type specified!",
+            "5004": "Invalid inverter specified!",
+            "6001": "Reboot triggered!",
+            "6002": "Reboot cancled!",
+            "7001": "MQTT Server must between 1 and {max} characters long!",
+            "7002": "Username must not longer then {max} characters!",
+            "7003": "Password must not longer then {max} characters!",
+            "7004": "Topic must not longer then {max} characters!",
+            "7005": "Topic must not contain space characters!",
+            "7006": "Topic must end with slash (/)!",
+            "7007": "Port must be a number between 1 and 65535!",
+            "7008": "Certificate must not longer then {max} characters!",
+            "7009": "LWT topic must not longer then {max} characters!",
+            "7010": "LWT topic must not contain space characters!",
+            "7011": "LWT online value must not longer then {max} characters!",
+            "7012": "LWT offline value must not longer then {max} characters!",
+            "7013": "Publish interval must be a number between {min} and {max}!",
+            "7014": "Hass topic must not longer then {max} characters!",
+            "7015": "Hass topic must not contain space characters!",
+            "7016": "LWT QOS must not greater then {max}!",
+            "7017": "Client ID must not longer then {max} characters!",
+            "8001": "IP address is invalid!",
+            "8002": "Netmask is invalid!",
+            "8003": "Gateway is invalid!",
+            "8004": "DNS Server IP 1 is invalid!",
+            "8005": "DNS Server IP 2 is invalid!",
+            "8006": "Administrative AccessPoint Timeout value is invalid",
+            "9001": "NTP Server must between 1 and {max} characters long!",
+            "9002": "Timezone must between 1 and {max} characters long!",
+            "9003": "Timezone description must between 1 and {max} characters long!",
+            "9004": "Year must be a number between {min} and {max}!",
+            "9005": "Month must be a number between {min} and {max}!",
+            "9006": "Day must be a number between {min} and {max}!",
+            "9007": "Hour must be a number between {min} and {max}!",
+            "9008": "Minute must be a number between {min} and {max}!",
+            "9009": "Second must be a number between {min} and {max}!",
+            "9010": "Time updated!",
+            "10001": "Password must between 8 and {max} characters long!",
+            "10002": "Authentication successful!",
+            "11001": "@:apiresponse.2001",
+            "11002": "@:apiresponse:5004",
+            "12001": "Profil must between 1 and {max} characters long!"
+        },
+        "home": {
+            "LiveData": "Dati in tempo reale",
+            "SerialNumber": "Numero seriale: ",
+            "CurrentLimit": "Limite attuale: ",
+            "DataAge": "Aggiornamento Dati: ",
+            "Seconds": "{val} secondi",
+            "ShowSetInverterLimit": "Mostra / Imposta Limite di Potenza",
+            "TurnOnOff": "Accendi/Spegni Inverter",
+            "ShowInverterInfo": "Mostra info Inverter",
+            "ShowEventlog": "Mostra Log Eventi",
+            "UnreadMessages": "msg non letti",
+            "Loading": "@:base.Loading",
+            "EventLog": "Log Eventi",
+            "InverterInfo": "Info Inverter",
+            "LimitSettings": "Impostazioni Limite Potenza",
+            "LastLimitSetStatus": "Stato ultimo limite impostato:",
+            "SetLimit": "Imposta Limite a:",
+            "Relative": "Percentuale (%)",
+            "Absolute": "Assoluto (W)",
+            "LimitHint": "<b>Nota:</b> Se imposti il limite assoluto, il valore sul display sarà aggiornato dopo circa 4 minuti.",
+            "SetPersistent": "Imposta Limite in Modo Persistente",
+            "SetNonPersistent": "Imposta Limite Temporaneamente",
+            "PowerSettings": "Impostazioni Potenza",
+            "LastPowerSetStatus": "Ultimo Stato dell'Inverter:",
+            "TurnOn": "Accendi Inverter",
+            "TurnOff": "Spegni Inverter",
+            "Restart": "Riavvia Inverter",
+            "Failure": "Fallito",
+            "Pending": "In Attesa",
+            "Ok": "Ok",
+            "Unknown": "Sconosciuto",
+            "ShowGridProfile": "Mostra Settaggi Inverter",
+            "GridProfile": "Settaggi Inverter",
+            "LoadingInverter": "In attesa dei dati... (puo' richiedere fino a 10 secondi)",
+            "RadioStats": "Radio Statistics",
+            "TxRequest": "TX Request Count",
+            "RxSuccess": "RX Success",
+            "RxFailNothing": "RX Fail: Receive Nothing",
+            "RxFailPartial": "RX Fail: Receive Partial",
+            "RxFailCorrupt": "RX Fail: Receive Corrupt",
+            "TxReRequest": "TX Re-Request Fragment",
+            "StatsReset": "Reset Statistics",
+            "StatsResetting": "Resetting...",
+            "Rssi": "RSSI of last received packet",
+            "RssiHint": "HM inverters only support RSSI values < -64 dBm and > -64 dBm. In this case, -80 dbm and -30 dbm is shown.",
+            "dBm": "{dbm} dBm"
+        },
+        "eventlog": {
+            "Start": "Inizio",
+            "Stop": "Fine",
+            "Id": "ID",
+            "Message": "Messaggio"
+        },
+        "devinfo": {
+            "NoInfo": "Informazioni non disponibili",
+            "NoInfoLong": "Ancora nessuna informazione dall'inverter. Sto riprovando...",
+            "UnknownModel": "Modello sconosciuto! Per favore fornisci \"Hardware Part Number\" ed il modello (esempio HM-350) in una Issue su <a href=\"https://github.com/tbnobody/OpenDTU/issues\" target=\"_blank\">GitHub</a>.",
+            "Serial": "Seriale",
+            "ProdYear": "Produzione Annua",
+            "ProdWeek": "Produzione Settimanale",
+            "Model": "Modello",
+            "DetectedMaxPower": "Rilevata potenza massima",
+            "BootloaderVersion": "Versione Bootloader",
+            "FirmwareVersion": "Versione Firmware",
+            "FirmwareBuildDate": "Data Firmware",
+            "HardwarePartNumber": "Hardware Part Number",
+            "HardwareVersion": "Hardware Version"
+        },
+        "gridprofile": {
+            "NoInfo": "@:devinfo.NoInfo",
+            "NoInfoLong": "@:devinfo.NoInfoLong",
+            "Name": "Nome",
+            "Version": "Versione",
+            "Enabled": "@:wifistationinfo.Enabled",
+            "Disabled": "@:wifistationinfo.Disabled",
+            "GridprofileSupport": "Supporto sviluppatori",
+            "GridprofileSupportLong": "Clicca <a href=\"https://github.com/tbnobody/OpenDTU/wiki/Grid-Profile-Parser\" target=\"_blank\">qui</a> per ulteriori informazioni."
+        },
+        "systeminfo": {
+            "SystemInfo": "Info Sistema",
+            "VersionError": "Errore ricezione della versione",
+            "VersionNew": "Nuova versione disponibile! Mostra aggiornamenti!",
+            "VersionOk": "Già aggiornato!"
+        },
+        "firmwareinfo": {
+            "FirmwareInformation": "Info Firmware",
+            "Hostname": "Hostname",
+            "SdkVersion": "SDK Version",
+            "ConfigVersion": "Config Version",
+            "FirmwareVersion": "Firmware Version / Git Hash",
+            "PioEnv": "PIO Environment",
+            "FirmwareVersionHint": "Click here to show information about your current version",
+            "FirmwareUpdate": "Firmware Update",
+            "FirmwareUpdateHint": "Click here to view the changes between your version and the latest version",
+            "FrmwareUpdateAllow": "By activating the update check, a request is sent to GitHub.com each time the page is called up to retrieve the currently available version. If you do not agree with this, leave this function deactivated.",
+            "ResetReason0": "Reset Reason CPU 0",
+            "ResetReason1": "Reset Reason CPU 1",
+            "ConfigSaveCount": "Config save count",
+            "Uptime": "Uptime",
+            "UptimeValue": "0 days {time} | 1 day {time} | {count} days {time}"
+        },
+        "hardwareinfo": {
+            "HardwareInformation": "Info Hardware",
+            "ChipModel": "Chip Model",
+            "ChipRevision": "Chip Revision",
+            "ChipCores": "Chip Cores",
+            "CpuFrequency": "CPU Frequency",
+            "Mhz": "MHz",
+            "CpuTemperature": "CPU Temperature",
+            "FlashSize": "Flash Memory Size"
+        },
+        "memoryinfo": {
+            "MemoryInformation": "Info Memoria",
+            "Type": "Tipo",
+            "Usage": "Uso",
+            "Free": "Libera",
+            "Used": "Usata",
+            "Size": "Dimensione",
+            "Heap": "Heap",
+            "PsRam": "PSRAM",
+            "LittleFs": "LittleFs",
+            "Sketch": "Sketch"
+        },
+        "heapdetails": {
+            "HeapDetails": "Dettagli memoria Heap",
+            "TotalFree": "Libera totale",
+            "LargestFreeBlock": "Blocco contiguo libero più grande",
+            "MaxUsage": "Massima utilizzata dall'avvio",
+            "Fragmentation": "Livello frammentazione"
+        },
+        "taskdetails": {
+            "TaskDetails": "Task Details",
+            "Name": "Name",
+            "StackFree": "Stack Free",
+            "Priority": "Priority",
+            "Task_idle0": "Idle (CPU Core 0)",
+            "Task_idle1": "Idle (CPU Core 1)",
+            "Task_wifi": "Wi-Fi",
+            "Task_tit": "TCP/IP",
+            "Task_looptask": "Arduino Main Loop",
+            "Task_asynctcp": "Async TCP",
+            "Task_mqttclient": "MQTT Client",
+            "Task_huaweican0": "AC Charger CAN",
+            "Task_pmsdm": "PowerMeter (SDM)",
+            "Task_pmhttpjson": "PowerMeter (HTTP+JSON)",
+            "Task_pmsml": "PowerMeter (Serial SML)",
+            "Task_pmhttpsml": "PowerMeter (HTTP+SML)"
+        },
+        "radioinfo": {
+            "RadioInformation": "Info Transceiver Radio",
+            "Status": "{module} Stato",
+            "ChipStatus": "{module} Chip Stato",
+            "ChipType": "{module} Chip Tipo",
+            "Connected": "connesso",
+            "NotConnected": "non connesso",
+            "Configured": "configurato",
+            "NotConfigured": "no configurato",
+            "Unknown": "Sconosciuto"
+        },
+        "networkinfo": {
+            "NetworkInformation": "Informazioni Rete"
+        },
+        "wifistationinfo": {
+            "WifiStationInfo": "Info WiFi (Station)",
+            "Status": "Stato",
+            "Enabled": "abilitato",
+            "Disabled": "disabilitato",
+            "Ssid": "SSID",
+            "Bssid": "BSSID",
+            "Quality": "Qualità",
+            "Rssi": "RSSI"
+        },
+        "wifiapinfo": {
+            "WifiApInfo": "Info WiFi (Access Point)",
+            "Status": "@:wifistationinfo.Status",
+            "Enabled": "@:wifistationinfo.Enabled",
+            "Disabled": "@:wifistationinfo.Disabled",
+            "Ssid": "@:wifistationinfo.Ssid",
+            "Stations": "Numero Stazioni"
+        },
+        "interfacenetworkinfo": {
+            "NetworkInterface": "Interfaccia di Rete ({iface})",
+            "Hostname": "@:firmwareinfo.Hostname",
+            "IpAddress": "Indirizzo IP",
+            "Netmask": "Netmask",
+            "DefaultGateway": "Gateway",
+            "Dns": "DNS {num}",
+            "MacAddress": "Indirizzo MAC"
+        },
+        "interfaceapinfo": {
+            "NetworkInterface": "Interfaccia di Rete (Access Point)",
+            "IpAddress": "@:interfacenetworkinfo.IpAddress",
+            "MacAddress": "@:interfacenetworkinfo.MacAddress"
+        },
+        "ntpinfo": {
+            "NtpInformation": "Informazioni NTP",
+            "ConfigurationSummary": "Riepilogo Configurazione",
+            "Server": "Server",
+            "Timezone": "Timezone",
+            "TimezoneDescription": "Descrizione Timezone",
+            "CurrentTime": "Data/Ora attuale",
+            "Status": "Stato",
+            "Synced": "sincronizzata",
+            "NotSynced": "non sincronizzata",
+            "LocalTime": "Ora Locale",
+            "Sunrise": "Alba",
+            "Sunset": "Tramonto",
+            "NotAvailable": "Non Disponibile",
+            "Mode": "Modalità",
+            "Day": "Giorno",
+            "Night": "Notte"
+        },
+        "mqttinfo": {
+            "MqttInformation": "Informazioni MQTT",
+            "ConfigurationSummary": "@:ntpinfo.ConfigurationSummary",
+            "Status": "@:ntpinfo.Status",
+            "Enabled": "Abilitato",
+            "Disabled": "Disabilitato",
+            "Server": "@:ntpinfo.Server",
+            "Port": "Porta",
+            "ClientId": "Client ID",
+            "Username": "Username",
+            "BaseTopic": "Topic Base",
+            "PublishInterval": "Intervallo Publish",
+            "Seconds": "{sec} secondi",
+            "CleanSession": "CleanSession",
+            "Retain": "Retain",
+            "Tls": "TLS",
+            "RootCertifcateInfo": "Info Certificato Root CA",
+            "TlsCertLogin": "Entra con Certificato TLS",
+            "ClientCertifcateInfo": "Info Certificato Client",
+            "HassSummary": "Riepilogo Configurazione Home Assistant MQTT Auto Discovery",
+            "Expire": "Scade",
+            "IndividualPanels": "Pannello Individuale",
+            "RuntimeSummary": "Riepilogo Runtime",
+            "ConnectionStatus": "Stato Connessione",
+            "Connected": "connesso",
+            "Disconnected": "disconnesso"
+        },
+        "console": {
+            "Console": "Console",
+            "VirtualDebugConsole": "Virtual Debug Console",
+            "EnableAutoScroll": "Abilita AutoScroll",
+            "ClearConsole": "Pulisci Console",
+            "CopyToClipboard": "Copia nella clipboard"
+        },
+        "inverterchannelinfo": {
+            "String": "Stringa {num}",
+            "Phase": "Fase {num}",
+            "General": "Generale"
+        },
+        "invertertotalinfo": {
+            "TotalYieldTotal": "Totale Energia",
+            "TotalYieldDay": "Energia Giornaliera",
+            "TotalPower": "Potenza Totale"
+        },
+        "inverterchannelproperty": {
+            "Power": "Potenza",
+            "Voltage": "Tensione",
+            "Current": "Corrente",
+            "Power DC": "PotenzaDC",
+            "YieldDay": "EnergiaOggi",
+            "YieldTotal": "EnergiaTotale",
+            "Frequency": "Frequenza",
+            "Temperature": "Temperatura",
+            "PowerFactor": "FattorePotenza",
+            "ReactivePower": "PotenzaReattiva",
+            "Efficiency": "Efficienza",
+            "Irradiation": "Irragiamento"
+        },
+        "maintenancereboot": {
+            "DeviceReboot": "Riavvio DTU",
+            "PerformReboot": "Fai il riavvio",
+            "Reboot": "Riavvio!",
+            "Cancel": "@:base.Cancel",
+            "RebootOpenDTU": "Riavvio OpenDTU",
+            "RebootQuestion": "Vuoi veramente riavvia il DTU?",
+            "RebootHint": "<b>Nota:</b> Normalmente non serve riavviare OpenDTU, in quanto esegue automaticamente il ravvio quando necessario (ad esempio dopo aggiornamento firmware). Modifiche alla configurazione vengono apprese subito, senza richiedere riavvio. Se devi riavviare a causa di un errore, ti preghiamo di segnalarcelo cliccando su <a href=\"https://github.com/tbnobody/OpenDTU/issues\" class=\"alert-link\" target=\"_blank\">https://github.com/tbnobody/OpenDTU/issues</a>."
+        },
+        "dtuadmin": {
+            "DtuSettings": "Impostazioni DTU",
+            "DtuConfiguration": "Configurazione DTU",
+            "Serial": "Seriale",
+            "SerialHint": "Sia il DTU che l'inverter hanno un numero seriale. Il numero seriale del DTU è generato casualmente al primo avvio e normalmente non serve modificarlo.",
+            "PollInterval": "Intervallo Interrogazione",
+            "Seconds": "Secondi",
+            "NrfPaLevel": "Potenza Trasmettitore NRF24",
+            "CmtPaLevel": "Potenza Trasmettitore CMT2300A",
+            "NrfPaLevelHint": "Usato per inverter HM. Considera che aumentando la potenza aumentano il consumo di corrente.",
+            "CmtPaLevelHint": "Usato per inverter HMS/HMT. Considera che aumentando la potenza aumentano il consumo di corrente.",
+            "CmtCountry": "CMT2300A Zona/Paese",
+            "CmtCountryHint": "Ogni zona ha una differente allocazione di frequenze utilizzabili.",
+            "country_0": "Europa ({min}MHz - {max}MHz)",
+            "country_1": "Nord America ({min}MHz - {max}MHz)",
+            "country_2": "Brasile ({min}MHz - {max}MHz)",
+            "CmtFrequency": "Frequenza CMT2300A",
+            "CmtFrequencyHint": "Fai attenzione ad usare solo frequenze ammesse nel tuo Paese! Dopo la modifica frequenza, servono fino a 15 minuti affinché la connessione si ristabilisca.",
+            "CmtFrequencyWarning": "La frequenza selezionata è fuori dal range selezionato dal tuo Paese. Verifica che la frequenza selezionata non violi le normative del tuo Paese.",
+            "MHz": "{mhz} MHz",
+            "dBm": "{dbm} dBm",
+            "Min": "Minima ({db} dBm)",
+            "Low": "Bassa ({db} dBm)",
+            "High": "Alta ({db} dBm)",
+            "Max": "Massima ({db} dBm)"
+        },
+        "securityadmin": {
+            "SecuritySettings": "Impostazioni di Sicurezza",
+            "AdminPassword": "Password Admin",
+            "Password": "Password",
+            "RepeatPassword": "Ripeti Password",
+            "PasswordHint": "<b>Nota:</b> La password di amministrazione viene utilizzata non solo per accedere a questa interfaccia web (con user 'admin'), ma anche per connettersi al dispositivo in modalità AP. Deve avere da 8 a 64 caratteri.",
+            "Permissions": "Permessi",
+            "ReadOnly": "Permetti accessi web in sola lettura senza richiedere la password"
+        },
+        "ntpadmin": {
+            "NtpSettings": "Impostazioni NTP (Data / Ora)",
+            "NtpConfiguration": "Configurazione NTP",
+            "TimeServer": "Server NTP",
+            "TimeServerHint": "Puoi lasciare il valore di default, nel caso in cui OpenDTU abbia accesso ad internet.",
+            "Timezone": "Timezone",
+            "TimezoneConfig": "Timezone Config",
+            "LocationConfiguration": "Configurazione Posizione",
+            "Longitude": "Longitudine",
+            "Latitude": "Latitudine",
+            "SunSetType": "Tipo di Alba",
+            "SunSetTypeHint": "Influenza il calcolo dell'ora di Alba/Tramonto. Dopo la conferma, è richiesto fino ad un minuto perché la modifica venga applicata.",
+            "OFFICIAL": "Standard dawn (90.8°)",
+            "NAUTICAL": "Nautical dawn (102°)",
+            "CIVIL": "Civil dawn (96°)",
+            "ASTONOMICAL": "Astronomical dawn (108°)",
+            "ManualTimeSynchronization": "Sincronizzazione Manuale Data/Ora",
+            "CurrentOpenDtuTime": "Ora OpenDTU attuale",
+            "CurrentLocalTime": "Ora Locale attuale",
+            "SynchronizeTime": "Sincronizza Data/Ora",
+            "SynchronizeTimeHint": "<b>Nota:</b> Puoi usare la sincronizzazione manuale per impostare Data/Ora nel caso che non sia disponibile un server NTP. In questo caso la data/ora viene persa in caso di mancata alimentazione. Inoltre, con la sincronizzazione manuale ci sarà una progressiva deriva della Data/Ora in quanto l'ESP32 non ha un Real Time Clock interno."
+        },
+        "networkadmin": {
+            "NetworkSettings": "Impostazioni di Rete",
+            "WifiConfiguration": "Configurazione WiFi",
+            "WifiSsid": "WiFi SSID",
+            "WifiPassword": "WiFi Password",
+            "Hostname": "Hostname",
+            "HostnameHint": "<b>Nota:</b> Il testo <span class=\"font-monospace\">%06X</span> sarà rimpiazzato con le ultime 6 cifre del ChipID dell'ESP32 in formato esadecimale.",
+            "EnableDhcp": "Abilita DHCP",
+            "StaticIpConfiguration": "Configurazione IP Statico",
+            "IpAddress": "Indirizzo IP",
+            "Netmask": "Netmask",
+            "DefaultGateway": "Default Gateway",
+            "Dns": "DNS Server {num}",
+            "AdminAp": "Configurazione WiFi (Admin AccessPoint)",
+            "ApTimeout": "Timeout AccessPoint",
+            "ApTimeoutHint": "Tempo in cui la modalità AccessPoint rimarrà attiva. 0=per sempre.",
+            "Minutes": "minuti",
+            "EnableMdns": "Abilita mDNS",
+            "MdnsSettings": "Configurazione mDNS"
+        },
+        "mqttadmin": {
+            "MqttSettings": "Impostazioni MQTT",
+            "MqttConfiguration": "Configurazione MQTT",
+            "EnableMqtt": "Abilita MQTT",
+            "EnableHass": "Abilita Home Assistant MQTT Auto Discovery",
+            "MqttBrokerParameter": "Parametri Broker MQTT",
+            "Hostname": "Hostname",
+            "HostnameHint": "Hostname o Indirizzo IP",
+            "Port": "Porta",
+            "ClientId": "Client ID",
+            "Username": "Username",
+            "UsernameHint": "Username, lascia vuoto per connessione anonima",
+            "Password": "Password",
+            "PasswordHint": "Password, lascia vuota per connessione anonima",
+            "BaseTopic": "Topic Base",
+            "BaseTopicHint": "Topic Base, prefisso da aggiungere (ad esempio inverter/)",
+            "PublishInterval": "Intervallo pubblicazione",
+            "Seconds": "secondi",
+            "CleanSession": "Abilita CleanSession",
+            "EnableRetain": "Abilita Retain",
+            "EnableTls": "Abilita TLS",
+            "RootCa": "CA-Root-Certificate (default Letsencrypt)",
+            "TlsCertLoginEnable": "Abilita Login con certificato TLS",
+            "ClientCert": "TLS Client-Certificate",
+            "ClientKey": "TLS Client-Key",
+            "LwtParameters": "Parametri LWT",
+            "LwtTopic": "Topic LWT",
+            "LwtTopicHint": "Topic LWT, da aggiungere al Topic Base",
+            "LwtOnline": "Messaggio 'Online0 LWT",
+            "LwtOnlineHint": "Messaggio pubblicato quando online",
+            "LwtOffline": "Messaggio 'Offline' LWT",
+            "LwtOfflineHint": "Messaggio che sarà pubblicato quando offline",
+            "LwtQos": "QoS (Quality of Service)",
+            "QOS0": "0 (Al massimo una volta)",
+            "QOS1": "1 (Almeno una volta)",
+            "QOS2": "2 (Esattamente una volta)",
+            "HassParameters": "Parametri Home Assistant MQTT Auto Discovery",
+            "HassPrefixTopic": "Prefisso Topic",
+            "HassPrefixTopicHint": "Prefisso per Topic autodiscovery",
+            "HassRetain": "Abilita Retain",
+            "HassExpire": "Abilita Scadenza",
+            "HassIndividual": "Pannelli Individuale"
+        },
+        "inverteradmin": {
+            "InverterSettings": "Impostazioni Inverter",
+            "AddInverter": "Aggiungi nuovo Inverter",
+            "Serial": "Seriale",
+            "Name": "Nome",
+            "Add": "Aggiungi",
+            "AddHint": "<b>Nota:</b> Potrai aggiungere ulteriori parametri dopo aver creato l'inverter, cliccando sull'icona 'Matita' nella lista inverter.",
+            "InverterList": "Lista Inverter",
+            "Status": "Stato",
+            "Send": "Invia",
+            "Receive": "Riceve",
+            "StatusHint": "<b>Nota:</b> L'inverter viene alimentato dal fotovoltaico. Durante la notte, l'inverter risulterà spento. Le richieste potranno comunque essere trasmesse.",
+            "Type": "Tipo",
+            "Action": "Azione",
+            "SaveOrder": "Salva ordine",
+            "DeleteInverter": "Rimuovi inverter",
+            "EditInverter": "Modifica inverter",
+            "General": "Generale",
+            "String": "Stringa",
+            "Advanced": "Avanzate",
+            "InverterSerial": "Seriale Inverter:",
+            "InverterName": "Nome Inverter:",
+            "InverterNameHint": "Puoi specificare un nome qualsiasi da assegnare all'inverter.",
+            "InverterStatus": "Riceve / Invia",
+            "PollEnable": "Interroga inverter",
+            "PollEnableNight": "Interroga inverter di notte",
+            "CommandEnable": "Invia comandi",
+            "CommandEnableNight": "Invia comandi di notte",
+            "StringName": "Nome stringa {num}:",
+            "StringNameHint": "Qui puoi specificare un nome qualsiasi per la porta dell'inverter o per il pannello fotovoltaico collegato.",
+            "StringMaxPower": "Massima potenza stringa {num}:",
+            "StringMaxPowerHint": "Inserisci la potenza massima associata ai panelli fotovoltaici collegati a questa stringa.",
+            "StringYtOffset": "Offset Energia totale per la stringa {num}:",
+            "StringYtOffsetHint": "Questo offset viene utilizzato per azzerare il contatore qualora venga usato un inverter usato.",
+            "InverterHint": "*) Inserisci la potenza W<sub>p</sub> dei pannelli fotovoltaici collegati alla stringa: servirà per calcolare l'irragiamento.",
+            "ReachableThreshold": "Reachable Threshold",
+            "ReachableThresholdHint": "Definisce il numero di richieste fallite prima che l'inverter sia considerato irraggiungibile.",
+            "ZeroRuntime": "Azzera dati in tempo reale",
+            "ZeroRuntimeHint": "Azzera i dati in tempo reale (tranne l'Energia) se l'inverter diventa irraggiunbile.",
+            "ZeroDay": "Azzera dati energia alla mezzanotte",
+            "ZeroDayHint": "Questo vale se l'inverter risulta irraggiungibile. Se l'inverter risponde anche di notte, verranno mostrati i suoi valori. (Il Reset si verifica al riavvio)",
+            "ClearEventlog": "Clear Eventlog at midnight",
+            "Cancel": "@:base.Cancel",
+            "Save": "@:base.Save",
+            "DeleteMsg": "Sicuro di voler rimuovere l'inverter \"{name}\" con numero seriale {serial}?",
+            "Delete": "Rimuovi",
+            "YieldDayCorrection": "Correzione energia giornaliera",
+            "YieldDayCorrectionHint": "Aggiungi questo valore all'energia giornaliera se l'inverter è stato riavviato. Questo valore sarò resettato a mezzanotte"
+        },
+        "fileadmin": {
+            "ConfigManagement": "Configurazione Gestione",
+            "BackupHeader": "Backup: Configurazione File Backup",
+            "BackupConfig": "Esegui il backup del file",
+            "Backup": "Backup",
+            "Restore": "Ripristina",
+            "NoFileSelected": "Nessun file selezionato",
+            "RestoreHeader": "Ripristina: Ripristina File Configurazione",
+            "Back": "Indietro",
+            "UploadSuccess": "Invio File con successo",
+            "RestoreHint": "<b>Nota:</b> questa operazione rimpiazza la configurazione con quella contenuta nel file, e poi riavvia automaticamente OpenDTU per applicare la nuova configurazione.",
+            "ResetHeader": "Inizializza: Esegui il Factory Reset",
+            "FactoryResetButton": "Ripristina Configurazione Factory-Default",
+            "ResetHint": "<b>Nota:</b> Clicca 'Ripristina Configurazione Factory-Default' per stabilire le impostazioni di fabbrica e riavviare automaticamente OpenDTU.",
+            "FactoryReset": "Factory Reset",
+            "ResetMsg": "Sei sicuro di voler cancellare la configurazione attuale e applicare la configurazione di fabbrica?",
+            "ResetConfirm": "Factory Reset!",
+            "Cancel": "@:base.Cancel",
+            "InvalidJson": "JSON file is formatted incorrectly.",
+            "InvalidJsonContent": "JSON file has the wrong content."
+        },
+        "login": {
+            "Login": "Login",
+            "SystemLogin": "System Login",
+            "Username": "Username",
+            "UsernameRequired": "Inserisci Username",
+            "Password": "Password",
+            "PasswordRequired": "Inserisci Password",
+            "LoginButton": "Login"
+        },
+        "firmwareupgrade": {
+            "FirmwareUpgrade": "Aggiornamento Firmware",
+            "Loading": "@:base.Loading",
+            "OtaError": "Errore aggiornamento OTA",
+            "Back": "Indietro",
+            "Retry": "Riprova",
+            "OtaStatus": "Stato OTA",
+            "OtaSuccess": "Aggiornamento firmware eseguito con successo. Il dispositivo si riavvierà automaticamente. Quando sarà nuovamente disponibile, l'interfacca sarà ricaricata automaticamente.",
+            "FirmwareUpload": "Invia Firmware",
+            "UploadProgress": "Upload in corso"
+        },
+        "about": {
+            "AboutOpendtu": "About OpenDTU",
+            "Documentation": "Documentazione",
+            "DocumentationBody": "La documentazione firmware e hardware sono disponibili qui: <a href=\"https://www.opendtu.solar\" target=\"_blank\">https://www.opendtu.solar</a>",
+            "ProjectOrigin": "Origine Progetto",
+            "ProjectOriginBody1": "Questo progetto è partito da <a href=\"https://www.mikrocontroller.net/topic/525778\" target=\"_blank\">questa discussione. (Mikrocontroller.net)</a>",
+            "ProjectOriginBody2": "Il protocollo Hoymiles è stato decriptato grazie al contributo volontario di molti programmatori. OpenDTU, fra gli altri, è stato sviluppato grazie a questo lavoro. Il progetto è distribuito con Licenza Open Source (<a href=\"https://www.gnu.de/documents/gpl-2.0.de.html\" target=\"_blank\">GNU General Public License version 2</a>).",
+            "ProjectOriginBody3": "Il software è stato sviluppato con le nostre migliori conoscenze e convinzioni. Tuttavia, non si assume alcuna responsabilità per malfunzionamenti o perdita di garanzia dell'inverter.",
+            "ProjectOriginBody4": "OpenDTU è disponibile gratuitamente. Se hai pagato per questo software, probabilmente sei stato truffato.",
+            "NewsUpdates": "Novità e Aggiornamenti",
+            "NewsUpdatesBody": "Nuovi aggiornamenti sono disponibili su Github: <a href=\"https://github.com/tbnobody/OpenDTU\" target=\"_blank\">https://github.com/tbnobody/OpenDTU</a>",
+            "ErrorReporting": "Segnalazione Errori",
+            "ErrorReportingBody": "Per favore segnala eventuali problemi utilizzando le funzionalità della piattaforma <a href=\"https://github.com/tbnobody/OpenDTU/issues\" target=\"_blank\">Github</a>",
+            "Discussion": "Discussioni",
+            "DiscussionBody": "Puoi avviare una discussione con noi su <a href=\"https://discord.gg/WzhxEY62mB\" target=\"_blank\">Discord</a> o <a href=\"https://github.com/tbnobody/OpenDTU/discussions\" target=\"_blank\">Github</a>"
+        },
+        "hints": {
+            "RadioProblem": "Non è possibile dialogare con il modulo radio selezionato. Controlla i collegamenti alla radio.",
+            "TimeSync": "La Data/Ora non sono state sincronizzate, ed in tal caso non è possibile eseguire richieste all'inverter. Questa condizione è normale appena avviato, tuttavia dopo un po' (>1 minuto), questa situazione potrebbe indicare un problema di accesso al server NTP.",
+            "TimeSyncLink": "Controlla le impostazioni Data/Ora.",
+            "DefaultPassword": "Stai usando la password di default per accedere all'interfaccia web e per la modalità Access Point di emergenza. Questo può portare ad un rischio di sicurezza.",
+            "DefaultPasswordLink": "Per favore cambia la password."
+        },
+        "deviceadmin": {
+            "DeviceManager": "Device-Manager",
+            "ParseError": "Parse error in 'pin_mapping.json': {error}",
+            "PinAssignment": "Impostazioni Connessione",
+            "SelectedProfile": "Profilo selezionato",
+            "DefaultProfile": "(Impostazioni di Default)",
+            "ProfileHint": "Il tuo dispositivo potrebbe smettere di rispondere selezionando un profilo incompatibile. In questo caso, dovrai eseguire una cancellazione collegandoti all'interfaccia seriale.",
+            "Display": "Display",
+            "PowerSafe": "Abilita Risparmio Energetico",
+            "PowerSafeHint": "Spegni il display se l'inverter non produce.",
+            "Screensaver": "Abilita Screensaver",
+            "ScreensaverHint": "Muove il testo nel display per prevenire danneggiamento pixel. (Utile in caso di display OLED)",
+            "DiagramMode": "Modalità grafica",
+            "off": "Off",
+            "small": "Small",
+            "fullscreen": "Fullscreen",
+            "DiagramDuration": "Durata grafico",
+            "DiagramDurationHint": "Periodo che viene mostrato nel grafico.",
+            "Seconds": "Secondi",
+            "Contrast": "Contrasto ({contrast})",
+            "Rotation": "Rotazione",
+            "rot0": "Nessuna rotazione",
+            "rot90": "Rotazione 90 gradi",
+            "rot180": "Rotazione 180 gradi",
+            "rot270": "Rotazione 270 gradi",
+            "DisplayLanguage": "Linuga Display",
+            "en": "English",
+            "de": "German",
+            "fr": "French",
+            "Leds": "LEDs",
+            "EqualBrightness": "Equalizza luminosità",
+            "LedBrightness": "LED {led}, Luminosità ({brightness})"
+        },
+        "pininfo": {
+            "Category": "Categoria",
+            "Name": "Nome",
+            "Number": "Numero",
+            "ValueSelected": "Selezionato",
+            "ValueActive": "Attivo"
+        },
+        "inputserial": {
+            "format_hoymiles": "Hoymiles serial number format",
+            "format_converted": "Already converted serial number",
+            "format_herf_valid": "E-Star HERF format (will be saved converted): {serial}",
+            "format_herf_invalid": "E-Star HERF format: Invalid checksum",
+            "format_unknown": "Unknown format"
+        }
+    }
+}
diff --git a/lib/Hoymiles/src/commands/ActivePowerControlCommand.cpp b/lib/Hoymiles/src/commands/ActivePowerControlCommand.cpp
index dcd2370c..4ce3c6e5 100644
--- a/lib/Hoymiles/src/commands/ActivePowerControlCommand.cpp
+++ b/lib/Hoymiles/src/commands/ActivePowerControlCommand.cpp
@@ -85,13 +85,13 @@ bool ActivePowerControlCommand::handleResponse(const fragment_t fragment[], cons
 
 float ActivePowerControlCommand::getLimit() const
 {
-    const float l = (((uint16_t)_payload[12] << 8) | _payload[13]);
+    const float l = (static_cast<uint16_t>(_payload[12]) << 8) | _payload[13];
     return l / 10;
 }
 
 PowerLimitControlType ActivePowerControlCommand::getType()
 {
-    return (PowerLimitControlType)(((uint16_t)_payload[14] << 8) | _payload[15]);
+    return (PowerLimitControlType)((static_cast<uint16_t>(_payload[14]) << 8) | _payload[15]);
 }
 
 void ActivePowerControlCommand::gotTimeout()
diff --git a/lib/Hoymiles/src/commands/DevControlCommand.cpp b/lib/Hoymiles/src/commands/DevControlCommand.cpp
index b73f74f0..8dc419d6 100644
--- a/lib/Hoymiles/src/commands/DevControlCommand.cpp
+++ b/lib/Hoymiles/src/commands/DevControlCommand.cpp
@@ -35,8 +35,8 @@ DevControlCommand::DevControlCommand(InverterAbstract* inv, const uint64_t route
 void DevControlCommand::udpateCRC(const uint8_t len)
 {
     const uint16_t crc = crc16(&_payload[10], len);
-    _payload[10 + len] = (uint8_t)(crc >> 8);
-    _payload[10 + len + 1] = (uint8_t)(crc);
+    _payload[10 + len] = static_cast<uint8_t>(crc >> 8);
+    _payload[10 + len + 1] = static_cast<uint8_t>(crc);
 }
 
 bool DevControlCommand::handleResponse(const fragment_t fragment[], const uint8_t max_fragment_id)
diff --git a/lib/Hoymiles/src/commands/MultiDataCommand.cpp b/lib/Hoymiles/src/commands/MultiDataCommand.cpp
index 0e7bf51f..dd5d72ea 100644
--- a/lib/Hoymiles/src/commands/MultiDataCommand.cpp
+++ b/lib/Hoymiles/src/commands/MultiDataCommand.cpp
@@ -63,10 +63,10 @@ uint8_t MultiDataCommand::getDataType() const
 
 void MultiDataCommand::setTime(const time_t time)
 {
-    _payload[12] = (uint8_t)(time >> 24);
-    _payload[13] = (uint8_t)(time >> 16);
-    _payload[14] = (uint8_t)(time >> 8);
-    _payload[15] = (uint8_t)(time);
+    _payload[12] = static_cast<uint8_t>(time >> 24);
+    _payload[13] = static_cast<uint8_t>(time >> 16);
+    _payload[14] = static_cast<uint8_t>(time >> 8);
+    _payload[15] = static_cast<uint8_t>(time);
     udpateCRC();
 }
 
@@ -112,8 +112,8 @@ bool MultiDataCommand::handleResponse(const fragment_t fragment[], const uint8_t
 void MultiDataCommand::udpateCRC()
 {
     const  uint16_t crc = crc16(&_payload[10], 14); // From data_type till password
-    _payload[24] = (uint8_t)(crc >> 8);
-    _payload[25] = (uint8_t)(crc);
+    _payload[24] = static_cast<uint8_t>(crc >> 8);
+    _payload[25] = static_cast<uint8_t>(crc);
 }
 
 uint8_t MultiDataCommand::getTotalFragmentSize(const fragment_t fragment[], const uint8_t max_fragment_id)
diff --git a/lib/Hoymiles/src/inverters/HERF_1CH.cpp b/lib/Hoymiles/src/inverters/HERF_1CH.cpp
index 49531d99..17e0a618 100644
--- a/lib/Hoymiles/src/inverters/HERF_1CH.cpp
+++ b/lib/Hoymiles/src/inverters/HERF_1CH.cpp
@@ -29,6 +29,10 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A }
+};
+
 HERF_1CH::HERF_1CH(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial) {};
 
@@ -53,3 +57,13 @@ uint8_t HERF_1CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HERF_1CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HERF_1CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HERF_1CH.h b/lib/Hoymiles/src/inverters/HERF_1CH.h
index 8220272e..fc6f1e38 100644
--- a/lib/Hoymiles/src/inverters/HERF_1CH.h
+++ b/lib/Hoymiles/src/inverters/HERF_1CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
 };
diff --git a/lib/Hoymiles/src/inverters/HERF_2CH.cpp b/lib/Hoymiles/src/inverters/HERF_2CH.cpp
index f0216a64..14f4644b 100644
--- a/lib/Hoymiles/src/inverters/HERF_2CH.cpp
+++ b/lib/Hoymiles/src/inverters/HERF_2CH.cpp
@@ -36,6 +36,11 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_B }
+};
+
 HERF_2CH::HERF_2CH(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial) {};
 
@@ -60,3 +65,13 @@ uint8_t HERF_2CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HERF_2CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HERF_2CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HERF_2CH.h b/lib/Hoymiles/src/inverters/HERF_2CH.h
index 048ccb61..e606a843 100644
--- a/lib/Hoymiles/src/inverters/HERF_2CH.h
+++ b/lib/Hoymiles/src/inverters/HERF_2CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
 };
diff --git a/lib/Hoymiles/src/inverters/HMS_1CH.cpp b/lib/Hoymiles/src/inverters/HMS_1CH.cpp
index 2c7e3857..a04b0b7d 100644
--- a/lib/Hoymiles/src/inverters/HMS_1CH.cpp
+++ b/lib/Hoymiles/src/inverters/HMS_1CH.cpp
@@ -28,6 +28,10 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A }
+};
+
 HMS_1CH::HMS_1CH(HoymilesRadio* radio, const uint64_t serial)
     : HMS_Abstract(radio, serial) {};
 
@@ -52,3 +56,13 @@ uint8_t HMS_1CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HMS_1CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HMS_1CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HMS_1CH.h b/lib/Hoymiles/src/inverters/HMS_1CH.h
index a5a64c17..de53d501 100644
--- a/lib/Hoymiles/src/inverters/HMS_1CH.h
+++ b/lib/Hoymiles/src/inverters/HMS_1CH.h
@@ -11,4 +11,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HMS_1CHv2.cpp b/lib/Hoymiles/src/inverters/HMS_1CHv2.cpp
index d79d2c1d..3716cd98 100644
--- a/lib/Hoymiles/src/inverters/HMS_1CHv2.cpp
+++ b/lib/Hoymiles/src/inverters/HMS_1CHv2.cpp
@@ -28,6 +28,10 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A }
+};
+
 HMS_1CHv2::HMS_1CHv2(HoymilesRadio* radio, const uint64_t serial)
     : HMS_Abstract(radio, serial) {};
 
@@ -52,3 +56,13 @@ uint8_t HMS_1CHv2::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HMS_1CHv2::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HMS_1CHv2::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HMS_1CHv2.h b/lib/Hoymiles/src/inverters/HMS_1CHv2.h
index c831d120..2274ae53 100644
--- a/lib/Hoymiles/src/inverters/HMS_1CHv2.h
+++ b/lib/Hoymiles/src/inverters/HMS_1CHv2.h
@@ -11,4 +11,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HMS_2CH.cpp b/lib/Hoymiles/src/inverters/HMS_2CH.cpp
index 4cbc686c..c22fcf0d 100644
--- a/lib/Hoymiles/src/inverters/HMS_2CH.cpp
+++ b/lib/Hoymiles/src/inverters/HMS_2CH.cpp
@@ -35,6 +35,11 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_B }
+};
+
 HMS_2CH::HMS_2CH(HoymilesRadio* radio, const uint64_t serial)
     : HMS_Abstract(radio, serial) {};
 
@@ -59,3 +64,13 @@ uint8_t HMS_2CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HMS_2CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HMS_2CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HMS_2CH.h b/lib/Hoymiles/src/inverters/HMS_2CH.h
index 9f1ed91f..75d3f9b0 100644
--- a/lib/Hoymiles/src/inverters/HMS_2CH.h
+++ b/lib/Hoymiles/src/inverters/HMS_2CH.h
@@ -11,4 +11,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HMS_4CH.cpp b/lib/Hoymiles/src/inverters/HMS_4CH.cpp
index b3cf1f38..1616d013 100644
--- a/lib/Hoymiles/src/inverters/HMS_4CH.cpp
+++ b/lib/Hoymiles/src/inverters/HMS_4CH.cpp
@@ -49,6 +49,13 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_B },
+    { CH2, MPPT_C },
+    { CH3, MPPT_D }
+};
+
 HMS_4CH::HMS_4CH(HoymilesRadio* radio, const uint64_t serial)
     : HMS_Abstract(radio, serial) {};
 
@@ -73,3 +80,13 @@ uint8_t HMS_4CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HMS_4CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HMS_4CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HMS_4CH.h b/lib/Hoymiles/src/inverters/HMS_4CH.h
index 9d49de07..cb757339 100644
--- a/lib/Hoymiles/src/inverters/HMS_4CH.h
+++ b/lib/Hoymiles/src/inverters/HMS_4CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HMT_4CH.cpp b/lib/Hoymiles/src/inverters/HMT_4CH.cpp
index c84eff47..48caf8ce 100644
--- a/lib/Hoymiles/src/inverters/HMT_4CH.cpp
+++ b/lib/Hoymiles/src/inverters/HMT_4CH.cpp
@@ -58,6 +58,13 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_A },
+    { CH2, MPPT_B },
+    { CH3, MPPT_B }
+};
+
 HMT_4CH::HMT_4CH(HoymilesRadio* radio, const uint64_t serial)
     : HMT_Abstract(radio, serial) {};
 
@@ -82,3 +89,13 @@ uint8_t HMT_4CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HMT_4CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HMT_4CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HMT_4CH.h b/lib/Hoymiles/src/inverters/HMT_4CH.h
index 01d32893..8f26c14b 100644
--- a/lib/Hoymiles/src/inverters/HMT_4CH.h
+++ b/lib/Hoymiles/src/inverters/HMT_4CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HMT_6CH.cpp b/lib/Hoymiles/src/inverters/HMT_6CH.cpp
index 2c3dd5f3..9e835671 100644
--- a/lib/Hoymiles/src/inverters/HMT_6CH.cpp
+++ b/lib/Hoymiles/src/inverters/HMT_6CH.cpp
@@ -72,6 +72,15 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_A },
+    { CH2, MPPT_B },
+    { CH3, MPPT_B },
+    { CH4, MPPT_C },
+    { CH5, MPPT_C }
+};
+
 HMT_6CH::HMT_6CH(HoymilesRadio* radio, const uint64_t serial)
     : HMT_Abstract(radio, serial) {};
 
@@ -96,3 +105,13 @@ uint8_t HMT_6CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HMT_6CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HMT_6CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HMT_6CH.h b/lib/Hoymiles/src/inverters/HMT_6CH.h
index 6b728006..ab849174 100644
--- a/lib/Hoymiles/src/inverters/HMT_6CH.h
+++ b/lib/Hoymiles/src/inverters/HMT_6CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HM_1CH.cpp b/lib/Hoymiles/src/inverters/HM_1CH.cpp
index 0f0c64c2..37761942 100644
--- a/lib/Hoymiles/src/inverters/HM_1CH.cpp
+++ b/lib/Hoymiles/src/inverters/HM_1CH.cpp
@@ -28,6 +28,10 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A }
+};
+
 HM_1CH::HM_1CH(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial) {};
 
@@ -36,10 +40,10 @@ bool HM_1CH::isValidSerial(const uint64_t serial)
     // serial >= 0x112100000000 && serial <= 0x1121ffffffff
 
     uint8_t preId[2];
-    preId[0] = (uint8_t)(serial >> 40);
-    preId[1] = (uint8_t)(serial >> 32);
+    preId[0] = static_cast<uint8_t>(serial >> 40);
+    preId[1] = static_cast<uint8_t>(serial >> 32);
 
-    if ((uint8_t)(((((uint16_t)preId[0] << 8) | preId[1]) >> 4) & 0xff) == 0x12) {
+    if (static_cast<uint8_t>((((static_cast<uint16_t>(preId[0]) << 8) | preId[1]) >> 4) & 0xff) == 0x12) {
         return true;
     }
 
@@ -65,3 +69,13 @@ uint8_t HM_1CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HM_1CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HM_1CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HM_1CH.h b/lib/Hoymiles/src/inverters/HM_1CH.h
index a35b4e56..60724aab 100644
--- a/lib/Hoymiles/src/inverters/HM_1CH.h
+++ b/lib/Hoymiles/src/inverters/HM_1CH.h
@@ -11,4 +11,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HM_2CH.cpp b/lib/Hoymiles/src/inverters/HM_2CH.cpp
index 02dd8ae4..28778463 100644
--- a/lib/Hoymiles/src/inverters/HM_2CH.cpp
+++ b/lib/Hoymiles/src/inverters/HM_2CH.cpp
@@ -36,6 +36,11 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_B }
+};
+
 HM_2CH::HM_2CH(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial) {};
 
@@ -44,10 +49,10 @@ bool HM_2CH::isValidSerial(const uint64_t serial)
     // serial >= 0x114100000000 && serial <= 0x1141ffffffff
 
     uint8_t preId[2];
-    preId[0] = (uint8_t)(serial >> 40);
-    preId[1] = (uint8_t)(serial >> 32);
+    preId[0] = static_cast<uint8_t>(serial >> 40);
+    preId[1] = static_cast<uint8_t>(serial >> 32);
 
-    if ((uint8_t)(((((uint16_t)preId[0] << 8) | preId[1]) >> 4) & 0xff) == 0x14) {
+    if (static_cast<uint8_t>((((static_cast<uint16_t>(preId[0]) << 8) | preId[1]) >> 4) & 0xff) == 0x14) {
         return true;
     }
 
@@ -73,3 +78,13 @@ uint8_t HM_2CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HM_2CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HM_2CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HM_2CH.h b/lib/Hoymiles/src/inverters/HM_2CH.h
index 1fd54496..34e9dbc0 100644
--- a/lib/Hoymiles/src/inverters/HM_2CH.h
+++ b/lib/Hoymiles/src/inverters/HM_2CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HM_4CH.cpp b/lib/Hoymiles/src/inverters/HM_4CH.cpp
index 586248b5..4d90e4ad 100644
--- a/lib/Hoymiles/src/inverters/HM_4CH.cpp
+++ b/lib/Hoymiles/src/inverters/HM_4CH.cpp
@@ -49,6 +49,13 @@ static const byteAssign_t byteAssignment[] = {
     { TYPE_INV, CH0, FLD_EFF, UNIT_PCT, CALC_TOTAL_EFF, 0, CMD_CALC, false, 3 }
 };
 
+static const channelMetaData_t channelMetaData[] = {
+    { CH0, MPPT_A },
+    { CH1, MPPT_A },
+    { CH2, MPPT_B },
+    { CH3, MPPT_B }
+};
+
 HM_4CH::HM_4CH(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial) {};
 
@@ -57,10 +64,10 @@ bool HM_4CH::isValidSerial(const uint64_t serial)
     // serial >= 0x116100000000 && serial <= 0x1161ffffffff
 
     uint8_t preId[2];
-    preId[0] = (uint8_t)(serial >> 40);
-    preId[1] = (uint8_t)(serial >> 32);
+    preId[0] = static_cast<uint8_t>(serial >> 40);
+    preId[1] = static_cast<uint8_t>(serial >> 32);
 
-    if ((uint8_t)(((((uint16_t)preId[0] << 8) | preId[1]) >> 4) & 0xff) == 0x16) {
+    if (static_cast<uint8_t>((((static_cast<uint16_t>(preId[0]) << 8) | preId[1]) >> 4) & 0xff) == 0x16) {
         return true;
     }
 
@@ -86,3 +93,13 @@ uint8_t HM_4CH::getByteAssignmentSize() const
 {
     return sizeof(byteAssignment) / sizeof(byteAssignment[0]);
 }
+
+const channelMetaData_t* HM_4CH::getChannelMetaData() const
+{
+    return channelMetaData;
+}
+
+uint8_t HM_4CH::getChannelMetaDataSize() const
+{
+    return sizeof(channelMetaData) / sizeof(channelMetaData[0]);
+}
diff --git a/lib/Hoymiles/src/inverters/HM_4CH.h b/lib/Hoymiles/src/inverters/HM_4CH.h
index e54f3323..cce04578 100644
--- a/lib/Hoymiles/src/inverters/HM_4CH.h
+++ b/lib/Hoymiles/src/inverters/HM_4CH.h
@@ -10,4 +10,6 @@ public:
     String typeName() const;
     const byteAssign_t* getByteAssignment() const;
     uint8_t getByteAssignmentSize() const;
-};
\ No newline at end of file
+    const channelMetaData_t* getChannelMetaData() const;
+    uint8_t getChannelMetaDataSize() const;
+};
diff --git a/lib/Hoymiles/src/inverters/HM_Abstract.cpp b/lib/Hoymiles/src/inverters/HM_Abstract.cpp
index c99d4cfc..9f426af4 100644
--- a/lib/Hoymiles/src/inverters/HM_Abstract.cpp
+++ b/lib/Hoymiles/src/inverters/HM_Abstract.cpp
@@ -50,13 +50,13 @@ bool HM_Abstract::sendAlarmLogRequest(const bool force)
 
     if (!force) {
         if (Statistics()->hasChannelFieldValue(TYPE_INV, CH0, FLD_EVT_LOG)) {
-            if ((uint8_t)Statistics()->getChannelFieldValue(TYPE_INV, CH0, FLD_EVT_LOG) == _lastAlarmLogCnt) {
+            if (static_cast<uint8_t>(Statistics()->getChannelFieldValue(TYPE_INV, CH0, FLD_EVT_LOG) == _lastAlarmLogCnt)) {
                 return false;
             }
         }
     }
 
-    _lastAlarmLogCnt = (uint8_t)Statistics()->getChannelFieldValue(TYPE_INV, CH0, FLD_EVT_LOG);
+    _lastAlarmLogCnt = static_cast<uint8_t>(Statistics()->getChannelFieldValue(TYPE_INV, CH0, FLD_EVT_LOG));
 
     time_t now;
     time(&now);
diff --git a/lib/Hoymiles/src/inverters/InverterAbstract.cpp b/lib/Hoymiles/src/inverters/InverterAbstract.cpp
index 5d52a380..033fbb05 100644
--- a/lib/Hoymiles/src/inverters/InverterAbstract.cpp
+++ b/lib/Hoymiles/src/inverters/InverterAbstract.cpp
@@ -14,8 +14,8 @@ InverterAbstract::InverterAbstract(HoymilesRadio* radio, const uint64_t serial)
 
     char serial_buff[sizeof(uint64_t) * 8 + 1];
     snprintf(serial_buff, sizeof(serial_buff), "%0x%08x",
-        ((uint32_t)((serial >> 32) & 0xFFFFFFFF)),
-        ((uint32_t)(serial & 0xFFFFFFFF)));
+        static_cast<uint32_t>((serial >> 32) & 0xFFFFFFFF),
+        static_cast<uint32_t>(serial & 0xFFFFFFFF));
     _serialString = serial_buff;
 
     _alarmLogParser.reset(new AlarmLogParser());
@@ -298,3 +298,35 @@ void InverterAbstract::resetRadioStats()
 {
     RadioStats = {};
 }
+
+std::vector<ChannelNum_t> InverterAbstract::getChannelsDC() const
+{
+    std::vector<ChannelNum_t> l;
+    for (uint8_t i = 0; i < getChannelMetaDataSize(); i++) {
+        l.push_back(getChannelMetaData()[i].ch);
+    }
+    return l;
+}
+
+std::vector<MpptNum_t> InverterAbstract::getMppts() const
+{
+    std::vector<MpptNum_t> l;
+    for (uint8_t i = 0; i < getChannelMetaDataSize(); i++) {
+        auto m = getChannelMetaData()[i].mppt;
+        if (l.end() == std::find(l.begin(), l.end(), m)){
+            l.push_back(m);
+        }
+    }
+    return l;
+}
+
+std::vector<ChannelNum_t> InverterAbstract::getChannelsDCByMppt(const MpptNum_t mppt) const
+{
+    std::vector<ChannelNum_t> l;
+    for (uint8_t i = 0; i < getChannelMetaDataSize(); i++) {
+        if (getChannelMetaData()[i].mppt == mppt) {
+            l.push_back(getChannelMetaData()[i].ch);
+        }
+    }
+    return l;
+}
diff --git a/lib/Hoymiles/src/inverters/InverterAbstract.h b/lib/Hoymiles/src/inverters/InverterAbstract.h
index 29fba12f..db2ed255 100644
--- a/lib/Hoymiles/src/inverters/InverterAbstract.h
+++ b/lib/Hoymiles/src/inverters/InverterAbstract.h
@@ -24,6 +24,20 @@ enum {
     FRAGMENT_OK = 0
 };
 
+enum MpptNum_t {
+    MPPT_A = 0,
+    MPPT_B,
+    MPPT_C,
+    MPPT_D,
+    MPPT_CNT
+};
+
+// additional meta data per input channel
+typedef struct {
+    ChannelNum_t ch; // channel 0 - 5
+    MpptNum_t mppt; // mppt a - d (0 - 3)
+} channelMetaData_t;
+
 #define MAX_RF_FRAGMENT_COUNT 13
 
 class CommandAbstract;
@@ -40,6 +54,9 @@ public:
     virtual const byteAssign_t* getByteAssignment() const = 0;
     virtual uint8_t getByteAssignmentSize() const = 0;
 
+    virtual const channelMetaData_t* getChannelMetaData() const = 0;
+    virtual uint8_t getChannelMetaDataSize() const = 0;
+
     bool isProducing();
     bool isReachable();
 
@@ -112,6 +129,10 @@ public:
     StatisticsParser* Statistics();
     SystemConfigParaParser* SystemConfigPara();
 
+    std::vector<MpptNum_t> getMppts() const;
+    std::vector<ChannelNum_t> getChannelsDC() const;
+    std::vector<ChannelNum_t> getChannelsDCByMppt(const MpptNum_t mppt) const;
+
 protected:
     HoymilesRadio* _radio;
 
diff --git a/lib/Hoymiles/src/parser/AlarmLogParser.cpp b/lib/Hoymiles/src/parser/AlarmLogParser.cpp
index 30b81364..027dd84b 100644
--- a/lib/Hoymiles/src/parser/AlarmLogParser.cpp
+++ b/lib/Hoymiles/src/parser/AlarmLogParser.cpp
@@ -243,7 +243,7 @@ void AlarmLogParser::getLogEntry(const uint8_t entryId, AlarmLogEntry_t& entry,
 
     HOY_SEMAPHORE_TAKE();
 
-    const uint32_t wcode = (uint16_t)_payloadAlarmLog[entryStartOffset] << 8 | _payloadAlarmLog[entryStartOffset + 1];
+    const uint32_t wcode = static_cast<uint16_t>(_payloadAlarmLog[entryStartOffset]) << 8 | _payloadAlarmLog[entryStartOffset + 1];
     uint32_t startTimeOffset = 0;
     if (((wcode >> 13) & 0x01) == 1) {
         startTimeOffset = 12 * 60 * 60;
@@ -255,8 +255,8 @@ void AlarmLogParser::getLogEntry(const uint8_t entryId, AlarmLogEntry_t& entry,
     }
 
     entry.MessageId = _payloadAlarmLog[entryStartOffset + 1];
-    entry.StartTime = (((uint16_t)_payloadAlarmLog[entryStartOffset + 4] << 8) | ((uint16_t)_payloadAlarmLog[entryStartOffset + 5])) + startTimeOffset + timezoneOffset;
-    entry.EndTime = ((uint16_t)_payloadAlarmLog[entryStartOffset + 6] << 8) | ((uint16_t)_payloadAlarmLog[entryStartOffset + 7]);
+    entry.StartTime = ((static_cast<uint16_t>(_payloadAlarmLog[entryStartOffset + 4]) << 8) | static_cast<uint16_t>(_payloadAlarmLog[entryStartOffset + 5])) + startTimeOffset + timezoneOffset;
+    entry.EndTime = (static_cast<uint16_t>(_payloadAlarmLog[entryStartOffset + 6]) << 8) | static_cast<uint16_t>(_payloadAlarmLog[entryStartOffset + 7]);
 
     HOY_SEMAPHORE_GIVE();
 
diff --git a/lib/Hoymiles/src/parser/DevInfoParser.cpp b/lib/Hoymiles/src/parser/DevInfoParser.cpp
index 0c2e15e8..fb0fe3e8 100644
--- a/lib/Hoymiles/src/parser/DevInfoParser.cpp
+++ b/lib/Hoymiles/src/parser/DevInfoParser.cpp
@@ -61,6 +61,7 @@ const devInfo_t devInfo[] = {
     { { 0x10, 0x10, 0x71, ALL }, 500, "HMS-500-1T" }, // 02
     { { 0x10, 0x20, 0x71, ALL }, 500, "HMS-500-1T v2" }, // 02
     { { 0x10, 0x21, 0x11, ALL }, 600, "HMS-600-2T" }, // 01
+    { { 0x10, 0x21, 0x21, ALL }, 700, "HMS-700-2T" }, // 00
     { { 0x10, 0x21, 0x41, ALL }, 800, "HMS-800-2T" }, // 00
     { { 0x10, 0x11, 0x41, ALL }, 800, "HMS-800-2T-LV" }, // 00
     { { 0x10, 0x11, 0x51, ALL }, 900, "HMS-900-2T" }, // 01
@@ -149,7 +150,7 @@ void DevInfoParser::setLastUpdateSimple(const uint32_t lastUpdate)
 uint16_t DevInfoParser::getFwBuildVersion() const
 {
     HOY_SEMAPHORE_TAKE();
-    const uint16_t ret = (((uint16_t)_payloadDevInfoAll[0]) << 8) | _payloadDevInfoAll[1];
+    const uint16_t ret = (static_cast<uint16_t>(_payloadDevInfoAll[0]) << 8) | _payloadDevInfoAll[1];
     HOY_SEMAPHORE_GIVE();
     return ret;
 }
@@ -158,13 +159,13 @@ time_t DevInfoParser::getFwBuildDateTime() const
 {
     struct tm timeinfo = {};
     HOY_SEMAPHORE_TAKE();
-    timeinfo.tm_year = ((((uint16_t)_payloadDevInfoAll[2]) << 8) | _payloadDevInfoAll[3]) - 1900;
+    timeinfo.tm_year = ((static_cast<uint16_t>(_payloadDevInfoAll[2]) << 8) | _payloadDevInfoAll[3]) - 1900;
 
-    timeinfo.tm_mon = ((((uint16_t)_payloadDevInfoAll[4]) << 8) | _payloadDevInfoAll[5]) / 100 - 1;
-    timeinfo.tm_mday = ((((uint16_t)_payloadDevInfoAll[4]) << 8) | _payloadDevInfoAll[5]) % 100;
+    timeinfo.tm_mon = ((static_cast<uint16_t>(_payloadDevInfoAll[4]) << 8) | _payloadDevInfoAll[5]) / 100 - 1;
+    timeinfo.tm_mday = ((static_cast<uint16_t>(_payloadDevInfoAll[4]) << 8) | _payloadDevInfoAll[5]) % 100;
 
-    timeinfo.tm_hour = ((((uint16_t)_payloadDevInfoAll[6]) << 8) | _payloadDevInfoAll[7]) / 100;
-    timeinfo.tm_min = ((((uint16_t)_payloadDevInfoAll[6]) << 8) | _payloadDevInfoAll[7]) % 100;
+    timeinfo.tm_hour = ((static_cast<uint16_t>(_payloadDevInfoAll[6]) << 8) | _payloadDevInfoAll[7]) / 100;
+    timeinfo.tm_min = ((static_cast<uint16_t>(_payloadDevInfoAll[6]) << 8) | _payloadDevInfoAll[7]) % 100;
     HOY_SEMAPHORE_GIVE();
 
     return timegm(&timeinfo);
@@ -181,7 +182,7 @@ String DevInfoParser::getFwBuildDateTimeStr() const
 uint16_t DevInfoParser::getFwBootloaderVersion() const
 {
     HOY_SEMAPHORE_TAKE();
-    const uint16_t ret = (((uint16_t)_payloadDevInfoAll[8]) << 8) | _payloadDevInfoAll[9];
+    const uint16_t ret = (static_cast<uint16_t>(_payloadDevInfoAll[8]) << 8) | _payloadDevInfoAll[9];
     HOY_SEMAPHORE_GIVE();
     return ret;
 }
@@ -189,11 +190,11 @@ uint16_t DevInfoParser::getFwBootloaderVersion() const
 uint32_t DevInfoParser::getHwPartNumber() const
 {
     HOY_SEMAPHORE_TAKE();
-    const uint16_t hwpn_h = (((uint16_t)_payloadDevInfoSimple[2]) << 8) | _payloadDevInfoSimple[3];
-    const uint16_t hwpn_l = (((uint16_t)_payloadDevInfoSimple[4]) << 8) | _payloadDevInfoSimple[5];
+    const uint16_t hwpn_h = (static_cast<uint16_t>(_payloadDevInfoSimple[2]) << 8) | _payloadDevInfoSimple[3];
+    const uint16_t hwpn_l = (static_cast<uint16_t>(_payloadDevInfoSimple[4]) << 8) | _payloadDevInfoSimple[5];
     HOY_SEMAPHORE_GIVE();
 
-    return ((uint32_t)hwpn_h << 16) | ((uint32_t)hwpn_l);
+    return (static_cast<uint32_t>(hwpn_h) << 16) | static_cast<uint32_t>(hwpn_l);
 }
 
 String DevInfoParser::getHwVersion() const
diff --git a/lib/Hoymiles/src/parser/GridProfileParser.cpp b/lib/Hoymiles/src/parser/GridProfileParser.cpp
index 489565e1..2f50bd50 100644
--- a/lib/Hoymiles/src/parser/GridProfileParser.cpp
+++ b/lib/Hoymiles/src/parser/GridProfileParser.cpp
@@ -443,7 +443,7 @@ std::list<GridProfileSection_t> GridProfileParser::getProfile() const
             for (uint8_t val_id = 0; val_id < section_size; val_id++) {
                 auto itemDefinition = itemDefinitions.at(_profileValues[section_start + val_id].ItemDefinition);
 
-                float value = (int16_t)((_payloadGridProfile[pos] << 8) | _payloadGridProfile[pos + 1]);
+                float value = static_cast<int16_t>((_payloadGridProfile[pos] << 8) | _payloadGridProfile[pos + 1]);
                 value /= itemDefinition.Divider;
 
                 GridProfileItem_t v;
diff --git a/lib/Hoymiles/src/parser/SystemConfigParaParser.cpp b/lib/Hoymiles/src/parser/SystemConfigParaParser.cpp
index 346b5d46..f01af707 100644
--- a/lib/Hoymiles/src/parser/SystemConfigParaParser.cpp
+++ b/lib/Hoymiles/src/parser/SystemConfigParaParser.cpp
@@ -45,7 +45,7 @@ void SystemConfigParaParser::appendFragment(const uint8_t offset, const uint8_t*
 float SystemConfigParaParser::getLimitPercent() const
 {
     HOY_SEMAPHORE_TAKE();
-    const float ret = ((((uint16_t)_payload[2]) << 8) | _payload[3]) / 10.0;
+    const float ret = ((static_cast<uint16_t>(_payload[2]) << 8) | _payload[3]) / 10.0;
     HOY_SEMAPHORE_GIVE();
     return ret;
 }
@@ -53,8 +53,8 @@ float SystemConfigParaParser::getLimitPercent() const
 void SystemConfigParaParser::setLimitPercent(const float value)
 {
     HOY_SEMAPHORE_TAKE();
-    _payload[2] = ((uint16_t)(value * 10)) >> 8;
-    _payload[3] = ((uint16_t)(value * 10));
+    _payload[2] = static_cast<uint16_t>(value * 10) >> 8;
+    _payload[3] = static_cast<uint16_t>(value * 10);
     HOY_SEMAPHORE_GIVE();
 }
 
diff --git a/lib/VeDirectFrameHandler/VeDirectData.cpp b/lib/VeDirectFrameHandler/VeDirectData.cpp
index a67175fd..d929a471 100644
--- a/lib/VeDirectFrameHandler/VeDirectData.cpp
+++ b/lib/VeDirectFrameHandler/VeDirectData.cpp
@@ -143,6 +143,17 @@ frozen::string const& veStruct::getPidAsString() const
  */
 uint32_t veStruct::getFwVersionAsInteger() const
 {
+	if (strlen(firmwareVer_FW) == 0) {
+		if (strlen(firmwareVer_FWE) == 0) { return 0; }
+
+		// the firmware version from the FWE field may be preceeded by a zero
+		// for padding as per VE.Direct protocol, which is fine for strtoul()
+		// when we use a fixed base. however, the postfix (2 chars) might be
+		// numeric as well to indicate a beta release, which we must not parse.
+		std::string strVer(firmwareVer_FWE, strlen(firmwareVer_FWE) - 2);
+		return static_cast<uint32_t>(strtoul(strVer.c_str(), nullptr, 10));
+	}
+
 	char const* strVersion = firmwareVer_FW;
 
 	// VE.Direct protocol manual states that the first char can be a non-digit,
@@ -157,6 +168,34 @@ uint32_t veStruct::getFwVersionAsInteger() const
  */
 String veStruct::getFwVersionFormatted() const
 {
+	if (strlen(firmwareVer_FW) == 0 && strlen(firmwareVer_FWE) == 0) {
+		return "n/a";
+	}
+
+	if (strlen(firmwareVer_FWE) > 0) {
+		char const* strVersion = firmwareVer_FWE;
+
+		// the firmware version from the FWE field may be preceeded by a zero
+		// for padding as per VE.Direct protocol.
+		while (strVersion[0] == '0') { ++strVersion; }
+
+		String res(strVersion[0]);
+		strVersion++;
+		res += ".";
+		res += strVersion[0];
+		strVersion++;
+		res += strVersion[0];
+		strVersion++;
+
+		String suffix(strVersion);
+		suffix.toUpperCase();
+		if (suffix == "FF") { return res; }
+
+		res += "-beta-";
+		res += suffix;
+		return res;
+	}
+
 	char const* strVersion = firmwareVer_FW;
 	char rc = 0;
 
@@ -191,7 +230,7 @@ frozen::string const& veMpptStruct::getCsAsString() const
 		{ 0,   "OFF" },
 		{ 2,   "Fault" },
 		{ 3,   "Bulk" },
-		{ 4,   "Absorbtion" },
+		{ 4,   "Absorption" },
 		{ 5,   "Float" },
 		{ 7,   "Equalize (manual)" },
 		{ 245, "Starting-up" },
@@ -287,18 +326,27 @@ frozen::string const& VeDirectHexData::getResponseAsString() const
 frozen::string const& VeDirectHexData::getRegisterAsString() const
 {
 	using Register = VeDirectHexRegister;
-	static constexpr frozen::map<Register, frozen::string, 11> values = {
+	static constexpr frozen::map<Register, frozen::string, 20> values = {
 		{ Register::DeviceMode, "Device Mode" },
 		{ Register::DeviceState, "Device State" },
 		{ Register::RemoteControlUsed, "Remote Control Used" },
 		{ Register::PanelVoltage, "Panel Voltage" },
+		{ Register::PanelPower, "Panel Power" },
 		{ Register::ChargerVoltage, "Charger Voltage" },
+		{ Register::ChargerCurrent, "Charger Current" },
 		{ Register::NetworkTotalDcInputPower, "Network Total DC Input Power" },
 		{ Register::ChargeControllerTemperature, "Charger Controller Temperature" },
 		{ Register::SmartBatterySenseTemperature, "Smart Battery Sense Temperature" },
 		{ Register::NetworkInfo, "Network Info" },
 		{ Register::NetworkMode, "Network Mode" },
-		{ Register::NetworkStatus, "Network Status" }
+		{ Register::NetworkStatus, "Network Status" },
+		{ Register::BatteryAbsorptionVoltage, "Battery Absorption Voltage" },
+		{ Register::BatteryFloatVoltage, "Battery Float Voltage" },
+		{ Register::TotalChargeCurrent, "Total Charge Current" },
+		{ Register::ChargeStateElapsedTime, "Charge State Elapsed Time" },
+		{ Register::BatteryVoltageSense, "Battery Voltage Sense" },
+		{ Register::LoadCurrent, "Load current" },
+		{ Register::LoadOutputVoltage, "Load Output Voltage" }
 	};
 
 	return getAsString(values, addr);
diff --git a/lib/VeDirectFrameHandler/VeDirectData.h b/lib/VeDirectFrameHandler/VeDirectData.h
index 34c6b899..4cda9127 100644
--- a/lib/VeDirectFrameHandler/VeDirectData.h
+++ b/lib/VeDirectFrameHandler/VeDirectData.h
@@ -11,6 +11,8 @@ typedef struct {
     uint16_t productID_PID = 0;             // product id
     char serialNr_SER[VE_MAX_VALUE_LEN];    // serial number
     char firmwareVer_FW[VE_MAX_VALUE_LEN];  // firmware release number
+    // some devices use "FWE" instead of "FW" for the firmware version.
+    char firmwareVer_FWE[VE_MAX_VALUE_LEN]; // firmware release number (alternative field)
     uint32_t batteryVoltage_V_mV = 0;       // battery voltage in mV
     int32_t batteryCurrent_I_mA = 0;        // battery current in mA (can be negative)
     float mpptEfficiency_Percent = 0;       // efficiency in percent (calculated, moving average)
@@ -26,8 +28,6 @@ struct veMpptStruct : veStruct {
     uint32_t panelVoltage_VPV_mV;       // panel voltage in mV
     uint32_t panelCurrent_mA;           // panel current in mA (calculated)
     int16_t  batteryOutputPower_W;      // battery output power in W (calculated, can be negative if load output is used)
-    uint32_t loadCurrent_IL_mA;         // Load current in mA (Available only for models with a load output)
-    bool     loadOutputState_LOAD;      // virtual load output state (on if battery voltage reaches upper limit, off if battery reaches lower limit)
     uint8_t  currentState_CS;           // current state of operation e.g. OFF or Bulk
     uint8_t  errorCode_ERR;             // error code
     uint32_t offReason_OR;              // off reason
@@ -38,6 +38,15 @@ struct veMpptStruct : veStruct {
     uint32_t yieldYesterday_H22_Wh;     // yield yesterday Wh
     uint16_t maxPowerYesterday_H23_W;   // maximum power yesterday W
 
+    // these are optional values communicated through the TEXT protocol. the pair's first
+    // value is the timestamp the respective info was last received. if it is
+    // zero, the value is deemed invalid. the timestamp is reset if no current
+    // value could be retrieved.
+    std::pair<uint32_t, bool> loadOutputState_LOAD;     // physical load output or virtual load output state (on if battery voltage
+                                                        // reaches upper limit, off if battery reaches lower limit)
+    std::pair<uint32_t, uint32_t> loadCurrent_IL_mA;    // Load current in mA (Available only for models with a physical load output)
+    std::pair<uint32_t, bool> relayState_RELAY;         // relay alarm state. On=true, Off=false
+
     // these are values communicated through the HEX protocol. the pair's first
     // value is the timestamp the respective info was last received. if it is
     // zero, the value is deemed invalid. the timestamp is reset if no current
@@ -45,6 +54,8 @@ struct veMpptStruct : veStruct {
     std::pair<uint32_t, int32_t> MpptTemperatureMilliCelsius;
     std::pair<uint32_t, int32_t> SmartBatterySenseTemperatureMilliCelsius;
     std::pair<uint32_t, uint32_t> NetworkTotalDcInputPowerMilliWatts;
+    std::pair<uint32_t, uint32_t> BatteryAbsorptionMilliVolt;
+    std::pair<uint32_t, uint32_t> BatteryFloatMilliVolt;
     std::pair<uint32_t, uint8_t> NetworkInfo;
     std::pair<uint32_t, uint8_t> NetworkMode;
     std::pair<uint32_t, uint8_t> NetworkStatus;
@@ -121,7 +132,9 @@ enum class VeDirectHexRegister : uint16_t {
     DeviceState = 0x0201,
     RemoteControlUsed = 0x0202,
     PanelVoltage = 0xEDBB,
+    PanelPower = 0xEDBC,
     ChargerVoltage = 0xEDD5,
+    ChargerCurrent = 0xEDD7,
     NetworkTotalDcInputPower = 0x2027,
     ChargeControllerTemperature = 0xEDDB,
     SmartBatterySenseTemperature = 0xEDEC,
@@ -129,7 +142,14 @@ enum class VeDirectHexRegister : uint16_t {
     NetworkMode = 0x200E,
     NetworkStatus = 0x200F,
     HistoryTotal = 0x104F,
-    HistoryMPPTD30 = 0x10BE
+    HistoryMPPTD30 = 0x10BE,
+    BatteryAbsorptionVoltage = 0xEDF7,
+    BatteryFloatVoltage = 0xEDF6,
+    TotalChargeCurrent = 0x2013,
+    ChargeStateElapsedTime= 0x2007,
+    BatteryVoltageSense = 0x2002,
+    LoadCurrent = 0xEDAD,
+    LoadOutputVoltage = 0xEDA9
 };
 
 struct VeDirectHexData {
diff --git a/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp b/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp
index 9de8151d..6073c56d 100644
--- a/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp
+++ b/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp
@@ -249,10 +249,18 @@ void VeDirectFrameHandler<T>::processTextData(std::string const& name, std::stri
 	}
 
 	if (name == "FW") {
+		_tmpFrame.firmwareVer_FWE[0] = '\0';
 		strncpy(_tmpFrame.firmwareVer_FW, value.c_str(), sizeof(_tmpFrame.firmwareVer_FW));
 		return;
 	}
 
+	// some devices use "FWE" instead of "FW" for the firmware version.
+	if (name == "FWE") {
+		_tmpFrame.firmwareVer_FW[0] = '\0';
+		strncpy(_tmpFrame.firmwareVer_FWE, value.c_str(), sizeof(_tmpFrame.firmwareVer_FWE));
+		return;
+	}
+
 	if (name == "V") {
 		_tmpFrame.batteryVoltage_V_mV = atol(value.c_str());
 		return;
diff --git a/lib/VeDirectFrameHandler/VeDirectFrameHandler.h b/lib/VeDirectFrameHandler/VeDirectFrameHandler.h
index 244caf3f..86636e87 100644
--- a/lib/VeDirectFrameHandler/VeDirectFrameHandler.h
+++ b/lib/VeDirectFrameHandler/VeDirectFrameHandler.h
@@ -27,12 +27,13 @@ public:
     bool isDataValid() const;                    // return true if data valid and not outdated
     T const& getData() const { return _tmpFrame; }
     bool sendHexCommand(VeDirectHexCommand cmd, VeDirectHexRegister addr, uint32_t value = 0, uint8_t valsize = 0);
+    bool isStateIdle() const { return (_state == State::IDLE); }
 
 protected:
     VeDirectFrameHandler();
     void init(char const* who, int8_t rx, int8_t tx, Print* msgOut,
         bool verboseLogging, uint8_t hwSerialPort);
-    virtual bool hexDataHandler(VeDirectHexData const &data) { return false; } // handles the disassembeled hex response
+    virtual bool hexDataHandler(VeDirectHexData const &data) { return false; } // handles the disassembled hex response
 
     bool _verboseLogging;
     Print* _msgOut;
diff --git a/lib/VeDirectFrameHandler/VeDirectFrameHexHandler.cpp b/lib/VeDirectFrameHandler/VeDirectFrameHexHandler.cpp
index 392d2f8a..8256f1ea 100644
--- a/lib/VeDirectFrameHandler/VeDirectFrameHexHandler.cpp
+++ b/lib/VeDirectFrameHandler/VeDirectFrameHexHandler.cpp
@@ -8,7 +8,7 @@ HexHandler.cpp
  * 1. Use sendHexCommand() to send hex messages. Use the Victron documentation to find the parameter.
  * 2. The from class "VeDirectFrameHandler" derived class X must overwrite the function
  *    void VeDirectFrameHandler::hexDataHandler(VeDirectHexData const &data)
- *    to handle the received hex messages. All hex messages will be forwarted to function hexDataHandler()
+ *    to handle the received hex messages. All hex messages will be forwarded to function hexDataHandler()
  * 3. Analyse the content of data (struct VeDirectHexData) to check if a message fits.
  *
  * 2024.03.08 - 0.4 - adds the ability to send hex commands and to parse hex messages
@@ -63,9 +63,9 @@ static uint32_t AsciiHexLE2Int(const char *ascii, const uint8_t anz) {
  * disassembleHexData()
  * analysis the hex message and extract: response, address, flags and value/text
  * buffer:  pointer to message (ascii hex little endian format)
- * data:    disassembeled message
- * return:  true = successful disassembeld, false = hex sum fault or message
- *          do not aligin with VE.Diekt syntax
+ * data:    disassembled message
+ * return:  true = successful disassembled, false = hex sum fault or message
+ *          do not align with VE.Direct syntax
  */
 template<typename T>
 bool VeDirectFrameHandler<T>::disassembleHexData(VeDirectHexData &data) {
@@ -164,14 +164,14 @@ static String Int2HexLEString(uint32_t value, uint8_t anz) {
  * addr:    register address, default 0
  * value:   value to write into a register, default 0
  * valsize: size of the value, 8, 16 or 32 bit, default 0
- * return:  true = message assembeld and send, false = it was not possible to put the message together
+ * return:  true = message assembled and send, false = it was not possible to put the message together
  * SAMPLE:  ping command: sendHexCommand(PING),
  *          read total DC input power sendHexCommand(GET, 0xEDEC)
  *          set Charge current limit 10A sendHexCommand(SET, 0x2015, 64, 16)
  *
  * WARNING: some values are stored in non-volatile memory. Continuous writing, for example from a control loop, will
  *          lead to early failure.
- *          On MPPT for example 0xEDE0 - 0xEDFF. Check the Vivtron doc "BlueSolar-HEX-protocol.pdf"
+ *          On MPPT for example 0xEDE0 - 0xEDFF. Check the Victron doc "BlueSolar-HEX-protocol.pdf"
  */
 template<typename T>
 bool VeDirectFrameHandler<T>::sendHexCommand(VeDirectHexCommand cmd, VeDirectHexRegister addr, uint32_t value, uint8_t valsize) {
diff --git a/lib/VeDirectFrameHandler/VeDirectMpptController.cpp b/lib/VeDirectFrameHandler/VeDirectMpptController.cpp
index 6630a4ce..d4e9dac5 100644
--- a/lib/VeDirectFrameHandler/VeDirectMpptController.cpp
+++ b/lib/VeDirectFrameHandler/VeDirectMpptController.cpp
@@ -22,11 +22,18 @@ void VeDirectMpptController::init(int8_t rx, int8_t tx, Print* msgOut,
 bool VeDirectMpptController::processTextDataDerived(std::string const& name, std::string const& value)
 {
 	if (name == "IL") {
-		_tmpFrame.loadCurrent_IL_mA = atol(value.c_str());
+		_tmpFrame.loadCurrent_IL_mA.second = atol(value.c_str());
+        _tmpFrame.loadCurrent_IL_mA.first = millis();
 		return true;
 	}
 	if (name == "LOAD") {
-		_tmpFrame.loadOutputState_LOAD = (value == "ON");
+		_tmpFrame.loadOutputState_LOAD.second = (value == "ON");
+        _tmpFrame.loadOutputState_LOAD.first = millis();
+		return true;
+	}
+    if (name == "RELAY") {
+		_tmpFrame.relayState_RELAY.second = (value == "ON");
+        _tmpFrame.relayState_RELAY.first = millis();
 		return true;
 	}
 	if (name == "CS") {
@@ -97,51 +104,46 @@ void VeDirectMpptController::frameValidEvent() {
 	}
 
 	// calculation of the MPPT efficiency
-	float totalPower_W = (_tmpFrame.loadCurrent_IL_mA / 1000.0f + _tmpFrame.batteryCurrent_I_mA / 1000.0f) * _tmpFrame.batteryVoltage_V_mV /1000.0f;
+    float loadCurrent = (_tmpFrame.loadCurrent_IL_mA.first > 0) ? _tmpFrame.loadCurrent_IL_mA.second / 1000.0f : 0.0f;
+	float totalPower_W = (loadCurrent + _tmpFrame.batteryCurrent_I_mA / 1000.0f) * _tmpFrame.batteryVoltage_V_mV / 1000.0f;
 	if (_tmpFrame.panelPower_PPV_W > 0) {
 		_efficiency.addNumber(totalPower_W * 100.0f / _tmpFrame.panelPower_PPV_W);
 		_tmpFrame.mpptEfficiency_Percent = _efficiency.getAverage();
 	} else {
 		_tmpFrame.mpptEfficiency_Percent = 0.0f;
 	}
-
-	if (!_canSend) { return; }
-
-	// Copy from the "VE.Direct Protocol" documentation
-	// For firmware version v1.52 and below, when no VE.Direct queries are sent to the device, the
-	// charger periodically sends human readable (TEXT) data to the serial port. For firmware
-	// versions v1.53 and above, the charger always periodically sends TEXT data to the serial port.
-	// --> We just use hex commandes for firmware >= 1.53 to keep text messages alive
-	if (_tmpFrame.getFwVersionAsInteger() < 153) { return; }
-
-	using Command = VeDirectHexCommand;
-	using Register = VeDirectHexRegister;
-
-	sendHexCommand(Command::GET, Register::ChargeControllerTemperature);
-	sendHexCommand(Command::GET, Register::SmartBatterySenseTemperature);
-	sendHexCommand(Command::GET, Register::NetworkTotalDcInputPower);
-
-#ifdef PROCESS_NETWORK_STATE
-	sendHexCommand(Command::GET, Register::NetworkInfo);
-	sendHexCommand(Command::GET, Register::NetworkMode);
-	sendHexCommand(Command::GET, Register::NetworkStatus);
-#endif // PROCESS_NETWORK_STATE
 }
 
 
 void VeDirectMpptController::loop()
 {
+	// First we send HEX-Commands (timing improvement)
+	if (isHexCommandPossible()) {
+		sendNextHexCommandFromQueue();
+	}
+
+	// Second we read Text- and HEX-Messages
 	VeDirectFrameHandler::loop();
 
+	// Note: Room for improvement, longer data valid time for slow changing values?
 	auto resetTimestamp = [this](auto& pair) {
 		if (pair.first > 0 && (millis() - pair.first) > (10 * 1000)) {
 			pair.first = 0;
 		}
 	};
 
+    // Check if optional TEXT-Data is outdated
+    resetTimestamp(_tmpFrame.loadOutputState_LOAD);
+	resetTimestamp(_tmpFrame.loadCurrent_IL_mA);
+    resetTimestamp(_tmpFrame.relayState_RELAY);
+
+	// Third we check if HEX-Data is outdated
+    if (!isHexCommandPossible()) { return; }
 	resetTimestamp(_tmpFrame.MpptTemperatureMilliCelsius);
 	resetTimestamp(_tmpFrame.SmartBatterySenseTemperatureMilliCelsius);
 	resetTimestamp(_tmpFrame.NetworkTotalDcInputPowerMilliWatts);
+	resetTimestamp(_tmpFrame.BatteryFloatMilliVolt);
+	resetTimestamp(_tmpFrame.BatteryAbsorptionMilliVolt);
 
 #ifdef PROCESS_NETWORK_STATE
 	resetTimestamp(_tmpFrame.NetworkInfo);
@@ -153,8 +155,8 @@ void VeDirectMpptController::loop()
 
 /*
  * hexDataHandler()
- * analyse the content of VE.Direct hex messages
- * Handels the received hex data from the MPPT
+ * analyze the content of VE.Direct hex messages
+ * handles the received hex data from the MPPT
  */
 bool VeDirectMpptController::hexDataHandler(VeDirectHexData const &data) {
 	if (data.rsp != VeDirectHexResponse::GET &&
@@ -162,6 +164,11 @@ bool VeDirectMpptController::hexDataHandler(VeDirectHexData const &data) {
 
 	auto regLog = static_cast<uint16_t>(data.addr);
 
+	// we check whether the answer matches a previously asked query
+	if ((data.rsp == VeDirectHexResponse::GET) && (data.addr == _hexQueue[_sendQueueNr]._hexRegister)) {
+		_sendTimeout = 0;
+	}
+
 	switch (data.addr) {
 		case VeDirectHexRegister::ChargeControllerTemperature:
 			_tmpFrame.MpptTemperatureMilliCelsius =
@@ -215,6 +222,29 @@ bool VeDirectMpptController::hexDataHandler(VeDirectHexData const &data) {
 			return true;
 			break;
 
+		case VeDirectHexRegister::BatteryAbsorptionVoltage:
+			_tmpFrame.BatteryAbsorptionMilliVolt =
+				{ millis(), static_cast<uint32_t>(data.value) * 10 };
+			if (_verboseLogging) {
+				_msgOut->printf("%s Hex Data: MPPT Absorption Voltage (0x%04X): %.2fV\r\n",
+						_logId, regLog,
+						_tmpFrame.BatteryAbsorptionMilliVolt.second / 1000.0);
+			}
+			return true;
+			break;
+
+		case VeDirectHexRegister::BatteryFloatVoltage:
+			_tmpFrame.BatteryFloatMilliVolt =
+				{ millis(), static_cast<uint32_t>(data.value) * 10 };
+
+			if (_verboseLogging) {
+				_msgOut->printf("%s Hex Data: MPPT Float Voltage (0x%04X): %.2fV\r\n",
+						_logId, regLog,
+						_tmpFrame.BatteryFloatMilliVolt.second / 1000.0);
+			}
+			return true;
+			break;
+
 #ifdef PROCESS_NETWORK_STATE
 		case VeDirectHexRegister::NetworkInfo:
 			_tmpFrame.NetworkInfo =
@@ -257,3 +287,66 @@ bool VeDirectMpptController::hexDataHandler(VeDirectHexData const &data) {
 
 	return false;
 }
+
+
+/*
+ * isHexCommandPossible()
+ * return: true = yes we can use Hex-Commands
+ */
+bool VeDirectMpptController::isHexCommandPossible(void) {
+	// Copy from the "VE.Direct Protocol" documentation
+	// For firmware version v1.52 and below, when no VE.Direct queries are sent to the device, the
+	// charger periodically sends human readable (TEXT) data to the serial port. For firmware
+	// versions v1.53 and above, the charger always periodically sends TEXT data to the serial port.
+	// --> We just use hex commands for firmware >= 1.53 to keep text messages alive
+	return (_canSend && (_tmpFrame.getFwVersionAsInteger() >= 153));
+}
+
+
+/*
+ * sendNextHexCommandFromQueue()
+ * send one Hex Commands from the Hex Command Queue
+ * handles the received hex data from the MPPT
+ */
+void VeDirectMpptController::sendNextHexCommandFromQueue(void) {
+	// It seems some commands get lost if we send to fast the next command.
+	// maybe we produce an overflow on the MPPT receive buffer or we have to
+	// wait for the MPPT answer before we can send the next command. We only
+	// send a new query in VE.Direct idle state and if no query is pending. In
+	// case we do not get an answer we send the next query from the queue after
+	// a timeout of 500ms. NOTE: _sendTimeout will be set to 0 after receiving
+	// an answer, see function hexDataHandler().
+	auto millisTime = millis();
+	if (isStateIdle() && ((millisTime - _hexQueue[_sendQueueNr]._lastSendTime) > _sendTimeout)) {
+
+		// we do 2 loops, first for high prio commands and second for low prio commands
+		bool prio = true;
+		for (auto idy = 0; idy < 2; ++idy) {
+
+			// we start searching the queue with the next queue index
+			auto idx = _sendQueueNr + 1;
+			if (idx >= _hexQueue.size()) { idx = 0; }
+
+			do {
+				// we check if it is time to send the command again
+				if (((prio && (_hexQueue[idx]._readPeriod == HIGH_PRIO_COMMAND)) ||
+					(!prio && (_hexQueue[idx]._readPeriod != HIGH_PRIO_COMMAND))) &&
+					(millisTime - _hexQueue[idx]._lastSendTime) > (_hexQueue[idx]._readPeriod * 1000)) {
+
+					sendHexCommand(VeDirectHexCommand::GET, _hexQueue[idx]._hexRegister);
+					_hexQueue[idx]._lastSendTime = millisTime;
+
+					// we need this information to check if we get an answer, see hexDataHandler()
+					_sendTimeout = 500;
+					_sendQueueNr = idx;
+					return;
+				}
+
+				++idx;
+				if (idx == _hexQueue.size()) { idx = 0; }
+			} while (idx != _sendQueueNr);
+
+			prio = false; // second loop for low prio commands
+		}
+	}
+}
diff --git a/lib/VeDirectFrameHandler/VeDirectMpptController.h b/lib/VeDirectFrameHandler/VeDirectMpptController.h
index b8bd4c72..ac3b9122 100644
--- a/lib/VeDirectFrameHandler/VeDirectMpptController.h
+++ b/lib/VeDirectFrameHandler/VeDirectMpptController.h
@@ -36,6 +36,12 @@ private:
     size_t _count;
 };
 
+struct VeDirectHexQueue {
+    VeDirectHexRegister _hexRegister;   // hex register
+    uint8_t _readPeriod;                // time period in sec until we send the command again
+    uint32_t _lastSendTime;             // time stamp in milli sec of last send
+};
+
 class VeDirectMpptController : public VeDirectFrameHandler<veMpptStruct> {
 public:
     VeDirectMpptController() = default;
@@ -51,5 +57,18 @@ private:
     bool hexDataHandler(VeDirectHexData const &data) final;
     bool processTextDataDerived(std::string const& name, std::string const& value) final;
     void frameValidEvent() final;
+    void sendNextHexCommandFromQueue(void);
+    bool isHexCommandPossible(void);
     MovingAverage<float, 5> _efficiency;
+
+    uint32_t _sendTimeout = 0;          // timeout until we send the next command from the queue
+    size_t _sendQueueNr = 0;            // actual queue position;
+
+    // for slow changing values we use a send time period of 4 sec
+    #define HIGH_PRIO_COMMAND 1
+    std::array<VeDirectHexQueue, 5> _hexQueue { VeDirectHexRegister::NetworkTotalDcInputPower, HIGH_PRIO_COMMAND, 0,
+                                                VeDirectHexRegister::ChargeControllerTemperature, 4, 0,
+                                                VeDirectHexRegister::SmartBatterySenseTemperature, 4, 0,
+                                                VeDirectHexRegister::BatteryFloatVoltage, 4, 0,
+                                                VeDirectHexRegister::BatteryAbsorptionVoltage, 4, 0 };
 };
diff --git a/pio-scripts/create_factory_bin.py b/pio-scripts/create_factory_bin.py
index c0ef4a8c..ec8274e2 100644
--- a/pio-scripts/create_factory_bin.py
+++ b/pio-scripts/create_factory_bin.py
@@ -130,4 +130,4 @@ def esp32_create_combined_bin(source, target, env):
     esptool.main(cmd)
 
 
-env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_create_combined_bin)
+env.AddPostAction("buildprog", esp32_create_combined_bin)
diff --git a/platformio.ini b/platformio.ini
index b619e3e2..42d6abf4 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -41,10 +41,10 @@ build_unflags =
     -std=gnu++11
 
 lib_deps =
-    mathieucarbou/ESPAsyncWebServer @ 3.3.16
+    mathieucarbou/ESPAsyncWebServer @ 3.3.22
     bblanchon/ArduinoJson @ 7.2.0
     https://github.com/bertmelis/espMqttClient.git#v1.7.0
-    nrf24/RF24 @ 1.4.9
+    nrf24/RF24 @ 1.4.10
     olikraus/U8g2 @ 2.36.2
     buelowp/sunset @ 1.1.7
     arkhipenko/TaskScheduler @ 3.8.5
diff --git a/src/Battery.cpp b/src/Battery.cpp
index 7483c1de..5e6ade82 100644
--- a/src/Battery.cpp
+++ b/src/Battery.cpp
@@ -4,6 +4,7 @@
 #include "PylontechCanReceiver.h"
 #include "SBSCanReceiver.h"
 #include "JkBmsController.h"
+#include "JbdBmsController.h"
 #include "VictronSmartShunt.h"
 #include "MqttBattery.h"
 #include "PytesCanReceiver.h"
@@ -41,7 +42,7 @@ void BatteryClass::updateSettings()
         _upProvider = nullptr;
     }
 
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     if (!config.Battery.Enabled) { return; }
 
     bool verboseLogging = config.Battery.VerboseLogging;
@@ -65,6 +66,9 @@ void BatteryClass::updateSettings()
         case 5:
             _upProvider = std::make_unique<SBSCanReceiver>();
             break;
+        case 6:
+            _upProvider = std::make_unique<JbdBms::Controller>();
+            break;
         default:
             MessageOutput.printf("[Battery] Unknown provider: %d\r\n", config.Battery.Provider);
             return;
@@ -86,19 +90,31 @@ void BatteryClass::loop()
 
 float BatteryClass::getDischargeCurrentLimit()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     if (!config.Battery.EnableDischargeCurrentLimit) { return FLT_MAX; }
 
     auto dischargeCurrentLimit = config.Battery.DischargeCurrentLimit;
-    auto dischargeCurrentValid = dischargeCurrentLimit > 0.0f;
-
+    auto dischargeCurrentLimitValid = dischargeCurrentLimit > 0.0f;
+    auto dischargeCurrentLimitBelowSoc = config.Battery.DischargeCurrentLimitBelowSoc;
+    auto dischargeCurrentLimitBelowVoltage = config.Battery.DischargeCurrentLimitBelowVoltage;
+    auto statsSoCValid = getStats()->getSoCAgeSeconds() <= 60 && !config.PowerLimiter.IgnoreSoc;
+    auto statsSoC = statsSoCValid ? getStats()->getSoC() : 100.0; // fail open so we use voltage instead
+    auto statsVoltageValid = getStats()->getVoltageAgeSeconds() <= 60;
+    auto statsVoltage = statsVoltageValid ? getStats()->getVoltage() : 0.0; // fail closed
     auto statsCurrentLimit = getStats()->getDischargeCurrentLimit();
     auto statsLimitValid = config.Battery.UseBatteryReportedDischargeCurrentLimit
         && statsCurrentLimit >= 0.0f
         && getStats()->getDischargeCurrentLimitAgeSeconds() <= 60;
 
-    if (statsLimitValid && dischargeCurrentValid) {
+
+    if (statsSoC > dischargeCurrentLimitBelowSoc && statsVoltage > dischargeCurrentLimitBelowVoltage) {
+        // Above SoC and Voltage thresholds, ignore custom limit.
+        // Battery-provided limit will still be applied.
+        dischargeCurrentLimitValid = false;
+    }
+
+    if (statsLimitValid && dischargeCurrentLimitValid) {
         // take the lowest limit
         return min(statsCurrentLimit, dischargeCurrentLimit);
     }
@@ -107,7 +123,7 @@ float BatteryClass::getDischargeCurrentLimit()
         return statsCurrentLimit;
     }
 
-    if (dischargeCurrentValid) {
+    if (dischargeCurrentLimitValid) {
         return dischargeCurrentLimit;
     }
 
diff --git a/src/BatteryStats.cpp b/src/BatteryStats.cpp
index 796158d2..f4e383b2 100644
--- a/src/BatteryStats.cpp
+++ b/src/BatteryStats.cpp
@@ -5,6 +5,7 @@
 #include "Configuration.h"
 #include "MqttSettings.h"
 #include "JkBmsDataPoints.h"
+#include "JbdBmsDataPoints.h"
 #include "MqttSettings.h"
 
 template<typename T>
@@ -163,7 +164,6 @@ void SBSBatteryStats::getLiveViewData(JsonVariant& root) const
     // values go into the "Status" card of the web application
     addLiveViewValue(root, "chargeVoltage", _chargeVoltage, "V", 1);
     addLiveViewValue(root, "chargeCurrentLimitation", _chargeCurrentLimitation, "A", 1);
-    addLiveViewValue(root, "dischargeCurrentLimitation", _dischargeCurrentLimitation, "A", 1);
     addLiveViewValue(root, "stateOfHealth", _stateOfHealth, "%", 0);
     addLiveViewValue(root, "current", _current, "A", 1);
     addLiveViewValue(root, "temperature", _temperature, "°C", 1);
@@ -337,6 +337,79 @@ void JkBmsBatteryStats::getJsonData(JsonVariant& root, bool verbose) const
     }
 }
 
+void JbdBmsBatteryStats::getJsonData(JsonVariant& root, bool verbose) const
+{
+    BatteryStats::getLiveViewData(root);
+
+    using Label = JbdBms::DataPointLabel;
+
+    auto oCurrent = _dataPoints.get<Label::BatteryCurrentMilliAmps>();
+    auto oVoltage = _dataPoints.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value() && oCurrent.has_value()) {
+        auto current = static_cast<float>(*oCurrent) / 1000;
+        auto voltage = static_cast<float>(*oVoltage) / 1000;
+        addLiveViewValue(root, "power", current * voltage , "W", 2);
+    }
+
+    auto oBatteryChargeEnabled = _dataPoints.get<Label::BatteryChargeEnabled>();
+    if (oBatteryChargeEnabled.has_value()) {
+        addLiveViewTextValue(root, "chargeEnabled", (*oBatteryChargeEnabled?"yes":"no"));
+    }
+
+    auto oBatteryDischargeEnabled = _dataPoints.get<Label::BatteryDischargeEnabled>();
+    if (oBatteryDischargeEnabled.has_value()) {
+        addLiveViewTextValue(root, "dischargeEnabled", (*oBatteryDischargeEnabled?"yes":"no"));
+    }
+
+    auto oTemperatureOne = _dataPoints.get<Label::BatteryTempOneCelsius>();
+    if (oTemperatureOne.has_value()) {
+        addLiveViewInSection(root, "cells", "batOneTemp", *oTemperatureOne, "°C", 0);
+    }
+
+    auto oTemperatureTwo = _dataPoints.get<Label::BatteryTempTwoCelsius>();
+    if (oTemperatureTwo.has_value()) {
+        addLiveViewInSection(root, "cells", "batTwoTemp", *oTemperatureTwo, "°C", 0);
+    }
+
+    if (_cellVoltageTimestamp > 0) {
+        addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellAvgVoltage", static_cast<float>(_cellAvgMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
+    }
+
+    auto oBalancingEnabled = _dataPoints.get<Label::BalancingEnabled>();
+    if (oBalancingEnabled.has_value()) {
+        addLiveViewTextInSection(root, "cells", "balancingActive", (*oBalancingEnabled?"yes":"no"));
+    }
+
+    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
+    if (oAlarms.has_value()) {
+#define ISSUE(t, x) \
+        auto x = *oAlarms & static_cast<uint16_t>(JbdBms::AlarmBits::x); \
+        addLiveView##t(root, "JbdBmsIssue"#x, x > 0);
+
+        //ISSUE(Warning, LowCapacity);
+        ISSUE(Alarm, CellOverVoltage);
+        ISSUE(Alarm, CellUnderVoltage);
+        ISSUE(Alarm, PackOverVoltage);
+        ISSUE(Alarm, PackUnderVoltage);
+        ISSUE(Alarm, ChargingOverTemperature);
+        ISSUE(Alarm, ChargingLowTemperature);
+        ISSUE(Alarm, DischargingOverTemperature);
+        ISSUE(Alarm, DischargingLowTemperature);
+        ISSUE(Alarm, ChargingOverCurrent);
+        ISSUE(Alarm, DischargeOverCurrent);
+        ISSUE(Alarm, ShortCircuit);
+        ISSUE(Alarm, IcFrontEndError);
+        ISSUE(Alarm, MosSotwareLock);
+        ISSUE(Alarm, Reserved1);
+        ISSUE(Alarm, Reserved2);
+        ISSUE(Alarm, Reserved3);
+#undef ISSUE
+    }
+}
+
 void BatteryStats::mqttLoop()
 {
     auto& config = Configuration.get();
@@ -419,7 +492,6 @@ void SBSBatteryStats::mqttPublish() const
 
     MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltage));
     MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimitation));
-    MqttSettings.publish("battery/settings/dischargeCurrentLimitation", String(_dischargeCurrentLimitation));
     MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
     MqttSettings.publish("battery/current", String(_current));
     MqttSettings.publish("battery/temperature", String(_temperature));
@@ -573,6 +645,66 @@ void JkBmsBatteryStats::mqttPublish() const
     if (fullPublish) { _lastFullMqttPublish = _lastMqttPublish; }
 }
 
+void JbdBmsBatteryStats::mqttPublish() const
+{
+    BatteryStats::mqttPublish();
+
+    using Label = JbdBms::DataPointLabel;
+
+    static std::vector<Label> mqttSkip = {
+        Label::CellsMilliVolt, // complex data format
+        Label::BatteryVoltageMilliVolt, // already published by base class
+        Label::BatterySoCPercent // already published by base class
+    };
+
+    // regularly publish all topics regardless of whether or not their value changed
+    bool neverFullyPublished = _lastFullMqttPublish == 0;
+    bool intervalElapsed = _lastFullMqttPublish + getMqttFullPublishIntervalMs() < millis();
+    bool fullPublish = neverFullyPublished || intervalElapsed;
+
+    for (auto iter = _dataPoints.cbegin(); iter != _dataPoints.cend(); ++iter) {
+        // skip data points that did not change since last published
+        if (!fullPublish && iter->second.getTimestamp() < _lastMqttPublish) { continue; }
+
+        auto skipMatch = std::find(mqttSkip.begin(), mqttSkip.end(), iter->first);
+        if (skipMatch != mqttSkip.end()) { continue; }
+
+        String topic((std::string("battery/") + iter->second.getLabelText()).c_str());
+        MqttSettings.publish(topic, iter->second.getValueText().c_str());
+    }
+
+    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
+    if (oCellVoltages.has_value() && (fullPublish || _cellVoltageTimestamp > _lastMqttPublish)) {
+        unsigned idx = 1;
+        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
+            String topic("battery/Cell");
+            topic += String(idx);
+            topic += "MilliVolt";
+
+            MqttSettings.publish(topic, String(iter->second));
+
+            ++idx;
+        }
+
+        MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
+        MqttSettings.publish("battery/CellAvgMilliVolt", String(_cellAvgMilliVolt));
+        MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
+        MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
+    }
+
+    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
+    if (oAlarms.has_value()) {
+        for (auto iter = JbdBms::AlarmBitTexts.begin(); iter != JbdBms::AlarmBitTexts.end(); ++iter) {
+            auto bit = iter->first;
+            String value = (*oAlarms & static_cast<uint16_t>(bit))?"1":"0";
+            MqttSettings.publish(String("battery/alarms/") + iter->second.data(), value);
+        }
+    }
+
+    _lastMqttPublish = millis();
+    if (fullPublish) { _lastFullMqttPublish = _lastMqttPublish; }
+}
+
 void JkBmsBatteryStats::updateFrom(JkBms::DataPointContainer const& dp)
 {
     using Label = JkBms::DataPointLabel;
@@ -650,6 +782,62 @@ void JkBmsBatteryStats::updateFrom(JkBms::DataPointContainer const& dp)
     _lastUpdate = millis();
 }
 
+void JbdBmsBatteryStats::updateFrom(JbdBms::DataPointContainer const& dp)
+{
+    using Label = JbdBms::DataPointLabel;
+
+    setManufacturer("JBDBMS");
+
+    auto oSoCValue = dp.get<Label::BatterySoCPercent>();
+    if (oSoCValue.has_value()) {
+        auto oSoCDataPoint = dp.getDataPointFor<Label::BatterySoCPercent>();
+        BatteryStats::setSoC(*oSoCValue, 0/*precision*/,
+                oSoCDataPoint->getTimestamp());
+    }
+
+    auto oVoltage = dp.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value()) {
+        auto oVoltageDataPoint = dp.getDataPointFor<Label::BatteryVoltageMilliVolt>();
+        BatteryStats::setVoltage(static_cast<float>(*oVoltage) / 1000,
+                oVoltageDataPoint->getTimestamp());
+    }
+
+    auto oCurrent = dp.get<Label::BatteryCurrentMilliAmps>();
+    if (oCurrent.has_value()) {
+        auto oCurrentDataPoint = dp.getDataPointFor<Label::BatteryCurrentMilliAmps>();
+        BatteryStats::setCurrent(static_cast<float>(*oCurrent) / 1000, 2/*precision*/,
+                oCurrentDataPoint->getTimestamp());
+    }
+
+    _dataPoints.updateFrom(dp);
+
+    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
+    if (oCellVoltages.has_value()) {
+        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
+            if (iter == oCellVoltages->cbegin()) {
+                _cellMinMilliVolt = _cellAvgMilliVolt = _cellMaxMilliVolt = iter->second;
+                continue;
+            }
+            _cellMinMilliVolt = std::min(_cellMinMilliVolt, iter->second);
+            _cellAvgMilliVolt = (_cellAvgMilliVolt + iter->second) / 2;
+            _cellMaxMilliVolt = std::max(_cellMaxMilliVolt, iter->second);
+        }
+        _cellVoltageTimestamp = millis();
+    }
+
+    auto oSoftwareVersion = _dataPoints.get<Label::BmsSoftwareVersion>();
+    if (oSoftwareVersion.has_value()) {
+        _fwversion = oSoftwareVersion->c_str();
+    }
+
+    auto oHardwareVersion = _dataPoints.get<Label::BmsHardwareVersion>();
+    if (oHardwareVersion.has_value()) {
+        _hwversion = oHardwareVersion->c_str();
+    }
+
+    _lastUpdate = millis();
+}
+
 void VictronSmartShuntStats::updateFrom(VeDirectShuntController::data_t const& shuntData) {
     BatteryStats::setVoltage(shuntData.batteryVoltage_V_mV / 1000.0, millis());
     BatteryStats::setSoC(static_cast<float>(shuntData.SOC) / 10, 1/*precision*/, millis());
diff --git a/src/Configuration.cpp b/src/Configuration.cpp
index 61ee7758..4b05e047 100644
--- a/src/Configuration.cpp
+++ b/src/Configuration.cpp
@@ -12,8 +12,17 @@
 
 CONFIG_T config;
 
-void ConfigurationClass::init()
+static std::condition_variable sWriterCv;
+static std::mutex sWriterMutex;
+static unsigned sWriterCount = 0;
+
+void ConfigurationClass::init(Scheduler& scheduler)
 {
+    scheduler.addTask(_loopTask);
+    _loopTask.setCallback(std::bind(&ConfigurationClass::loop, this));
+    _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.enable();
+
     memset(&config, 0x0, sizeof(config));
 }
 
@@ -88,12 +97,74 @@ void ConfigurationClass::serializeBatteryConfig(BatteryConfig const& source, Jso
     target["mqtt_voltage_unit"] = config.Battery.MqttVoltageUnit;
     target["enable_discharge_current_limit"] = config.Battery.EnableDischargeCurrentLimit;
     target["discharge_current_limit"] = config.Battery.DischargeCurrentLimit;
+    target["discharge_current_limit_below_soc"] = config.Battery.DischargeCurrentLimitBelowSoc;
+    target["discharge_current_limit_below_voltage"] = config.Battery.DischargeCurrentLimitBelowVoltage;
     target["use_battery_reported_discharge_current_limit"] = config.Battery.UseBatteryReportedDischargeCurrentLimit;
     target["mqtt_discharge_current_topic"] = config.Battery.MqttDischargeCurrentTopic;
     target["mqtt_discharge_current_json_path"] = config.Battery.MqttDischargeCurrentJsonPath;
     target["mqtt_amperage_unit"] = config.Battery.MqttAmperageUnit;
 }
 
+void ConfigurationClass::serializePowerLimiterConfig(PowerLimiterConfig const& source, JsonObject& target)
+{
+    char serialBuffer[sizeof(uint64_t) * 8 + 1];
+    auto serialStr = [&serialBuffer](uint64_t const& serial) -> String {
+        snprintf(serialBuffer, sizeof(serialBuffer), "%0x%08x",
+            static_cast<uint32_t>((serial >> 32) & 0xFFFFFFFF),
+            static_cast<uint32_t>(serial & 0xFFFFFFFF));
+        return String(serialBuffer);
+    };
+
+    // we want a representation of our floating-point value in the JSON that
+    // uses the least amount of decimal digits possible to convey the value that
+    // is actually represented by the float. this is no easy task. ArduinoJson
+    // does this for us, however, it does it as expected only for variables of
+    // type double. this is probably because it assumes all floating-point
+    // values to have the precision of a double (64 bits), so it prints the
+    // respective number of siginificant decimals, which are too many if the
+    // actual value is a float (32 bits).
+    auto roundedFloat = [](float val) -> double {
+        return static_cast<int>(val * 100 + (val > 0 ? 0.5 : -0.5)) / 100.0;
+    };
+
+    target["enabled"] = source.Enabled;
+    target["verbose_logging"] = source.VerboseLogging;
+    target["solar_passthrough_enabled"] = source.SolarPassThroughEnabled;
+    target["solar_passthrough_losses"] = source.SolarPassThroughLosses;
+    target["battery_always_use_at_night"] = source.BatteryAlwaysUseAtNight;
+    target["target_power_consumption"] = source.TargetPowerConsumption;
+    target["target_power_consumption_hysteresis"] = source.TargetPowerConsumptionHysteresis;
+    target["base_load_limit"] = source.BaseLoadLimit;
+    target["ignore_soc"] = source.IgnoreSoc;
+    target["battery_soc_start_threshold"] = source.BatterySocStartThreshold;
+    target["battery_soc_stop_threshold"] = source.BatterySocStopThreshold;
+    target["voltage_start_threshold"] = roundedFloat(source.VoltageStartThreshold);
+    target["voltage_stop_threshold"] = roundedFloat(source.VoltageStopThreshold);
+    target["voltage_load_correction_factor"] = source.VoltageLoadCorrectionFactor;
+    target["full_solar_passthrough_soc"] = source.FullSolarPassThroughSoc;
+    target["full_solar_passthrough_start_voltage"] = roundedFloat(source.FullSolarPassThroughStartVoltage);
+    target["full_solar_passthrough_stop_voltage"] = roundedFloat(source.FullSolarPassThroughStopVoltage);
+    target["inverter_serial_for_dc_voltage"] = serialStr(source.InverterSerialForDcVoltage);
+    target["inverter_channel_id_for_dc_voltage"] = source.InverterChannelIdForDcVoltage;
+    target["inverter_restart_hour"] = source.RestartHour;
+    target["total_upper_power_limit"] = source.TotalUpperPowerLimit;
+
+    JsonArray inverters = target["inverters"].to<JsonArray>();
+    for (size_t i = 0; i < INV_MAX_COUNT; ++i) {
+        PowerLimiterInverterConfig const& s = source.Inverters[i];
+        if (s.Serial == 0ULL) { break; }
+        JsonObject t = inverters.add<JsonObject>();
+
+        t["serial"] = serialStr(s.Serial);
+        t["is_governed"] = s.IsGoverned;
+        t["is_behind_power_meter"] = s.IsBehindPowerMeter;
+        t["is_solar_powered"] = s.IsSolarPowered;
+        t["use_overscaling_to_compensate_shading"] = s.UseOverscalingToCompensateShading;
+        t["lower_power_limit"] = s.LowerPowerLimit;
+        t["upper_power_limit"] = s.UpperPowerLimit;
+    }
+}
+
 bool ConfigurationClass::write()
 {
     File f = LittleFS.open(CONFIG_FILENAME, "w");
@@ -190,7 +261,7 @@ bool ConfigurationClass::write()
     display["screensaver"] = config.Display.ScreenSaver;
     display["rotation"] = config.Display.Rotation;
     display["contrast"] = config.Display.Contrast;
-    display["language"] = config.Display.Language;
+    display["locale"] = config.Display.Locale;
     display["diagram_duration"] = config.Display.Diagram.Duration;
     display["diagram_mode"] = config.Display.Diagram.Mode;
 
@@ -248,32 +319,7 @@ bool ConfigurationClass::write()
     serializePowerMeterHttpSmlConfig(config.PowerMeter.HttpSml, powermeter_http_sml);
 
     JsonObject powerlimiter = doc["powerlimiter"].to<JsonObject>();
-    powerlimiter["enabled"] = config.PowerLimiter.Enabled;
-    powerlimiter["verbose_logging"] = config.PowerLimiter.VerboseLogging;
-    powerlimiter["solar_passtrough_enabled"] = config.PowerLimiter.SolarPassThroughEnabled;
-    powerlimiter["solar_passthrough_losses"] = config.PowerLimiter.SolarPassThroughLosses;
-    powerlimiter["battery_always_use_at_night"] = config.PowerLimiter.BatteryAlwaysUseAtNight;
-    powerlimiter["interval"] = config.PowerLimiter.Interval;
-    powerlimiter["is_inverter_behind_powermeter"] = config.PowerLimiter.IsInverterBehindPowerMeter;
-    powerlimiter["is_inverter_solar_powered"] = config.PowerLimiter.IsInverterSolarPowered;
-    powerlimiter["use_overscaling_to_compensate_shading"] = config.PowerLimiter.UseOverscalingToCompensateShading;
-    powerlimiter["inverter_id"] = config.PowerLimiter.InverterId;
-    powerlimiter["inverter_channel_id"] = config.PowerLimiter.InverterChannelId;
-    powerlimiter["target_power_consumption"] = config.PowerLimiter.TargetPowerConsumption;
-    powerlimiter["target_power_consumption_hysteresis"] = config.PowerLimiter.TargetPowerConsumptionHysteresis;
-    powerlimiter["lower_power_limit"] = config.PowerLimiter.LowerPowerLimit;
-    powerlimiter["base_load_limit"] = config.PowerLimiter.BaseLoadLimit;
-    powerlimiter["upper_power_limit"] = config.PowerLimiter.UpperPowerLimit;
-    powerlimiter["ignore_soc"] = config.PowerLimiter.IgnoreSoc;
-    powerlimiter["battery_soc_start_threshold"] = config.PowerLimiter.BatterySocStartThreshold;
-    powerlimiter["battery_soc_stop_threshold"] = config.PowerLimiter.BatterySocStopThreshold;
-    powerlimiter["voltage_start_threshold"] = config.PowerLimiter.VoltageStartThreshold;
-    powerlimiter["voltage_stop_threshold"] = config.PowerLimiter.VoltageStopThreshold;
-    powerlimiter["voltage_load_correction_factor"] = config.PowerLimiter.VoltageLoadCorrectionFactor;
-    powerlimiter["inverter_restart_hour"] = config.PowerLimiter.RestartHour;
-    powerlimiter["full_solar_passthrough_soc"] = config.PowerLimiter.FullSolarPassThroughSoc;
-    powerlimiter["full_solar_passthrough_start_voltage"] = config.PowerLimiter.FullSolarPassThroughStartVoltage;
-    powerlimiter["full_solar_passthrough_stop_voltage"] = config.PowerLimiter.FullSolarPassThroughStopVoltage;
+    serializePowerLimiterConfig(config.PowerLimiter, powerlimiter);
 
     JsonObject battery = doc["battery"].to<JsonObject>();
     serializeBatteryConfig(config.Battery, battery);
@@ -311,7 +357,7 @@ void ConfigurationClass::deserializeHttpRequestConfig(JsonObject const& source,
     JsonObject source_http_config = source["http_request"];
 
     // http request parameters of HTTP/JSON power meter were previously stored
-    // alongside other settings. TODO(schlimmchen): remove in early 2025.
+    // alongside other settings. TODO(schlimmchen): remove in mid 2025.
     if (source_http_config.isNull()) { source_http_config = source; }
 
     strlcpy(target.Url, source_http_config["url"] | "", sizeof(target.Url));
@@ -383,15 +429,68 @@ void ConfigurationClass::deserializeBatteryConfig(JsonObject const& source, Batt
     target.MqttVoltageUnit = source["mqtt_voltage_unit"] | BatteryVoltageUnit::Volts;
     target.EnableDischargeCurrentLimit = source["enable_discharge_current_limit"] | BATTERY_ENABLE_DISCHARGE_CURRENT_LIMIT;
     target.DischargeCurrentLimit = source["discharge_current_limit"] | BATTERY_DISCHARGE_CURRENT_LIMIT;
+    target.DischargeCurrentLimitBelowSoc = source["discharge_current_limit_below_soc"] | BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_SOC;
+    target.DischargeCurrentLimitBelowVoltage = source["discharge_current_limit_below_voltage"] | BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_VOLTAGE;
     target.UseBatteryReportedDischargeCurrentLimit = source["use_battery_reported_discharge_current_limit"] | BATTERY_USE_BATTERY_REPORTED_DISCHARGE_CURRENT_LIMIT;
     strlcpy(target.MqttDischargeCurrentTopic, source["mqtt_discharge_current_topic"] | "", sizeof(config.Battery.MqttDischargeCurrentTopic));
     strlcpy(target.MqttDischargeCurrentJsonPath, source["mqtt_discharge_current_json_path"] | "", sizeof(config.Battery.MqttDischargeCurrentJsonPath));
     target.MqttAmperageUnit = source["mqtt_amperage_unit"] | BatteryAmperageUnit::Amps;
 }
 
+void ConfigurationClass::deserializePowerLimiterConfig(JsonObject const& source, PowerLimiterConfig& target)
+{
+    auto serialBin = [](String const& input) -> uint64_t {
+        return strtoll(input.c_str(), NULL, 16);
+    };
+
+    target.Enabled = source["enabled"] | POWERLIMITER_ENABLED;
+    target.VerboseLogging = source["verbose_logging"] | VERBOSE_LOGGING;
+    target.SolarPassThroughEnabled = source["solar_passthrough_enabled"] | POWERLIMITER_SOLAR_PASSTHROUGH_ENABLED;
+    target.SolarPassThroughLosses = source["solar_passthrough_losses"] | POWERLIMITER_SOLAR_PASSTHROUGH_LOSSES;
+    target.BatteryAlwaysUseAtNight = source["battery_always_use_at_night"] | POWERLIMITER_BATTERY_ALWAYS_USE_AT_NIGHT;
+    target.TargetPowerConsumption = source["target_power_consumption"] | POWERLIMITER_TARGET_POWER_CONSUMPTION;
+    target.TargetPowerConsumptionHysteresis = source["target_power_consumption_hysteresis"] | POWERLIMITER_TARGET_POWER_CONSUMPTION_HYSTERESIS;
+    target.BaseLoadLimit = source["base_load_limit"] | POWERLIMITER_BASE_LOAD_LIMIT;
+    target.IgnoreSoc = source["ignore_soc"] | POWERLIMITER_IGNORE_SOC;
+    target.BatterySocStartThreshold = source["battery_soc_start_threshold"] | POWERLIMITER_BATTERY_SOC_START_THRESHOLD;
+    target.BatterySocStopThreshold = source["battery_soc_stop_threshold"] | POWERLIMITER_BATTERY_SOC_STOP_THRESHOLD;
+    target.VoltageStartThreshold = source["voltage_start_threshold"] | POWERLIMITER_VOLTAGE_START_THRESHOLD;
+    target.VoltageStopThreshold = source["voltage_stop_threshold"] | POWERLIMITER_VOLTAGE_STOP_THRESHOLD;
+    target.VoltageLoadCorrectionFactor = source["voltage_load_correction_factor"] | POWERLIMITER_VOLTAGE_LOAD_CORRECTION_FACTOR;
+    target.FullSolarPassThroughSoc = source["full_solar_passthrough_soc"] | POWERLIMITER_FULL_SOLAR_PASSTHROUGH_SOC;
+    target.FullSolarPassThroughStartVoltage = source["full_solar_passthrough_start_voltage"] | POWERLIMITER_FULL_SOLAR_PASSTHROUGH_START_VOLTAGE;
+    target.FullSolarPassThroughStopVoltage = source["full_solar_passthrough_stop_voltage"] | POWERLIMITER_FULL_SOLAR_PASSTHROUGH_STOP_VOLTAGE;
+    target.InverterSerialForDcVoltage = serialBin(source["inverter_serial_for_dc_voltage"] | String("0"));
+    target.InverterChannelIdForDcVoltage = source["inverter_channel_id_for_dc_voltage"] | POWERLIMITER_INVERTER_CHANNEL_ID;
+    target.RestartHour = source["inverter_restart_hour"] | POWERLIMITER_RESTART_HOUR;
+    target.TotalUpperPowerLimit = source["total_upper_power_limit"] | POWERLIMITER_UPPER_POWER_LIMIT;
+
+    JsonArray inverters = source["inverters"].as<JsonArray>();
+    for (size_t i = 0; i < INV_MAX_COUNT; ++i) {
+        PowerLimiterInverterConfig& inv = target.Inverters[i];
+        JsonObject s = inverters[i];
+
+        inv.Serial = serialBin(s["serial"] | String("0")); // 0 marks inverter slot as unused
+        inv.IsGoverned = s["is_governed"] | false;
+        inv.IsBehindPowerMeter = s["is_behind_power_meter"] | POWERLIMITER_IS_INVERTER_BEHIND_POWER_METER;
+        inv.IsSolarPowered = s["is_solar_powered"] | POWERLIMITER_IS_INVERTER_SOLAR_POWERED;
+        inv.UseOverscalingToCompensateShading = s["use_overscaling_to_compensate_shading"] | POWERLIMITER_USE_OVERSCALING_TO_COMPENSATE_SHADING;
+        inv.LowerPowerLimit = s["lower_power_limit"] | POWERLIMITER_LOWER_POWER_LIMIT;
+        inv.UpperPowerLimit = s["upper_power_limit"] | POWERLIMITER_UPPER_POWER_LIMIT;
+    }
+}
+
 bool ConfigurationClass::read()
 {
     File f = LittleFS.open(CONFIG_FILENAME, "r", false);
+    Utils::skipBom(f);
+
+    // skip Byte Order Mask (BOM). valid JSON docs always start with '{' or '['.
+    while (f.available() > 0) {
+        int c = f.peek();
+        if (c == '{' || c == '[') { break; }
+        f.read();
+    }
 
     JsonDocument doc;
 
@@ -522,7 +621,7 @@ bool ConfigurationClass::read()
     config.Display.ScreenSaver = display["screensaver"] | DISPLAY_SCREENSAVER;
     config.Display.Rotation = display["rotation"] | DISPLAY_ROTATION;
     config.Display.Contrast = display["contrast"] | DISPLAY_CONTRAST;
-    config.Display.Language = display["language"] | DISPLAY_LANGUAGE;
+    strlcpy(config.Display.Locale, display["locale"] | DISPLAY_LOCALE, sizeof(config.Display.Locale));
     config.Display.Diagram.Duration = display["diagram_duration"] | DISPLAY_DIAGRAM_DURATION;
     config.Display.Diagram.Mode = display["diagram_mode"] | DISPLAY_DIAGRAM_MODE;
 
@@ -570,7 +669,7 @@ bool ConfigurationClass::read()
     deserializePowerMeterMqttConfig(powermeter["mqtt"], config.PowerMeter.Mqtt);
 
     // process settings from legacy config if they are present
-    // TODO(schlimmchen): remove in early 2025.
+    // TODO(schlimmchen): remove in mid 2025.
     if (!powermeter["mqtt_topic_powermeter_1"].isNull()) {
         auto& values = config.PowerMeter.Mqtt.Values;
         strlcpy(values[0].Topic, powermeter["mqtt_topic_powermeter_1"], sizeof(values[0].Topic));
@@ -581,7 +680,7 @@ bool ConfigurationClass::read()
     deserializePowerMeterSerialSdmConfig(powermeter["serial_sdm"], config.PowerMeter.SerialSdm);
 
     // process settings from legacy config if they are present
-    // TODO(schlimmchen): remove in early 2025.
+    // TODO(schlimmchen): remove in mid 2025.
     if (!powermeter["sdmaddress"].isNull()) {
         config.PowerMeter.SerialSdm.Address = powermeter["sdmaddress"];
     }
@@ -593,7 +692,7 @@ bool ConfigurationClass::read()
     deserializePowerMeterHttpSmlConfig(powermeter_sml, config.PowerMeter.HttpSml);
 
     // process settings from legacy config if they are present
-    // TODO(schlimmchen): remove in early 2025.
+    // TODO(schlimmchen): remove in mid 2025.
     if (!powermeter["http_phases"].isNull()) {
         auto& target = config.PowerMeter.HttpJson;
 
@@ -613,33 +712,48 @@ bool ConfigurationClass::read()
     }
 
     JsonObject powerlimiter = doc["powerlimiter"];
-    config.PowerLimiter.Enabled = powerlimiter["enabled"] | POWERLIMITER_ENABLED;
-    config.PowerLimiter.VerboseLogging = powerlimiter["verbose_logging"] | VERBOSE_LOGGING;
-    config.PowerLimiter.SolarPassThroughEnabled = powerlimiter["solar_passtrough_enabled"] | POWERLIMITER_SOLAR_PASSTHROUGH_ENABLED;
-    config.PowerLimiter.SolarPassThroughLosses = powerlimiter["solar_passthrough_losses"] | powerlimiter["solar_passtrough_losses"] | POWERLIMITER_SOLAR_PASSTHROUGH_LOSSES; // solar_passthrough_losses was previously saved as solar_passtrough_losses. Be nice and also try mistyped key.
-    config.PowerLimiter.BatteryAlwaysUseAtNight = powerlimiter["battery_always_use_at_night"] | POWERLIMITER_BATTERY_ALWAYS_USE_AT_NIGHT;
-    if (powerlimiter["battery_drain_strategy"].as<uint8_t>() == 1) { config.PowerLimiter.BatteryAlwaysUseAtNight = true; } // convert legacy setting
-    config.PowerLimiter.Interval =  powerlimiter["interval"] | POWERLIMITER_INTERVAL;
-    config.PowerLimiter.IsInverterBehindPowerMeter = powerlimiter["is_inverter_behind_powermeter"] | POWERLIMITER_IS_INVERTER_BEHIND_POWER_METER;
-    config.PowerLimiter.IsInverterSolarPowered = powerlimiter["is_inverter_solar_powered"] | POWERLIMITER_IS_INVERTER_SOLAR_POWERED;
-    config.PowerLimiter.UseOverscalingToCompensateShading = powerlimiter["use_overscaling_to_compensate_shading"] | POWERLIMITER_USE_OVERSCALING_TO_COMPENSATE_SHADING;
-    config.PowerLimiter.InverterId = powerlimiter["inverter_id"] | POWERLIMITER_INVERTER_ID;
-    config.PowerLimiter.InverterChannelId = powerlimiter["inverter_channel_id"] | POWERLIMITER_INVERTER_CHANNEL_ID;
-    config.PowerLimiter.TargetPowerConsumption = powerlimiter["target_power_consumption"] | POWERLIMITER_TARGET_POWER_CONSUMPTION;
-    config.PowerLimiter.TargetPowerConsumptionHysteresis = powerlimiter["target_power_consumption_hysteresis"] | POWERLIMITER_TARGET_POWER_CONSUMPTION_HYSTERESIS;
-    config.PowerLimiter.LowerPowerLimit = powerlimiter["lower_power_limit"] | POWERLIMITER_LOWER_POWER_LIMIT;
-    config.PowerLimiter.BaseLoadLimit = powerlimiter["base_load_limit"] | POWERLIMITER_BASE_LOAD_LIMIT;
-    config.PowerLimiter.UpperPowerLimit = powerlimiter["upper_power_limit"] | POWERLIMITER_UPPER_POWER_LIMIT;
-    config.PowerLimiter.IgnoreSoc = powerlimiter["ignore_soc"] | POWERLIMITER_IGNORE_SOC;
-    config.PowerLimiter.BatterySocStartThreshold = powerlimiter["battery_soc_start_threshold"] | POWERLIMITER_BATTERY_SOC_START_THRESHOLD;
-    config.PowerLimiter.BatterySocStopThreshold = powerlimiter["battery_soc_stop_threshold"] | POWERLIMITER_BATTERY_SOC_STOP_THRESHOLD;
-    config.PowerLimiter.VoltageStartThreshold = powerlimiter["voltage_start_threshold"] | POWERLIMITER_VOLTAGE_START_THRESHOLD;
-    config.PowerLimiter.VoltageStopThreshold = powerlimiter["voltage_stop_threshold"] | POWERLIMITER_VOLTAGE_STOP_THRESHOLD;
-    config.PowerLimiter.VoltageLoadCorrectionFactor = powerlimiter["voltage_load_correction_factor"] | POWERLIMITER_VOLTAGE_LOAD_CORRECTION_FACTOR;
-    config.PowerLimiter.RestartHour = powerlimiter["inverter_restart_hour"] | POWERLIMITER_RESTART_HOUR;
-    config.PowerLimiter.FullSolarPassThroughSoc = powerlimiter["full_solar_passthrough_soc"] | POWERLIMITER_FULL_SOLAR_PASSTHROUGH_SOC;
-    config.PowerLimiter.FullSolarPassThroughStartVoltage = powerlimiter["full_solar_passthrough_start_voltage"] | POWERLIMITER_FULL_SOLAR_PASSTHROUGH_START_VOLTAGE;
-    config.PowerLimiter.FullSolarPassThroughStopVoltage = powerlimiter["full_solar_passthrough_stop_voltage"] | POWERLIMITER_FULL_SOLAR_PASSTHROUGH_STOP_VOLTAGE;
+    deserializePowerLimiterConfig(powerlimiter, config.PowerLimiter);
+
+    if (powerlimiter["battery_drain_strategy"].as<uint8_t>() == 1) {
+        config.PowerLimiter.BatteryAlwaysUseAtNight = true; // convert legacy setting
+    }
+
+    if (!powerlimiter["solar_passtrough_enabled"].isNull()) {
+        // solar_passthrough_enabled was previously saved as
+        // solar_passtrough_enabled. be nice and also try misspelled key.
+        config.PowerLimiter.SolarPassThroughEnabled = powerlimiter["solar_passtrough_enabled"].as<bool>();
+    }
+
+    if (!powerlimiter["solar_passtrough_losses"].isNull()) {
+        // solar_passthrough_losses was previously saved as
+        // solar_passtrough_losses. be nice and also try misspelled key.
+        config.PowerLimiter.SolarPassThroughLosses = powerlimiter["solar_passtrough_losses"].as<uint8_t>();
+    }
+
+    // process settings from legacy config if they are present
+    // TODO(schlimmchen): remove in mid 2025.
+    if (!powerlimiter["inverter_id"].isNull()) {
+        config.PowerLimiter.InverterChannelIdForDcVoltage = powerlimiter["inverter_channel_id"] | POWERLIMITER_INVERTER_CHANNEL_ID;
+
+        auto& inv = config.PowerLimiter.Inverters[0];
+        uint64_t previousInverterSerial = powerlimiter["inverter_id"].as<uint64_t>();
+        if (previousInverterSerial < INV_MAX_COUNT) {
+            // we previously had an index (not a serial) saved as inverter_id.
+            previousInverterSerial = config.Inverter[inv.Serial].Serial; // still 0 if no inverters configured
+        }
+        inv.Serial = previousInverterSerial;
+        config.PowerLimiter.InverterSerialForDcVoltage = previousInverterSerial;
+        inv.IsGoverned = true;
+        inv.IsBehindPowerMeter = powerlimiter["is_inverter_behind_powermeter"] | POWERLIMITER_IS_INVERTER_BEHIND_POWER_METER;
+        inv.IsSolarPowered = powerlimiter["is_inverter_solar_powered"] | POWERLIMITER_IS_INVERTER_SOLAR_POWERED;
+        inv.UseOverscalingToCompensateShading = powerlimiter["use_overscaling_to_compensate_shading"] | POWERLIMITER_USE_OVERSCALING_TO_COMPENSATE_SHADING;
+        inv.LowerPowerLimit = powerlimiter["lower_power_limit"] | POWERLIMITER_LOWER_POWER_LIMIT;
+        inv.UpperPowerLimit = powerlimiter["upper_power_limit"] | POWERLIMITER_UPPER_POWER_LIMIT;
+
+        config.PowerLimiter.TotalUpperPowerLimit = inv.UpperPowerLimit;
+
+        config.PowerLimiter.Inverters[1].Serial = 0;
+    }
 
     deserializeBatteryConfig(doc["battery"], config.Battery);
 
@@ -658,6 +772,20 @@ bool ConfigurationClass::read()
     config.Huawei.Auto_Power_Target_Power_Consumption = huawei["target_power_consumption"] | HUAWEI_AUTO_POWER_TARGET_POWER_CONSUMPTION;
 
     f.close();
+
+    // Check for default DTU serial
+    MessageOutput.print("Check for default DTU serial... ");
+    if (config.Dtu.Serial == DTU_SERIAL) {
+        MessageOutput.print("generate serial based on ESP chip id: ");
+        const uint64_t dtuId = Utils::generateDtuSerial();
+        MessageOutput.printf("%0" PRIx32 "%08" PRIx32 "... ",
+            static_cast<uint32_t>((dtuId >> 32) & 0xFFFFFFFF),
+            static_cast<uint32_t>(dtuId & 0xFFFFFFFF));
+        config.Dtu.Serial = dtuId;
+        write();
+    }
+    MessageOutput.println("done");
+
     return true;
 }
 
@@ -723,6 +851,22 @@ void ConfigurationClass::migrate()
         }
     }
 
+    if (config.Cfg.Version < 0x00011d00) {
+        JsonObject device = doc["device"];
+        JsonObject display = device["display"];
+        switch (display["language"] | 0U) {
+        case 0U:
+            strlcpy(config.Display.Locale, "en", sizeof(config.Display.Locale));
+            break;
+        case 1U:
+            strlcpy(config.Display.Locale, "de", sizeof(config.Display.Locale));
+            break;
+        case 2U:
+            strlcpy(config.Display.Locale, "fr", sizeof(config.Display.Locale));
+            break;
+        }
+    }
+
     f.close();
 
     config.Cfg.Version = CONFIG_VERSION;
@@ -730,11 +874,16 @@ void ConfigurationClass::migrate()
     read();
 }
 
-CONFIG_T& ConfigurationClass::get()
+CONFIG_T const& ConfigurationClass::get()
 {
     return config;
 }
 
+ConfigurationClass::WriteGuard ConfigurationClass::getWriteGuard()
+{
+    return WriteGuard();
+}
+
 INVERTER_CONFIG_T* ConfigurationClass::getFreeInverterSlot()
 {
     for (uint8_t i = 0; i < INV_MAX_COUNT; i++) {
@@ -779,4 +928,30 @@ void ConfigurationClass::deleteInverterById(const uint8_t id)
     }
 }
 
+void ConfigurationClass::loop()
+{
+    std::unique_lock<std::mutex> lock(sWriterMutex);
+    if (sWriterCount == 0) { return; }
+
+    sWriterCv.notify_all();
+    sWriterCv.wait(lock, [] { return sWriterCount == 0; });
+}
+
+CONFIG_T& ConfigurationClass::WriteGuard::getConfig()
+{
+    return config;
+}
+
+ConfigurationClass::WriteGuard::WriteGuard()
+    : _lock(sWriterMutex)
+{
+    sWriterCount++;
+    sWriterCv.wait(_lock);
+}
+
+ConfigurationClass::WriteGuard::~WriteGuard() {
+    sWriterCount--;
+    if (sWriterCount == 0) { sWriterCv.notify_all(); }
+}
+
 ConfigurationClass Configuration;
diff --git a/src/JkBmsDataPoints.cpp b/src/DataPoints.cpp
similarity index 67%
rename from src/JkBmsDataPoints.cpp
rename to src/DataPoints.cpp
index c9377ee0..48882115 100644
--- a/src/JkBmsDataPoints.cpp
+++ b/src/DataPoints.cpp
@@ -1,8 +1,6 @@
 #include <stdio.h>
 
-#include "JkBmsDataPoints.h"
-
-namespace JkBms {
+#include "DataPoints.h"
 
 static char conversionBuffer[16];
 
@@ -30,7 +28,7 @@ std::string dataPointValueToStr(bool const& v) {
 }
 
 template<>
-std::string dataPointValueToStr(tCells const& v) {
+std::string dataPointValueToStr(tCellVoltages const& v) {
     std::string res;
     res.reserve(v.size()*(2+2+1+4)); // separator, index, equal sign, value
     res += "(";
@@ -44,20 +42,3 @@ std::string dataPointValueToStr(tCells const& v) {
     res += ")";
     return std::move(res);
 }
-
-void DataPointContainer::updateFrom(DataPointContainer const& source)
-{
-    for (auto iter = source.cbegin(); iter != source.cend(); ++iter) {
-        auto pos = _dataPoints.find(iter->first);
-
-        if (pos != _dataPoints.end()) {
-            // do not update existing data points with the same value
-            if (pos->second == iter->second) { continue; }
-
-            _dataPoints.erase(pos);
-        }
-        _dataPoints.insert(*iter);
-    }
-}
-
-} /* namespace JkBms */
diff --git a/src/Display_Graphic.cpp b/src/Display_Graphic.cpp
index 540554f2..ce845cec 100644
--- a/src/Display_Graphic.cpp
+++ b/src/Display_Graphic.cpp
@@ -4,6 +4,7 @@
  */
 #include "Display_Graphic.h"
 #include "Datastore.h"
+#include "I18n.h"
 #include "PowerMeter.h"
 #include "Configuration.h"
 #include <NetworkSettings.h>
@@ -18,18 +19,11 @@ std::map<DisplayType_t, std::function<U8G2*(uint8_t, uint8_t, uint8_t, uint8_t)>
     { DisplayType_t::ST7567_GM12864I_59N, [](uint8_t reset, uint8_t clock, uint8_t data, uint8_t cs) { return new U8G2_ST7567_ENH_DG128064I_F_HW_I2C(U8G2_R0, reset, clock, data); } },
 };
 
-// Language defintion, respect order in languages[] and translation lists
+// Language defintion, respect order in translation lists
 #define I18N_LOCALE_EN 0
 #define I18N_LOCALE_DE 1
 #define I18N_LOCALE_FR 2
 
-// Languages supported. Note: the order is important and must match locale_translations.h
-const uint8_t languages[] = {
-    I18N_LOCALE_EN,
-    I18N_LOCALE_DE,
-    I18N_LOCALE_FR
-};
-
 static const char* const i18n_offline[] = { "Offline", "Offline", "Offline" };
 
 static const char* const i18n_current_power_w[] = { "%.0f W", "%.0f W", "%.0f W" };
@@ -171,9 +165,38 @@ void DisplayGraphicClass::setOrientation(const uint8_t rotation)
     calcLineHeights();
 }
 
-void DisplayGraphicClass::setLanguage(const uint8_t language)
+void DisplayGraphicClass::setLocale(const String& locale)
 {
-    _display_language = language < sizeof(languages) / sizeof(languages[0]) ? language : DISPLAY_LANGUAGE;
+    _display_language = locale;
+    uint8_t idx = I18N_LOCALE_EN;
+    if (locale == "de") {
+        idx = I18N_LOCALE_DE;
+    } else if (locale == "fr") {
+        idx = I18N_LOCALE_FR;
+    }
+
+    _i18n_date_format = i18n_date_format[idx];
+    _i18n_offline = i18n_offline[idx];
+    _i18n_current_power_w = i18n_current_power_w[idx];
+    _i18n_current_power_kw = i18n_current_power_kw[idx];
+    _i18n_meter_power_w = i18n_meter_power_w[idx];
+    _i18n_meter_power_kw = i18n_meter_power_kw[idx];
+    _i18n_yield_today_wh = i18n_yield_today_wh[idx];
+    _i18n_yield_today_kwh = i18n_yield_today_kwh[idx];
+    _i18n_yield_total_kwh = i18n_yield_total_kwh[idx];
+    _i18n_yield_total_mwh = i18n_yield_total_mwh[idx];
+
+    I18n.readDisplayStrings(locale,
+        _i18n_date_format,
+        _i18n_offline,
+        _i18n_current_power_w,
+        _i18n_current_power_kw,
+        _i18n_meter_power_w,
+        _i18n_meter_power_kw,
+        _i18n_yield_today_wh,
+        _i18n_yield_today_kwh,
+        _i18n_yield_total_kwh,
+        _i18n_yield_total_mwh);
 }
 
 void DisplayGraphicClass::setDiagramMode(DiagramMode_t mode)
@@ -230,9 +253,9 @@ void DisplayGraphicClass::loop()
         if (showText) {
             const float watts = Datastore.getTotalAcPowerEnabled();
             if (watts > 999) {
-                snprintf(_fmtText, sizeof(_fmtText), i18n_current_power_kw[_display_language], watts / 1000);
+                snprintf(_fmtText, sizeof(_fmtText), _i18n_current_power_kw.c_str(), watts / 1000);
             } else {
-                snprintf(_fmtText, sizeof(_fmtText), i18n_current_power_w[_display_language], watts);
+                snprintf(_fmtText, sizeof(_fmtText), _i18n_current_power_w.c_str(), watts);
             }
             printText(_fmtText, 0);
         }
@@ -242,7 +265,7 @@ void DisplayGraphicClass::loop()
 
     //=====> Offline ===========
     else {
-        printText(i18n_offline[_display_language], 0);
+        printText(_i18n_offline.c_str(), 0);
         // check if it's time to enter power saving mode
         if (millis() - _previousMillis >= (_interval * 2)) {
             displayPowerSave = enablePowerSafe;
@@ -254,16 +277,16 @@ void DisplayGraphicClass::loop()
         // Daily production
         float wattsToday = Datastore.getTotalAcYieldDayEnabled();
         if (wattsToday >= 10000) {
-            snprintf(_fmtText, sizeof(_fmtText), i18n_yield_today_kwh[_display_language], wattsToday / 1000);
+            snprintf(_fmtText, sizeof(_fmtText), _i18n_yield_today_kwh.c_str(), wattsToday / 1000);
         } else {
-            snprintf(_fmtText, sizeof(_fmtText), i18n_yield_today_wh[_display_language], wattsToday);
+            snprintf(_fmtText, sizeof(_fmtText), _i18n_yield_today_wh.c_str(), wattsToday);
         }
         printText(_fmtText, 1);
 
         // Total production
         const float wattsTotal = Datastore.getTotalAcYieldTotalEnabled();
-        auto const format = (wattsTotal >= 1000) ? i18n_yield_total_mwh : i18n_yield_total_kwh;
-        snprintf(_fmtText, sizeof(_fmtText), format[_display_language], wattsTotal);
+        auto const format = (wattsTotal >= 1000) ? _i18n_yield_total_mwh : _i18n_yield_total_kwh;
+        snprintf(_fmtText, sizeof(_fmtText), format.c_str(), wattsTotal);
         printText(_fmtText, 2);
 
         //=====> IP or Date-Time ========
@@ -273,7 +296,7 @@ void DisplayGraphicClass::loop()
         } else {
             // Get current time
             time_t now = time(nullptr);
-            strftime(_fmtText, sizeof(_fmtText), i18n_date_format[_display_language], localtime(&now));
+            strftime(_fmtText, sizeof(_fmtText), _i18n_date_format.c_str(), localtime(&now));
             printText(_fmtText, 3);
         }
     }
@@ -296,9 +319,9 @@ void DisplayGraphicClass::loop()
 
         auto acPower = PowerMeter.getPowerTotal();
         if (acPower > 999) {
-            snprintf(_fmtText, sizeof(_fmtText), i18n_meter_power_kw[_display_language], (acPower / 1000));
+            snprintf(_fmtText, sizeof(_fmtText), _i18n_meter_power_kw.c_str(), (acPower / 1000));
         } else {
-            snprintf(_fmtText, sizeof(_fmtText), i18n_meter_power_w[_display_language], acPower);
+            snprintf(_fmtText, sizeof(_fmtText), _i18n_meter_power_w.c_str(), acPower);
         }
 
         printText(_fmtText, 2);
diff --git a/src/HttpGetter.cpp b/src/HttpGetter.cpp
index c7eed556..c1dd8078 100644
--- a/src/HttpGetter.cpp
+++ b/src/HttpGetter.cpp
@@ -83,7 +83,7 @@ HttpRequestResult HttpGetter::performGetRequest()
     // depth at https://github.com/espressif/esp-idf/issues/2507#issuecomment-761836300
     // in conclusion: we cannot rely on _upHttpClient->begin(*wifiClient, url) to resolve
     // IP adresses. have to do it manually.
-    IPAddress ipaddr((uint32_t)0);
+    IPAddress ipaddr(static_cast<uint32_t>(0));
 
     if (!ipaddr.fromString(_host)) {
         // host is not an IP address, so try to resolve the name to an address.
diff --git a/src/Huawei_can.cpp b/src/Huawei_can.cpp
index c215ddb1..d1ed98b9 100644
--- a/src/Huawei_can.cpp
+++ b/src/Huawei_can.cpp
@@ -356,25 +356,12 @@ void HuaweiCanClass::loop()
       _autoPowerEnabledCounter = 10;
     }
 
-
-    // Check if inverter used by the power limiter is active
-    std::shared_ptr<InverterAbstract> inverter =
-        Hoymiles.getInverterBySerial(config.PowerLimiter.InverterId);
-
-    if (inverter == nullptr && config.PowerLimiter.InverterId < INV_MAX_COUNT) {
-        // we previously had an index saved as InverterId. fall back to the
-        // respective positional lookup if InverterId is not a known serial.
-        inverter = Hoymiles.getInverterByPos(config.PowerLimiter.InverterId);
-    }
-
-    if (inverter != nullptr) {
-        if(inverter->isProducing()) {
-          _setValue(0.0, HUAWEI_ONLINE_CURRENT);
-          // Don't run auto mode for a second now. Otherwise we may send too much over the CAN bus
-          _autoModeBlockedTillMillis = millis() + 1000;
-          MessageOutput.printf("[HuaweiCanClass::loop] Inverter is active, disable\r\n");
-          return;
-        }
+    if (PowerLimiter.isGovernedInverterProducing()) {
+      _setValue(0.0, HUAWEI_ONLINE_CURRENT);
+      // Don't run auto mode for a second now. Otherwise we may send too much over the CAN bus
+      _autoModeBlockedTillMillis = millis() + 1000;
+      MessageOutput.printf("[HuaweiCanClass::loop] Inverter is active, disable\r\n");
+      return;
     }
 
     if (PowerMeter.getLastUpdate() > _lastPowerMeterUpdateReceivedMillis &&
diff --git a/src/I18n.cpp b/src/I18n.cpp
new file mode 100644
index 00000000..b8d48e76
--- /dev/null
+++ b/src/I18n.cpp
@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2024 Thomas Basler and others
+ */
+#include "I18n.h"
+#include "MessageOutput.h"
+#include "Utils.h"
+#include "defaults.h"
+#include <ArduinoJson.h>
+#include <LittleFS.h>
+
+I18nClass I18n;
+
+I18nClass::I18nClass()
+{
+}
+
+void I18nClass::init(Scheduler& scheduler)
+{
+    readLangPacks();
+}
+
+std::list<LanguageInfo_t> I18nClass::getAvailableLanguages()
+{
+    return _availLanguages;
+}
+
+String I18nClass::getFilenameByLocale(const String& locale) const
+{
+    auto it = std::find_if(_availLanguages.begin(), _availLanguages.end(), [locale](const LanguageInfo_t& elem) {
+        return elem.code == locale;
+    });
+
+    if (it != _availLanguages.end()) {
+        return it->filename;
+    } else {
+        return String();
+    }
+}
+
+void I18nClass::readDisplayStrings(
+    const String& locale,
+    String& date_format,
+    String& offline,
+    String& power_w, String& power_kw,
+    String& meter_power_w, String& meter_power_kw,
+    String& yield_today_wh, String& yield_today_kwh,
+    String& yield_total_kwh, String& yield_total_mwh)
+{
+    auto filename = getFilenameByLocale(locale);
+    if (filename == "") {
+        return;
+    }
+
+    JsonDocument filter;
+    filter["display"] = true;
+
+    File f = LittleFS.open(filename, "r", false);
+
+    JsonDocument doc;
+
+    // Deserialize the JSON document
+    const DeserializationError error = deserializeJson(doc, f, DeserializationOption::Filter(filter));
+    if (error) {
+        MessageOutput.printf("Failed to read file %s\r\n", filename.c_str());
+        f.close();
+        return;
+    }
+
+    if (!Utils::checkJsonAlloc(doc, __FUNCTION__, __LINE__)) {
+        return;
+    }
+
+    auto displayData = doc["display"];
+
+    if (displayData["date_format"].as<String>() != "null") {
+        date_format = displayData["date_format"].as<String>();
+    }
+
+    if (displayData["offline"].as<String>() != "null") {
+        offline = displayData["offline"].as<String>();
+    }
+
+    if (displayData["power_w"].as<String>() != "null") {
+        power_w = displayData["power_w"].as<String>();
+    }
+
+    if (displayData["power_kw"].as<String>() != "null") {
+        power_kw = displayData["power_kw"].as<String>();
+    }
+
+    if (displayData["meter_power_w"].as<String>() != "null") {
+        meter_power_w = displayData["meter_power_w"].as<String>();
+    }
+
+    if (displayData["meter_power_kw"].as<String>() != "null") {
+        meter_power_kw = displayData["meter_power_kw"].as<String>();
+    }
+
+    if (displayData["yield_today_wh"].as<String>() != "null") {
+        yield_today_wh = displayData["yield_today_wh"].as<String>();
+    }
+
+    if (displayData["yield_today_kwh"].as<String>() != "null") {
+        yield_today_kwh = displayData["yield_today_kwh"].as<String>();
+    }
+
+    if (displayData["yield_total_kwh"].as<String>() != "null") {
+        yield_total_kwh = displayData["yield_total_kwh"].as<String>();
+    }
+
+    if (displayData["yield_total_mwh"].as<String>() != "null") {
+        yield_total_mwh = displayData["yield_total_mwh"].as<String>();
+    }
+
+    f.close();
+}
+
+void I18nClass::readLangPacks()
+{
+    auto root = LittleFS.open("/");
+    auto file = root.getNextFileName();
+
+    while (file != "") {
+        if (file.endsWith(LANG_PACK_SUFFIX)) {
+            MessageOutput.printf("Read File %s\r\n", file.c_str());
+            readConfig(file);
+        }
+        file = root.getNextFileName();
+    }
+    root.close();
+}
+
+void I18nClass::readConfig(String file)
+{
+    JsonDocument filter;
+    filter["meta"] = true;
+
+    File f = LittleFS.open(file, "r", false);
+
+    JsonDocument doc;
+
+    // Deserialize the JSON document
+    const DeserializationError error = deserializeJson(doc, f, DeserializationOption::Filter(filter));
+    if (error) {
+        MessageOutput.printf("Failed to read file %s\r\n", file.c_str());
+        f.close();
+        return;
+    }
+
+    if (!Utils::checkJsonAlloc(doc, __FUNCTION__, __LINE__)) {
+        return;
+    }
+
+    LanguageInfo_t lang;
+    lang.code = String(doc["meta"]["code"] | "");
+    lang.name = String(doc["meta"]["name"] | "");
+    lang.filename = file;
+
+    if (lang.code != "" && lang.name != "") {
+        _availLanguages.push_back(lang);
+    } else {
+        MessageOutput.printf("Invalid meta data\r\n");
+    }
+
+    f.close();
+}
diff --git a/src/InverterSettings.cpp b/src/InverterSettings.cpp
index d2d92919..a23ef377 100644
--- a/src/InverterSettings.cpp
+++ b/src/InverterSettings.cpp
@@ -63,10 +63,10 @@ void InverterSettingsClass::init(Scheduler& scheduler)
 
         for (uint8_t i = 0; i < INV_MAX_COUNT; i++) {
             if (config.Inverter[i].Serial > 0) {
-                MessageOutput.print("  Adding inverter: ");
-                MessageOutput.print(config.Inverter[i].Serial, HEX);
-                MessageOutput.print(" - ");
-                MessageOutput.print(config.Inverter[i].Name);
+                MessageOutput.printf("  Adding inverter: %0" PRIx32 "%08" PRIx32 " - %s",
+                    static_cast<uint32_t>((config.Inverter[i].Serial >> 32) & 0xFFFFFFFF),
+                    static_cast<uint32_t>(config.Inverter[i].Serial & 0xFFFFFFFF),
+                    config.Inverter[i].Name);
                 auto inv = Hoymiles.addInverter(
                     config.Inverter[i].Name,
                     config.Inverter[i].Serial);
diff --git a/src/JbdBmsController.cpp b/src/JbdBmsController.cpp
new file mode 100644
index 00000000..3fc1dd33
--- /dev/null
+++ b/src/JbdBmsController.cpp
@@ -0,0 +1,274 @@
+#include <Arduino.h>
+#include <numeric>
+#include "Configuration.h"
+#include "HardwareSerial.h"
+#include "PinMapping.h"
+#include "MessageOutput.h"
+#include "JbdBmsDataPoints.h"
+#include "JbdBmsController.h"
+#include "JbdBmsSerialMessage.h"
+#include "SerialPortManager.h"
+#include <frozen/map.h>
+
+namespace JbdBms {
+
+bool Controller::init(bool verboseLogging)
+{
+    _verboseLogging = verboseLogging;
+
+    std::string ifcType = "transceiver";
+    if (Interface::Transceiver != getInterface()) { ifcType = "TTL-UART"; }
+    MessageOutput.printf("[JBD BMS] Initialize %s interface...\r\n", ifcType.c_str());
+
+    const PinMapping_t& pin = PinMapping.get();
+    MessageOutput.printf("[JBD BMS] rx = %d, rxen = %d, tx = %d, txen = %d\r\n",
+            pin.battery_rx, pin.battery_rxen, pin.battery_tx, pin.battery_txen);
+
+    if (pin.battery_rx < 0 || pin.battery_tx < 0) {
+        MessageOutput.println("[JBD BMS] Invalid RX/TX pin config");
+        return false;
+    }
+
+#ifdef JBDBMS_DUMMY_SERIAL
+    _upSerial = std::make_unique<DummySerial>();
+#else
+    auto oHwSerialPort = SerialPortManager.allocatePort(_serialPortOwner);
+    if (!oHwSerialPort) { return false; }
+
+    _upSerial = std::make_unique<HardwareSerial>(*oHwSerialPort);
+#endif
+
+    _upSerial->end(); // make sure the UART will be re-initialized
+    _upSerial->begin(9600, SERIAL_8N1, pin.battery_rx, pin.battery_tx);
+    _upSerial->flush();
+
+    if (Interface::Transceiver != getInterface()) { return true; }
+
+    _rxEnablePin = pin.battery_rxen;
+    _txEnablePin = pin.battery_txen;
+
+    if (_rxEnablePin < 0 || _txEnablePin < 0) {
+        MessageOutput.println("[JBD BMS] Invalid transceiver pin config");
+        return false;
+    }
+
+    pinMode(_rxEnablePin, OUTPUT);
+    pinMode(_txEnablePin, OUTPUT);
+
+    return true;
+}
+
+void Controller::deinit()
+{
+    _upSerial->end();
+
+    if (_rxEnablePin > 0) { pinMode(_rxEnablePin, INPUT); }
+    if (_txEnablePin > 0) { pinMode(_txEnablePin, INPUT); }
+
+    SerialPortManager.freePort(_serialPortOwner);
+}
+
+Controller::Interface Controller::getInterface() const
+{
+    auto const& config = Configuration.get();
+    if (0x00 == config.Battery.JkBmsInterface) { return Interface::Uart; }
+    if (0x01 == config.Battery.JkBmsInterface) { return Interface::Transceiver; }
+    return Interface::Invalid;
+}
+
+frozen::string const& Controller::getStatusText(Controller::Status status)
+{
+    static constexpr frozen::string missing = "programmer error: missing status text";
+
+    static constexpr frozen::map<Status, frozen::string, 6> texts = {
+        { Status::Timeout, "timeout wating for response from BMS" },
+        { Status::WaitingForPollInterval, "waiting for poll interval to elapse" },
+        { Status::HwSerialNotAvailableForWrite, "UART is not available for writing" },
+        { Status::BusyReading, "busy waiting for or reading a message from the BMS" },
+        { Status::RequestSent, "request for data sent" },
+        { Status::FrameCompleted, "a whole frame was received" }
+    };
+
+    auto iter = texts.find(status);
+    if (iter == texts.end()) { return missing; }
+
+    return iter->second;
+}
+
+void Controller::announceStatus(Controller::Status status)
+{
+    if (_lastStatus == status && millis() < _lastStatusPrinted + 10 * 1000) { return; }
+
+    MessageOutput.printf("[%11.3f] JBD BMS: %s\r\n",
+        static_cast<double>(millis())/1000, getStatusText(status).data());
+
+    _lastStatus = status;
+    _lastStatusPrinted = millis();
+}
+
+void Controller::sendRequest(uint8_t pollInterval)
+{
+    if (ReadState::Idle != _readState) {
+        return announceStatus(Status::BusyReading);
+    }
+
+    if ((millis() - _lastRequest) < pollInterval * 1000) {
+        return announceStatus(Status::WaitingForPollInterval);
+    }
+
+    if (!_upSerial->availableForWrite()) {
+        return announceStatus(Status::HwSerialNotAvailableForWrite);
+    }
+
+    SerialCommand::Command cmd;
+    switch (SerialCommand::getLastCommand()) {
+        case SerialCommand::Command::Init: // read only once
+            cmd = SerialCommand::Command::ReadHardwareVersionNumber;
+            break;
+        case SerialCommand::Command::ReadBasicInformation:
+            cmd = SerialCommand::Command::ReadCellVoltages;
+            break;
+        case SerialCommand::Command::ReadCellVoltages:
+            cmd = SerialCommand::Command::ReadBasicInformation;
+            break;
+        default:
+            cmd = SerialCommand::Command::ReadBasicInformation;
+            break;
+    }
+
+    SerialCommand readCmd(SerialCommand::Status::Read, cmd);
+
+    if (Interface::Transceiver == getInterface()) {
+        digitalWrite(_rxEnablePin, HIGH); // disable reception (of our own data)
+        digitalWrite(_txEnablePin, HIGH); // enable transmission
+    }
+
+    _upSerial->write(readCmd.data(), readCmd.size());
+
+    if (Interface::Transceiver == getInterface()) {
+        _upSerial->flush();
+        digitalWrite(_rxEnablePin, LOW); // enable reception
+        digitalWrite(_txEnablePin, LOW); // disable transmission (free the bus)
+    }
+
+    _lastRequest = millis();
+
+    setReadState(ReadState::WaitingForFrameStart);
+    return announceStatus(Status::RequestSent);
+}
+
+void Controller::loop()
+{
+    auto const& config = Configuration.get();
+    uint8_t pollInterval = config.Battery.JkBmsPollingInterval;
+
+    while (_upSerial->available()) {
+        rxData(_upSerial->read());
+    }
+
+    sendRequest(pollInterval);
+
+    if (millis() > _lastRequest + 2 * pollInterval * 1000 + 250) {
+        reset();
+        return announceStatus(Status::Timeout);
+    }
+}
+
+void Controller::rxData(uint8_t inbyte)
+{
+    _buffer.push_back(inbyte);
+
+    switch(_readState) {
+        case ReadState::Idle: // unsolicited message from BMS
+        case ReadState::WaitingForFrameStart:
+            if (inbyte == SerialMessage::startMarker) {
+                return setReadState(ReadState::FrameStartReceived);
+            }
+            break;
+        case ReadState::FrameStartReceived:
+            return setReadState(ReadState::StateReceived);
+            break;
+        case ReadState::StateReceived:
+            return setReadState(ReadState::CommandCodeReceived);
+            break;
+        case ReadState::CommandCodeReceived:
+            _dataLength = inbyte;
+            if (_dataLength == 0) {
+                return setReadState(ReadState::DataContentReceived);
+            }
+            return setReadState(ReadState::ReadingDataContent);
+            break;
+        case ReadState::ReadingDataContent:
+            _dataLength--;
+            if (_dataLength == 0) {
+                return setReadState(ReadState::DataContentReceived);
+            }
+            return setReadState(ReadState::ReadingDataContent);
+            break;
+        case ReadState::DataContentReceived:
+            return setReadState(ReadState::ReadingCheckSum);
+            break;
+        case ReadState::ReadingCheckSum:
+            return setReadState(ReadState::CheckSumReceived);
+            break;
+        case ReadState::CheckSumReceived:
+            if (inbyte == SerialMessage::endMarker) {
+                return frameComplete();
+            }
+            MessageOutput.printf("[JBD BMS] Invalid Frame: end marker not found.");
+            MessageOutput.println();
+            return reset();
+            break;
+    }
+    reset();
+}
+
+void Controller::reset()
+{
+    _buffer.clear();
+    return setReadState(ReadState::Idle);
+}
+
+void Controller::frameComplete()
+{
+    announceStatus(Status::FrameCompleted);
+
+    if (_verboseLogging) {
+        double ts = static_cast<double>(millis())/1000;
+        MessageOutput.printf("[%11.3f] JBD BMS: raw data (%d Bytes):",
+            ts, _buffer.size());
+        for (size_t ctr = 0; ctr < _buffer.size(); ++ctr) {
+            if (ctr % 16 == 0) {
+                MessageOutput.printf("\r\n[%11.3f] JBD BMS:", ts);
+            }
+            MessageOutput.printf(" %02x", _buffer[ctr]);
+        }
+        MessageOutput.println();
+    }
+
+    auto pResponse = std::make_unique<SerialResponse>(std::move(_buffer));
+    if (pResponse->isValid()) {
+        processDataPoints(pResponse->getDataPoints());
+    } // if invalid, error message has been produced by SerialResponse c'tor
+
+    reset();
+}
+
+void Controller::processDataPoints(DataPointContainer const& dataPoints)
+{
+    _stats->updateFrom(dataPoints);
+
+    if (!_verboseLogging) { return; }
+
+    auto iter = dataPoints.cbegin();
+    while ( iter != dataPoints.cend() ) {
+        MessageOutput.printf("[%11.3f] JBD BMS: %s: %s%s\r\n",
+            static_cast<double>(iter->second.getTimestamp())/1000,
+            iter->second.getLabelText().c_str(),
+            iter->second.getValueText().c_str(),
+            iter->second.getUnitText().c_str());
+        ++iter;
+    }
+}
+
+} /* namespace JbdBms */
diff --git a/src/JbdBmsSerialMessage.cpp b/src/JbdBmsSerialMessage.cpp
new file mode 100644
index 00000000..302eeb04
--- /dev/null
+++ b/src/JbdBmsSerialMessage.cpp
@@ -0,0 +1,272 @@
+#include <numeric>
+#include <sstream>
+#include <iomanip>
+#include "JbdBmsSerialMessage.h"
+#include "MessageOutput.h"
+
+namespace JbdBms {
+
+SerialCommand::SerialCommand(SerialCommand::Status status, SerialCommand::Command cmd)
+    : SerialMessage(7, 0x00) // frame length 7 bytes initialized with zeros
+{
+    set(_raw.begin(), startMarker);
+    set(_raw.begin() + 1, static_cast<uint8_t>(status));
+    set(_raw.begin() + 2, static_cast<uint8_t>(cmd));
+    set(_raw.begin() + 3, static_cast<uint16_t>(0x00)); // frame length
+    updateChecksum();
+    set(_raw.end() - 1, endMarker);
+
+    _lastCmd = cmd;
+}
+
+SerialCommand::Command SerialCommand::_lastCmd = SerialCommand::Command::Init;
+
+
+using Label = JbdBms::DataPointLabel;
+template<Label L> using Traits = DataPointLabelTraits<L>;
+
+SerialResponse::SerialResponse(tData&& raw)
+    : SerialMessage(std::move(raw))
+{
+    if (!isValid()) { return; }
+
+    auto pos = _raw.cbegin() + 4; // start of data content
+    auto end = pos + getDataLength(); // end of data content
+
+    if (pos < end) {
+
+        if (getCommand() == Command::ReadBasicInformation) {
+
+            _dp.add<Label::BatteryVoltageMilliVolt>(static_cast<uint32_t>(get<uint16_t>(pos)) * 10); // Total voltage
+            _dp.add<Label::BatteryCurrentMilliAmps>(static_cast<int32_t>(get<int16_t>(pos)) * 10); // Current
+            _dp.add<Label::ActualBatteryCapacityAmpHours>(static_cast<uint32_t>(get<uint16_t>(pos)) * 10 / 1000); // remaining capacity
+            _dp.add<Label::BatteryCapacitySettingAmpHours>(static_cast<uint32_t>(get<uint16_t>(pos)) * 10 / 1000); // nominal capacity
+            _dp.add<Label::BatteryCycles>(get<uint16_t>(pos));
+            _dp.add<Label::DateOfManufacturing >(getProductionDate(pos));
+
+            bool balancingEnabled = false;
+            balancingEnabled |= static_cast<bool>(get<uint16_t>(pos)); // Equilibrium
+            balancingEnabled |= static_cast<bool>(get<uint16_t>(pos)); // Equilibrium_High
+            _dp.add<Label::BalancingEnabled>(balancingEnabled);
+
+            _dp.add<Label::AlarmsBitmask>(get<uint16_t>(pos)); // Protection status
+
+            uint8_t softwareVersion = get<uint8_t>(pos);
+            uint8_t digitOne = softwareVersion & 0x0F;
+            uint8_t digitTwo = softwareVersion >> 4;
+            char buffer[6];
+            snprintf(buffer, sizeof(buffer), "%d.%d", digitOne, digitTwo);
+            _dp.add<Label::BmsSoftwareVersion>(std::string(buffer)); // Software version
+
+            _dp.add<Label::BatterySoCPercent>(get<uint8_t>(pos)); // RSOC
+
+            uint8_t fetControl = get<uint8_t>(pos); // FET control status
+            const uint8_t chargingMask = (1 << 0);
+            const uint8_t dischargingMask = (1 << 1);
+            bool fetChargeEnabled = static_cast<bool>(fetControl & chargingMask);
+            bool fetDischargeEnabled = static_cast<bool>(fetControl & dischargingMask);
+            _dp.add<Label::BatteryChargeEnabled>(fetChargeEnabled);
+            _dp.add<Label::BatteryDischargeEnabled>(fetDischargeEnabled);
+
+            _dp.add<Label::BatteryCellAmount>(static_cast<uint16_t>(get<uint8_t>(pos))); // number of battery strings
+            _dp.add<Label::BatteryTemperatureSensorAmount>(get<uint8_t>(pos)); // number of ntc
+            _dp.add<Label::BatteryTempOneCelsius>(getTemperature(pos)); // ntc temperature one
+            _dp.add<Label::BatteryTempTwoCelsius>(getTemperature(pos)); // ntc temperature two
+        }
+        else if (getCommand() == Command::ReadCellVoltages)
+        {
+            uint8_t cellAmount = getDataLength() / 2;
+            std::map<uint8_t, uint16_t> voltages;
+            for (size_t cellCounter = 0; cellCounter < cellAmount; ++cellCounter) {
+                uint8_t idx = cellCounter;
+                auto cellMilliVolt = get<uint16_t>(pos);
+                voltages[idx] = cellMilliVolt;
+            }
+            _dp.add<Label::CellsMilliVolt>(voltages);
+        }
+        else if (getCommand() == Command::ReadHardwareVersionNumber)
+        {
+            _dp.add<Label::BmsHardwareVersion>(getString(pos, getDataLength()));
+        }
+        else if (getCommand() == Command::ControlMosInstruction)
+        {
+            /* Response doesn't contain any data content */
+        }
+
+    }
+}
+
+/**
+ * NOTE that this function moves the iterator by the amount of bytes read.
+ */
+template<typename T, typename It>
+T SerialMessage::get(It&& pos) const
+{
+    // add easy-to-understand error message when called with non-const iter,
+    // as compiler generated error message is hard to understand.
+    using ItNoRef = typename std::remove_reference<It>::type;
+    using PtrType = typename std::iterator_traits<ItNoRef>::pointer;
+    using ValueType = typename std::remove_pointer<PtrType>::type;
+    static_assert(std::is_const<ValueType>::value, "get() must be called with a const_iterator");
+
+    // avoid out-of-bound read
+    if (std::distance(pos, _raw.cend()) < sizeof(T)) { return 0; }
+
+    T res = 0;
+    for (unsigned i = 0; i < sizeof(T); ++i) {
+        res |= static_cast<T>(*(pos++)) << (sizeof(T)-1-i)*8;
+    }
+    return res;
+}
+
+template<typename It>
+bool SerialMessage::getBool(It&& pos) const
+{
+    uint8_t raw = get<uint8_t>(pos);
+    return raw > 0;
+}
+
+template<typename It>
+int16_t SerialMessage::getTemperature(It&& pos) const
+{
+    // raw in 0.1K
+    uint16_t raw = get<uint16_t>(pos);
+    return static_cast<int16_t>(raw - 2731) / 10;
+}
+
+template<typename It>
+std::string SerialMessage::getProductionDate(It&& pos) const
+{
+    // E.g. 0x2068 = 08.03.2016
+    // the date is the lowest 5: 0x2028 & 0x1f = 8 means the date;
+    // month (0x2068>>5) & 0x0f = 0x03 means March;
+    // the year is 2000+ (0x2068>>9) = 2000 + 0x10 =2016;
+    uint16_t raw = get<uint16_t>(pos);
+
+    uint16_t day = raw & 0x1f;
+    uint16_t month = (raw>>5) & 0x0f;
+    uint16_t year = 2000 + (raw>>9);
+    std::ostringstream oss;
+    oss << std::setw(2) << std::setfill('0') << day << "." << std::setw(2) << std::setfill('0') << month << "." << std::setw(4) << std::setfill('0') << year;
+    return oss.str();
+}
+
+template<typename It>
+std::string SerialMessage::getString(It&& pos, size_t len, bool replaceZeroes) const
+{
+    // avoid out-of-bound read
+    len = std::min<size_t>(std::distance(pos, _raw.cend()), len);
+
+    auto start = pos;
+    pos += len;
+
+    if (replaceZeroes) {
+        std::vector<uint8_t> copy(start, pos);
+        for (auto& c : copy) {
+            if (c == 0) { c = 0x20; } // replace by ASCII space
+        }
+        return std::string(copy.cbegin(), copy.cend());
+    }
+
+    return std::string(start, pos);
+}
+
+template<typename T>
+void SerialMessage::set(tData::iterator const& pos, T val)
+{
+    // avoid out-of-bound write
+    if (std::distance(pos, _raw.end()) < sizeof(T)) { return; }
+
+    for (unsigned i = 0; i < sizeof(T); ++i) {
+        *(pos+i) = static_cast<uint8_t>(val >> (sizeof(T)-1-i)*8);
+    }
+}
+
+uint16_t SerialMessage::calcChecksum() const
+{
+    return (~std::accumulate(_raw.cbegin()+2, _raw.cend()-3, 0) + 0x01);
+}
+
+void SerialMessage::updateChecksum()
+{
+    set(_raw.end()-3, calcChecksum());
+}
+
+void SerialMessage::printMessage() {
+
+    double ts = static_cast<double>(millis())/1000;
+    MessageOutput.printf("[%11.3f] JBD BMS: raw message (%d Bytes):",
+        ts, _raw.size());
+    for (size_t ctr = 0; ctr < _raw.size(); ++ctr) {
+        MessageOutput.printf(" %02x", _raw[ctr]);
+    }
+    MessageOutput.println();
+}
+
+bool SerialMessage::isValid() const {
+
+    uint8_t const actualStartMarker = getStartMarker();
+    if (actualStartMarker != startMarker) {
+        MessageOutput.printf("JbdBms::SerialMessage: invalid start marker 0x%02x, expected 0x%02x\r\n",
+            actualStartMarker, startMarker);
+        return false;
+    }
+
+    uint16_t const dataLength = getDataLength();
+    uint16_t const dataLengthExpected = _raw.size() - 7;
+    if (dataLength != _raw.size() - 7) {
+        MessageOutput.printf("JbdBms::SerialMessage: unexpected data length 0x%04x, expected 0x%04x\r\n",
+            dataLength, dataLengthExpected);
+        return false;
+    }
+
+    uint8_t const actualEndMarker = getEndMarker();
+    if (actualEndMarker != endMarker) {
+        MessageOutput.printf("JbdBms::SerialMessage: invalid end marker 0x%02x, expected 0x%02x\r\n",
+            actualEndMarker, endMarker);
+        return false;
+    }
+
+    uint16_t const actualChecksum = getChecksum();
+    uint16_t const expectedChecksum = calcChecksum();
+    if (actualChecksum != expectedChecksum) {
+        MessageOutput.printf("JbdBms::SerialMessage: invalid checksum 0x%04x, expected 0x%04x\r\n",
+            actualChecksum, expectedChecksum);
+        return false;
+    }
+
+    return true;
+}
+
+bool SerialResponse::isValid() const {
+
+    if(!SerialMessage::isValid()) {return false;}
+
+    Status const actualStatus = getStatus();
+    if (actualStatus != Status::Ok) {
+        MessageOutput.printf("JbdBms::SerialMessage: invalid status 0x%02x, expected 0x%02x\r\n",
+            static_cast<uint32_t>(actualStatus),
+            static_cast<uint32_t>(Status::Ok));
+        return false;
+    }
+
+    return true;
+}
+
+bool SerialCommand::isValid() const {
+
+    if(!SerialMessage::isValid()) {return false;}
+
+    Status const actualStatus = getStatus();
+    if (actualStatus != Status::Read || actualStatus != Status::Write) {
+        MessageOutput.printf("JbdBms::SerialMessage: invalid status 0x%02x, expected 0x%02x or 0x%02x\r\n",
+            static_cast<uint32_t>(actualStatus),
+            static_cast<uint32_t>(Status::Read),
+            static_cast<uint32_t>(Status::Write));
+        return false;
+    }
+
+    return true;
+}
+
+} /* namespace JbdBms */
diff --git a/src/JkBmsController.cpp b/src/JkBmsController.cpp
index db1a2d5b..0a53ec2f 100644
--- a/src/JkBmsController.cpp
+++ b/src/JkBmsController.cpp
@@ -68,7 +68,7 @@ void Controller::deinit()
 
 Controller::Interface Controller::getInterface() const
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     if (0x00 == config.Battery.JkBmsInterface) { return Interface::Uart; }
     if (0x01 == config.Battery.JkBmsInterface) { return Interface::Transceiver; }
     return Interface::Invalid;
@@ -141,7 +141,7 @@ void Controller::sendRequest(uint8_t pollInterval)
 
 void Controller::loop()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     uint8_t pollInterval = config.Battery.JkBmsPollingInterval;
 
     while (_upSerial->available()) {
diff --git a/src/MqttHandleBatteryHass.cpp b/src/MqttHandleBatteryHass.cpp
index b2af9e66..c80c6562 100644
--- a/src/MqttHandleBatteryHass.cpp
+++ b/src/MqttHandleBatteryHass.cpp
@@ -21,7 +21,7 @@ void MqttHandleBatteryHassClass::init(Scheduler& scheduler)
 
 void MqttHandleBatteryHassClass::loop()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     if (!config.Battery.Enabled) { return; }
 
@@ -214,6 +214,43 @@ void MqttHandleBatteryHassClass::loop()
             publishBinarySensor("Charge enabled", "mdi:battery-arrow-up", "charging/chargeEnabled", "1", "0");
             publishBinarySensor("Discharge enabled", "mdi:battery-arrow-down", "charging/dischargeEnabled", "1", "0");
 
+            break;
+        case 6: // JBD BMS
+            //            caption                  icon                    topic                    dev. class     state class    unit
+            publishSensor("Voltage",               "mdi:battery-charging", "voltage",               "voltage",     "measurement", "V");
+            publishSensor("Current",               "mdi:current-dc",       "current",               "current",     "measurement", "A");
+            publishSensor("Cell Min Voltage",      NULL,                   "CellMinMilliVolt",      "voltage",     "measurement", "mV");
+            publishSensor("Cell Average Voltage",  NULL,                   "CellAvgMilliVolt",      "voltage",     "measurement", "mV");
+            publishSensor("Cell Max Voltage",      NULL,                   "CellMaxMilliVolt",      "voltage",     "measurement", "mV");
+            publishSensor("Cell Voltage Diff",     "mdi:battery-alert",    "CellDiffMilliVolt",     "voltage",     "measurement", "mV");
+            publishSensor("Battery Temperature 1", "mdi:thermometer",      "BatteryTempOneCelsius", "temperature", "measurement", "°C");
+            publishSensor("Battery Temperature 2", "mdi:thermometer",      "BatteryTempTwoCelsius", "temperature", "measurement", "°C");
+            publishSensor("Alarms Bitmask",        NULL,                   "AlarmsBitmask");
+            publishSensor("Charge Cycles",         "mdi:counter",          "BatteryCycles");
+            publishSensor("Available Capacity",    NULL,                   "ActualBatteryCapacityAmpHours");
+
+            publishBinarySensor("Charging enabled",    "mdi:battery-arrow-up",   "BatteryChargeEnabled",    "yes", "no");
+            publishBinarySensor("Discharging enabled", "mdi:battery-arrow-down", "BatteryDischargeEnabled", "yes", "no");
+            publishBinarySensor("Balancing enabled",   "mdi:scale-balance",      "BatteryBalancingEnabled", "yes", "no");
+
+#define PBS(a, b, c) publishBinarySensor("Alarm: " a, "mdi:" b, "alarms/" c, "1", "0")
+            PBS("Cell Overvoltage",             "battery-alert",                 "CellOverVoltage");
+            PBS("Cell Undervoltage",            "battery-alert",                 "CellUnderVoltage");
+            PBS("Pack Overvoltage",             "fuse-alert",                    "PackOverVoltage");
+            PBS("Pack Undervoltage",            "fuse-alert",                    "PackUnderVoltage");
+            PBS("Charging Overtemperature",     "thermometer-alert",             "ChargingOverTemperature");
+            PBS("Charging Undertemperature",    "thermometer-alert",             "ChargingLowTemperature");
+            PBS("Discharging Overtemperature",  "thermometer-alert",             "DischargingOverTemperature");
+            PBS("Discharging Undertemperature", "thermometer-alert",             "DischargingLowTemperature");
+            PBS("Charging Overcurrent",         "fuse-alert",                    "ChargingOverCurrent");
+            PBS("Discharging Overcurrent",      "fuse-alert",                    "DischargeOverCurrent");
+            PBS("Short Circuit",                "fuse-alert",                    "ShortCircuit");
+            PBS("IC Frontend Error",            "battery-alert-variant-outline", "IcFrontEndError");
+            PBS("MOS Software Lock",            "battery-alert-variant-outline", "MosSoftwareLock");
+            PBS("Reserved 1",                   "battery-alert-variant-outline", "Reserved1");
+            PBS("Reserved 2",                   "battery-alert-variant-outline", "Reserved2");
+            PBS("Reserved 3",                   "battery-alert-variant-outline", "Reserved3");
+#undef PBS
             break;
     }
 
@@ -323,7 +360,7 @@ void MqttHandleBatteryHassClass::createDeviceInfo(JsonObject& object)
 {
     object["name"] = "Battery(" + serial + ")";
 
-    auto& config = Configuration.get();
+    auto const& config = Configuration.get();
     if (config.Battery.Provider == 1) {
         object["name"] = "JK BMS (" + Battery.getStats()->getManufacturer() + ")";
     }
diff --git a/src/MqttHandlePowerLimiter.cpp b/src/MqttHandlePowerLimiter.cpp
index 744320ed..d4861e62 100644
--- a/src/MqttHandlePowerLimiter.cpp
+++ b/src/MqttHandlePowerLimiter.cpp
@@ -65,7 +65,7 @@ void MqttHandlePowerLimiterClass::loop()
 {
     std::unique_lock<std::mutex> mqttLock(_mqttMutex);
 
-    const CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     if (!config.PowerLimiter.Enabled) {
         _mqttCallbacks.clear();
@@ -87,15 +87,15 @@ void MqttHandlePowerLimiterClass::loop()
 
     auto val = static_cast<unsigned>(PowerLimiter.getMode());
     MqttSettings.publish("powerlimiter/status/mode", String(val));
-    
-    MqttSettings.publish("powerlimiter/status/upper_power_limit", String(config.PowerLimiter.UpperPowerLimit));
+
+    MqttSettings.publish("powerlimiter/status/upper_power_limit", String(config.PowerLimiter.TotalUpperPowerLimit));
 
     MqttSettings.publish("powerlimiter/status/target_power_consumption", String(config.PowerLimiter.TargetPowerConsumption));
 
     MqttSettings.publish("powerlimiter/status/inverter_update_timeouts", String(PowerLimiter.getInverterUpdateTimeouts()));
 
     // no thresholds are relevant for setups without a battery
-    if (config.PowerLimiter.IsInverterSolarPowered) { return; }
+    if (!PowerLimiter.usesBatteryPoweredInverter()) { return; }
 
     MqttSettings.publish("powerlimiter/status/threshold/voltage/start", String(config.PowerLimiter.VoltageStartThreshold));
     MqttSettings.publish("powerlimiter/status/threshold/voltage/stop", String(config.PowerLimiter.VoltageStopThreshold));
@@ -118,8 +118,6 @@ void MqttHandlePowerLimiterClass::loop()
 
 void MqttHandlePowerLimiterClass::onMqttCmd(MqttPowerLimiterCommand command, const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total)
 {
-    CONFIG_T& config = Configuration.get();
-
     std::string strValue(reinterpret_cast<const char*>(payload), len);
     float payload_val = -1;
     try {
@@ -132,30 +130,35 @@ void MqttHandlePowerLimiterClass::onMqttCmd(MqttPowerLimiterCommand command, con
     }
     const int intValue = static_cast<int>(payload_val);
 
-    std::lock_guard<std::mutex> mqttLock(_mqttMutex);
+    if (command == MqttPowerLimiterCommand::Mode) {
+        std::lock_guard<std::mutex> mqttLock(_mqttMutex);
+        using Mode = PowerLimiterClass::Mode;
+        Mode mode = static_cast<Mode>(intValue);
+        if (mode == Mode::UnconditionalFullSolarPassthrough) {
+            MessageOutput.println("Power limiter unconditional full solar PT");
+            _mqttCallbacks.push_back(std::bind(&PowerLimiterClass::setMode,
+                        &PowerLimiter, Mode::UnconditionalFullSolarPassthrough));
+        } else if (mode == Mode::Disabled) {
+            MessageOutput.println("Power limiter disabled (override)");
+            _mqttCallbacks.push_back(std::bind(&PowerLimiterClass::setMode,
+                        &PowerLimiter, Mode::Disabled));
+        } else if (mode == Mode::Normal) {
+            MessageOutput.println("Power limiter normal operation");
+            _mqttCallbacks.push_back(std::bind(&PowerLimiterClass::setMode,
+                        &PowerLimiter, Mode::Normal));
+        } else {
+            MessageOutput.printf("PowerLimiter - unknown mode %d\r\n", intValue);
+        }
+        return;
+    }
+
+    auto guard = Configuration.getWriteGuard();
+    auto& config = guard.getConfig();
 
     switch (command) {
         case MqttPowerLimiterCommand::Mode:
-            {
-                using Mode = PowerLimiterClass::Mode;
-                Mode mode = static_cast<Mode>(intValue);
-                if (mode == Mode::UnconditionalFullSolarPassthrough) {
-                    MessageOutput.println("Power limiter unconditional full solar PT");
-                    _mqttCallbacks.push_back(std::bind(&PowerLimiterClass::setMode,
-                                &PowerLimiter, Mode::UnconditionalFullSolarPassthrough));
-                } else if (mode == Mode::Disabled) {
-                    MessageOutput.println("Power limiter disabled (override)");
-                    _mqttCallbacks.push_back(std::bind(&PowerLimiterClass::setMode,
-                                &PowerLimiter, Mode::Disabled));
-                } else if (mode == Mode::Normal) {
-                    MessageOutput.println("Power limiter normal operation");
-                    _mqttCallbacks.push_back(std::bind(&PowerLimiterClass::setMode,
-                                &PowerLimiter, Mode::Normal));
-                } else {
-                    MessageOutput.printf("PowerLimiter - unknown mode %d\r\n", intValue);
-                }
-                return;
-            }
+            // handled separately above to avoid locking two mutexes
+            break;
         case MqttPowerLimiterCommand::BatterySoCStartThreshold:
             if (config.PowerLimiter.BatterySocStartThreshold == intValue) { return; }
             MessageOutput.printf("Setting battery SoC start threshold to: %d %%\r\n", intValue);
@@ -192,9 +195,9 @@ void MqttHandlePowerLimiterClass::onMqttCmd(MqttPowerLimiterCommand command, con
             config.PowerLimiter.FullSolarPassThroughStopVoltage = payload_val;
             break;
         case MqttPowerLimiterCommand::UpperPowerLimit:
-            if (config.PowerLimiter.UpperPowerLimit == intValue) { return; }
-            MessageOutput.printf("Setting upper power limit to: %d W\r\n", intValue);
-            config.PowerLimiter.UpperPowerLimit = intValue;
+            if (config.PowerLimiter.TotalUpperPowerLimit == intValue) { return; }
+            MessageOutput.printf("Setting total upper power limit to: %d W\r\n", intValue);
+            config.PowerLimiter.TotalUpperPowerLimit = intValue;
             break;
         case MqttPowerLimiterCommand::TargetPowerConsumption:
             if (config.PowerLimiter.TargetPowerConsumption == intValue) { return; }
diff --git a/src/MqttHandlePowerLimiterHass.cpp b/src/MqttHandlePowerLimiterHass.cpp
index e5706cd8..43642f9f 100644
--- a/src/MqttHandlePowerLimiterHass.cpp
+++ b/src/MqttHandlePowerLimiterHass.cpp
@@ -9,6 +9,7 @@
 #include "NetworkSettings.h"
 #include "MessageOutput.h"
 #include "Utils.h"
+#include "PowerLimiter.h"
 #include "__compiled_constants.h"
 
 MqttHandlePowerLimiterHassClass MqttHandlePowerLimiterHass;
@@ -64,7 +65,7 @@ void MqttHandlePowerLimiterHassClass::publishConfig()
 
     publishSelect("DPL Mode", "mdi:gauge", "config", "mode", "mode");
 
-    if (config.PowerLimiter.IsInverterSolarPowered) {
+    if (!PowerLimiter.usesBatteryPoweredInverter()) {
         return;
     }
 
diff --git a/src/MqttHandleVedirect.cpp b/src/MqttHandleVedirect.cpp
index c244afc6..55334df5 100644
--- a/src/MqttHandleVedirect.cpp
+++ b/src/MqttHandleVedirect.cpp
@@ -35,7 +35,7 @@ void MqttHandleVedirectClass::forceUpdate()
 
 void MqttHandleVedirectClass::loop()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     if (!MqttSettings.getConnected() || !config.Vedirect.Enabled) {
         return;
@@ -110,8 +110,10 @@ void MqttHandleVedirectClass::publish_mppt_data(const VeDirectMpptController::da
 
     PUBLISH(productID_PID,           "PID",  currentData.getPidAsString().data());
     PUBLISH(serialNr_SER,            "SER",  currentData.serialNr_SER);
+    PUBLISH(firmwareVer_FW,          "FWI",  currentData.getFwVersionAsInteger());
+    PUBLISH(firmwareVer_FW,          "FWF",  currentData.getFwVersionFormatted());
     PUBLISH(firmwareVer_FW,           "FW",  currentData.firmwareVer_FW);
-    PUBLISH(loadOutputState_LOAD,   "LOAD",  (currentData.loadOutputState_LOAD ? "ON" : "OFF"));
+    PUBLISH(firmwareVer_FWE,         "FWE",  currentData.firmwareVer_FWE);
     PUBLISH(currentState_CS,          "CS",  currentData.getCsAsString().data());
     PUBLISH(errorCode_ERR,           "ERR",  currentData.getErrAsString().data());
     PUBLISH(offReason_OR,             "OR",  currentData.getOrAsString().data());
@@ -136,8 +138,13 @@ void MqttHandleVedirectClass::publish_mppt_data(const VeDirectMpptController::da
         MqttSettings.publish(topic + t, String(val)); \
     }
 
+    PUBLISH_OPT(relayState_RELAY,                         "RELAY",                        currentData.relayState_RELAY.second ? "ON" : "OFF");
+    PUBLISH_OPT(loadOutputState_LOAD,                     "LOAD",                         currentData.loadOutputState_LOAD.second ? "ON" : "OFF");
+    PUBLISH_OPT(loadCurrent_IL_mA,                        "IL",                           currentData.loadCurrent_IL_mA.second / 1000.0);
     PUBLISH_OPT(NetworkTotalDcInputPowerMilliWatts,       "NetworkTotalDcInputPower",     currentData.NetworkTotalDcInputPowerMilliWatts.second / 1000.0);
     PUBLISH_OPT(MpptTemperatureMilliCelsius,              "MpptTemperature",              currentData.MpptTemperatureMilliCelsius.second / 1000.0);
+    PUBLISH_OPT(BatteryAbsorptionMilliVolt,               "BatteryAbsorption",            currentData.BatteryAbsorptionMilliVolt.second / 1000.0);
+    PUBLISH_OPT(BatteryFloatMilliVolt,                    "BatteryFloat",                 currentData.BatteryFloatMilliVolt.second / 1000.0);
     PUBLISH_OPT(SmartBatterySenseTemperatureMilliCelsius, "SmartBatterySenseTemperature", currentData.SmartBatterySenseTemperatureMilliCelsius.second / 1000.0);
 #undef PUBLILSH_OPT
 }
diff --git a/src/MqttHandleVedirectHass.cpp b/src/MqttHandleVedirectHass.cpp
index 883705ad..279c258d 100644
--- a/src/MqttHandleVedirectHass.cpp
+++ b/src/MqttHandleVedirectHass.cpp
@@ -63,9 +63,11 @@ void MqttHandleVedirectHassClass::publishConfig()
         auto optMpptData = VictronMppt.getData(idx);
         if (!optMpptData.has_value()) { continue; }
 
-        publishBinarySensor("MPPT load output state", "mdi:export", "LOAD", "ON", "OFF", *optMpptData);
         publishSensor("MPPT serial number", "mdi:counter", "SER", nullptr, nullptr, nullptr, *optMpptData);
-        publishSensor("MPPT firmware number", "mdi:counter", "FW", nullptr, nullptr, nullptr, *optMpptData);
+        publishSensor("MPPT firmware version integer", "mdi:counter", "FWI", nullptr, nullptr, nullptr, *optMpptData);
+        publishSensor("MPPT firmware version formatted", "mdi:counter", "FWF", nullptr, nullptr, nullptr, *optMpptData);
+        publishSensor("MPPT firmware version FW", "mdi:counter", "FW", nullptr, nullptr, nullptr, *optMpptData);
+        publishSensor("MPPT firmware version FWE", "mdi:counter", "FWE", nullptr, nullptr, nullptr, *optMpptData);
         publishSensor("MPPT state of operation", "mdi:wrench", "CS", nullptr, nullptr, nullptr, *optMpptData);
         publishSensor("MPPT error code", "mdi:bell", "ERR", nullptr, nullptr, nullptr, *optMpptData);
         publishSensor("MPPT off reason", "mdi:wrench", "OR", nullptr, nullptr, nullptr, *optMpptData);
@@ -88,6 +90,17 @@ void MqttHandleVedirectHassClass::publishConfig()
         publishSensor("Panel yield yesterday", NULL, "H22", "energy", "total", "kWh", *optMpptData);
         publishSensor("Panel maximum power yesterday", NULL, "H23", "power", "measurement", "W", *optMpptData);
 
+        // optional info, provided only if the charge controller delivers the information
+        if (optMpptData->relayState_RELAY.first != 0) {
+            publishBinarySensor("MPPT error relay state", "mdi:electric-switch", "RELAY", "ON", "OFF", *optMpptData);
+        }
+        if (optMpptData->loadOutputState_LOAD.first != 0) {
+            publishBinarySensor("MPPT load output state", "mdi:export", "LOAD", "ON", "OFF", *optMpptData);
+        }
+        if (optMpptData->loadCurrent_IL_mA.first != 0) {
+            publishSensor("MPPT load current", NULL, "IL", "current", "measurement", "A", *optMpptData);
+        }
+
         // optional info, provided only if TX is connected to charge controller
         if (optMpptData->NetworkTotalDcInputPowerMilliWatts.first != 0) {
             publishSensor("VE.Smart network total DC input power", "mdi:solar-power", "NetworkTotalDcInputPower", "power", "measurement", "W", *optMpptData);
@@ -95,6 +108,12 @@ void MqttHandleVedirectHassClass::publishConfig()
         if (optMpptData->MpptTemperatureMilliCelsius.first != 0) {
             publishSensor("MPPT temperature", "mdi:temperature-celsius", "MpptTemperature", "temperature", "measurement", "°C", *optMpptData);
         }
+        if (optMpptData->BatteryAbsorptionMilliVolt.first != 0) {
+            publishSensor("Battery absorption voltage", "mdi:battery-charging-90", "BatteryAbsorption", "voltage", "measurement", "V", *optMpptData);
+        }
+        if (optMpptData->BatteryFloatMilliVolt.first != 0) {
+            publishSensor("Battery float voltage", "mdi:battery-charging-100", "BatteryFloat", "voltage", "measurement", "V", *optMpptData);
+        }
         if (optMpptData->SmartBatterySenseTemperatureMilliCelsius.first != 0) {
             publishSensor("Smart Battery Sense temperature", "mdi:temperature-celsius", "SmartBatterySenseTemperature", "temperature", "measurement", "°C", *optMpptData);
         }
diff --git a/src/MqttSettings.cpp b/src/MqttSettings.cpp
index acd2704f..63455f62 100644
--- a/src/MqttSettings.cpp
+++ b/src/MqttSettings.cpp
@@ -92,8 +92,7 @@ void MqttSettingsClass::onMqttDisconnect(espMqttClientTypes::DisconnectReason re
 void MqttSettingsClass::onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, const size_t len, const size_t index, const size_t total)
 {
     if (_verboseLogging) {
-        MessageOutput.print("Received MQTT message on topic: ");
-        MessageOutput.println(topic);
+        MessageOutput.printf("Received MQTT message on topic: %s\r\n", topic);
     }
 
     _mqttSubscribeParser.handle_message(properties, topic, payload, len, index, total);
diff --git a/src/PinMapping.cpp b/src/PinMapping.cpp
index 9f627217..9f6bf159 100644
--- a/src/PinMapping.cpp
+++ b/src/PinMapping.cpp
@@ -4,6 +4,7 @@
  */
 #include "PinMapping.h"
 #include "MessageOutput.h"
+#include "Utils.h"
 #include <ArduinoJson.h>
 #include <LittleFS.h>
 #include <string.h>
@@ -321,6 +322,8 @@ bool PinMappingClass::init(const String& deviceMapping)
         return false;
     }
 
+    Utils::skipBom(f);
+
     JsonDocument doc;
     // Deserialize the JSON document
     DeserializationError error = deserializeJson(doc, f);
diff --git a/src/PowerLimiter.cpp b/src/PowerLimiter.cpp
index c96a5a26..922f2a84 100644
--- a/src/PowerLimiter.cpp
+++ b/src/PowerLimiter.cpp
@@ -3,7 +3,6 @@
  * Copyright (C) 2022 Thomas Basler and others
  */
 
-#include "RestartHelper.h"
 #include "Battery.h"
 #include "PowerMeter.h"
 #include "PowerLimiter.h"
@@ -13,12 +12,24 @@
 #include "Huawei_can.h"
 #include <VictronMppt.h>
 #include "MessageOutput.h"
-#include "inverters/HMS_4CH.h"
 #include <ctime>
 #include <cmath>
+#include <limits>
 #include <frozen/map.h>
 #include "SunPosition.h"
 
+static auto sBatteryPoweredFilter = [](PowerLimiterInverter const& inv) {
+    return !inv.isSolarPowered();
+};
+
+static const char sBatteryPoweredExpression[] = "battery-powered inverters";
+
+static auto sSolarPoweredFilter = [](PowerLimiterInverter const& inv) {
+    return inv.isSolarPowered();
+};
+
+static const char sSolarPoweredExpression[] = "solar-powered inverters";
+
 PowerLimiterClass PowerLimiter;
 
 void PowerLimiterClass::init(Scheduler& scheduler)
@@ -33,25 +44,18 @@ frozen::string const& PowerLimiterClass::getStatusText(PowerLimiterClass::Status
 {
     static const frozen::string missing = "programmer error: missing status text";
 
-    static const frozen::map<Status, frozen::string, 19> texts = {
+    static const frozen::map<Status, frozen::string, 12> texts = {
         { Status::Initializing, "initializing (should not see me)" },
         { Status::DisabledByConfig, "disabled by configuration" },
         { Status::DisabledByMqtt, "disabled by MQTT" },
         { Status::WaitingForValidTimestamp, "waiting for valid date and time to be available" },
         { Status::PowerMeterPending, "waiting for sufficiently recent power meter reading" },
         { Status::InverterInvalid, "invalid inverter selection/configuration" },
-        { Status::InverterChanged, "target inverter changed" },
-        { Status::InverterOffline, "inverter is offline (polling enabled? radio okay?)" },
-        { Status::InverterCommandsDisabled, "inverter configuration prohibits sending commands" },
-        { Status::InverterLimitPending, "waiting for a power limit command to complete" },
-        { Status::InverterPowerCmdPending, "waiting for a start/stop/restart command to complete" },
-        { Status::InverterDevInfoPending, "waiting for inverter device information to be available" },
+        { Status::InverterCmdPending, "waiting for a start/stop/restart/limit command to complete" },
+        { Status::ConfigReload, "reloading DPL configuration" },
         { Status::InverterStatsPending, "waiting for sufficiently recent inverter data" },
-        { Status::CalculatedLimitBelowMinLimit, "calculated limit is less than minimum power limit" },
+        { Status::FullSolarPassthrough, "passing through all solar power (full solar passthrough)" },
         { Status::UnconditionalSolarPassthrough, "unconditionally passing through all solar power (MQTT override)" },
-        { Status::NoVeDirect, "VE.Direct disabled, connection broken, or data outdated" },
-        { Status::NoEnergy, "no energy source available to power the inverter from" },
-        { Status::HuaweiPsu, "DPL stands by while Huawei PSU is enabled/charging" },
         { Status::Stable, "the system is stable, the last power limit is still valid" },
     };
 
@@ -80,25 +84,65 @@ void PowerLimiterClass::announceStatus(PowerLimiterClass::Status status)
 }
 
 /**
- * returns true if the inverter state was changed or is about to change, i.e.,
- * if it is actually in need of a shutdown. returns false otherwise, i.e., the
- * inverter is already shut down.
+ * returns true if the inverters' state was changed or is about to change, i.e.,
+ * if any are actually in need of a shutdown. returns false otherwise, i.e., the
+ * inverters are already shut down.
  */
 bool PowerLimiterClass::shutdown(PowerLimiterClass::Status status)
 {
     announceStatus(status);
 
-    _shutdownPending = true;
+    for (auto& upInv : _inverters) { upInv->standby(); }
 
-    _oTargetPowerState = false;
+    return updateInverters();
+}
 
-    return updateInverter();
+void PowerLimiterClass::reloadConfig()
+{
+    auto const& config = Configuration.get();
+
+    _verboseLogging = config.PowerLimiter.VerboseLogging;
+
+    // clean up all inverter instances. put inverters into
+    // standby if they will not be governed any more.
+    auto iter = _inverters.begin();
+    while (iter != _inverters.end()) {
+        bool stillGoverned = false;
+
+        for (size_t i = 0; i < INV_MAX_COUNT; ++i) {
+            auto const& inv = config.PowerLimiter.Inverters[i];
+            if (inv.Serial == 0ULL) { break; }
+            stillGoverned = inv.Serial == (*iter)->getSerial() && inv.IsGoverned;
+            if (stillGoverned) { break; }
+        }
+
+        if (!stillGoverned) {
+            (*iter)->standby();
+            if ((*iter)->update()) { return; }
+        }
+
+        iter = _inverters.erase(iter);
+    }
+
+    for (size_t i = 0; i < INV_MAX_COUNT; ++i) {
+        auto const& invConfig = config.PowerLimiter.Inverters[i];
+
+        if (invConfig.Serial == 0ULL) { break; }
+
+        if (!invConfig.IsGoverned) { continue; }
+
+        auto upInv = PowerLimiterInverter::create(_verboseLogging, invConfig);
+        if (upInv) { _inverters.push_back(std::move(upInv)); }
+    }
+
+    calcNextInverterRestart();
+
+    _reloadConfigFlag = false;
 }
 
 void PowerLimiterClass::loop()
 {
-    CONFIG_T const& config = Configuration.get();
-    _verboseLogging = config.PowerLimiter.VerboseLogging;
+    auto const& config = Configuration.get();
 
     // we know that the Hoymiles library refuses to send any message to any
     // inverter until the system has valid time information. until then we can
@@ -109,12 +153,9 @@ void PowerLimiterClass::loop()
     }
 
     // take care that the last requested power
-    // limit and power state are actually reached
-    if (updateInverter()) { return; }
-
-    if (_shutdownPending) {
-        _shutdownPending = false;
-        _inverter = nullptr;
+    // limits and power states are actually reached
+    if (updateInverters()) {
+        return announceStatus(Status::InverterCmdPending);
     }
 
     if (!config.PowerLimiter.Enabled) {
@@ -127,72 +168,32 @@ void PowerLimiterClass::loop()
         return;
     }
 
-    std::shared_ptr<InverterAbstract> currentInverter =
-        Hoymiles.getInverterBySerial(config.PowerLimiter.InverterId);
-
-    if (currentInverter == nullptr && config.PowerLimiter.InverterId < INV_MAX_COUNT) {
-        // we previously had an index saved as InverterId. fall back to the
-        // respective positional lookup if InverterId is not a known serial.
-        currentInverter = Hoymiles.getInverterByPos(config.PowerLimiter.InverterId);
+    if (_reloadConfigFlag) {
+        reloadConfig();
+        return announceStatus(Status::ConfigReload);
     }
 
-    // in case of (newly) broken configuration, shut down
-    // the last inverter we worked with (if any)
-    if (currentInverter == nullptr) {
-        shutdown(Status::InverterInvalid);
-        return;
-    }
-
-    // if the DPL is supposed to manage another inverter now, we first
-    // shut down the previous one, if any. then we pick up the new one.
-    if (_inverter != nullptr && _inverter->serial() != currentInverter->serial()) {
-        shutdown(Status::InverterChanged);
-        return;
-    }
-
-    // update our pointer as the configuration might have changed
-    _inverter = currentInverter;
-
-    // data polling is disabled or the inverter is deemed offline
-    if (!_inverter->isReachable()) {
-        return announceStatus(Status::InverterOffline);
-    }
-
-    // sending commands to the inverter is disabled
-    if (!_inverter->getEnableCommands()) {
-        return announceStatus(Status::InverterCommandsDisabled);
-    }
-
-    // a calculated power limit will always be limited to the reported
-    // device's max power. that upper limit is only known after the first
-    // DevInfoSimpleCommand succeeded.
-    if (_inverter->DevInfo()->getMaxPower() <= 0) {
-        return announceStatus(Status::InverterDevInfoPending);
+    if (_inverters.empty()) {
+        return announceStatus(Status::InverterInvalid);
     }
 
     if (Mode::UnconditionalFullSolarPassthrough == _mode) {
-        // handle this mode of operation separately
-        return unconditionalSolarPassthrough(_inverter);
+        return fullSolarPassthrough(Status::UnconditionalSolarPassthrough);
     }
 
-    // concerns both power limits and start/stop/restart commands and is
-    // only updated if a respective response was received from the inverter
-    auto lastUpdateCmd = std::max(
-            _inverter->SystemConfigPara()->getLastUpdateCommand(),
-            _inverter->PowerCommand()->getLastUpdateCommand());
-
-    // we need inverter stats younger than the last update command
-    if (_oInverterStatsMillis.has_value() && lastUpdateCmd > *_oInverterStatsMillis) {
-        _oInverterStatsMillis = std::nullopt;
+    if (isFullSolarPassthroughActive()) {
+        return fullSolarPassthrough(Status::FullSolarPassthrough);
     }
 
-    if (!_oInverterStatsMillis.has_value()) {
-        auto lastStats = _inverter->Statistics()->getLastUpdate();
-        if (lastStats <= lastUpdateCmd) {
+    uint32_t latestInverterStats = 0;
+
+    for (auto const& upInv : _inverters) {
+        auto oStatsMillis = upInv->getLatestStatsMillis();
+        if (!oStatsMillis) {
             return announceStatus(Status::InverterStatsPending);
         }
 
-        _oInverterStatsMillis = lastStats;
+        latestInverterStats = std::max(*oStatsMillis, latestInverterStats);
     }
 
     // if the power meter is being used, i.e., if its data is valid, we want to
@@ -202,13 +203,13 @@ void PowerLimiterClass::loop()
     // arrives. this can be the case for readings provided by networked meter
     // readers, where a packet needs to travel through the network for some
     // time after the actual measurement was done by the reader.
-    if (PowerMeter.isDataValid() && PowerMeter.getLastUpdate() <= (*_oInverterStatsMillis + 2000)) {
+    if (PowerMeter.isDataValid() && PowerMeter.getLastUpdate() <= (latestInverterStats + 2000)) {
         return announceStatus(Status::PowerMeterPending);
     }
 
     // since _lastCalculation and _calculationBackoffMs are initialized to
     // zero, this test is passed the first time the condition is checked.
-    if (millis() < (_lastCalculation + _calculationBackoffMs)) {
+    if ((millis() - _lastCalculation) < _calculationBackoffMs) {
         return announceStatus(Status::Stable);
     }
 
@@ -216,31 +217,27 @@ void PowerLimiterClass::loop()
         MessageOutput.println("[DPL::loop] ******************* ENTER **********************");
     }
 
-    // Check if next inverter restart time is reached
-    if ((_nextInverterRestart > 1) && (_nextInverterRestart <= millis())) {
-        MessageOutput.println("[DPL::loop] send inverter restart");
-        _inverter->sendRestartControlRequest();
-        calcNextInverterRestart();
-    }
+    auto autoRestartInverters = [this]() -> void {
+        if (!_nextInverterRestart.first) { return; } // no automatic restarts
 
-    // Check if NTP time is set and next inverter restart not calculated yet
-    if ((config.PowerLimiter.RestartHour >= 0)  && (_nextInverterRestart == 0) ) {
-        // check every 5 seconds
-        if (_nextCalculateCheck < millis()) {
-            struct tm timeinfo;
-            if (getLocalTime(&timeinfo, 5)) {
-                calcNextInverterRestart();
-            } else {
-                MessageOutput.println("[DPL::loop] inverter restart calculation: NTP not ready");
-                _nextCalculateCheck += 5000;
-            }
+        auto constexpr halfOfAllMillis = std::numeric_limits<uint32_t>::max() / 2;
+        auto diff = _nextInverterRestart.second - millis();
+        if (diff < halfOfAllMillis) { return; }
+
+        MessageOutput.println("[DPL::loop] send inverter restart command");
+        for (auto& upInv : _inverters) {
+            if (!upInv->isSolarPowered()) { upInv->restart(); }
         }
-    }
+
+        calcNextInverterRestart();
+    };
+
+    autoRestartInverters();
 
     auto getBatteryPower = [this,&config]() -> bool {
-        if (config.PowerLimiter.IsInverterSolarPowered) { return false; }
+        if (!usesBatteryPoweredInverter()) { return false; }
 
-        auto isDayPeriod = SunPosition.isSunsetAvailable() ? SunPosition.isDayPeriod() : getSolarPower() > 0;
+        auto isDayPeriod = SunPosition.isSunsetAvailable() ? SunPosition.isDayPeriod() : true;
 
         if (_nighttimeDischarging && isDayPeriod) {
             _nighttimeDischarging = false;
@@ -265,8 +262,8 @@ void PowerLimiterClass::loop()
 
     _batteryDischargeEnabled = getBatteryPower();
 
-    if (_verboseLogging && !config.PowerLimiter.IsInverterSolarPowered) {
-        MessageOutput.printf("[DPL::loop] battery interface %s, SoC: %f %%, StartTH: %d %%, StopTH: %d %%, SoC age: %d s, ignore: %s\r\n",
+    if (_verboseLogging && usesBatteryPoweredInverter()) {
+        MessageOutput.printf("[DPL::loop] battery interface %s, SoC: %.1f %%, StartTH: %d %%, StopTH: %d %%, SoC age: %d s, ignore: %s\r\n",
                 (config.Battery.Enabled?"enabled":"disabled"),
                 Battery.getStats()->getSoC(),
                 config.PowerLimiter.BatterySocStartThreshold,
@@ -287,8 +284,32 @@ void PowerLimiterClass::loop()
                 (config.PowerLimiter.BatteryAlwaysUseAtNight?"yes":"no"));
     };
 
-    // Calculate and set Power Limit (NOTE: might reset _inverter to nullptr!)
-    bool limitUpdated = calcPowerLimit(_inverter, getSolarPower(), getBatteryDischargeLimit(), _batteryDischargeEnabled);
+    // this value is negative if we are exporting power to the grid
+    // from power sources other than DPL-governed inverters.
+    int16_t consumption = calcHouseholdConsumption();
+
+    uint16_t inverterTotalPower = (consumption > 0) ? static_cast<uint16_t>(consumption) : 0;
+
+    auto totalAllowance = config.PowerLimiter.TotalUpperPowerLimit;
+    inverterTotalPower = std::min(inverterTotalPower, totalAllowance);
+
+    auto coveredBySolar = updateInverterLimits(inverterTotalPower, sSolarPoweredFilter, sSolarPoweredExpression);
+    auto remaining = (inverterTotalPower >= coveredBySolar) ? inverterTotalPower - coveredBySolar : 0;
+    auto batteryAllowance = calcBatteryAllowance(remaining);
+    auto coveredByBattery = updateInverterLimits(batteryAllowance, sBatteryPoweredFilter, sBatteryPoweredExpression);
+
+    if (_verboseLogging) {
+        MessageOutput.printf("[DPL::loop] consumption: %d W, "
+                "target output: %u W (limited to %d W), "
+                "solar inverters output: %u W, battery allowance: "
+                "%u W, battery inverters output: %u W\r\n",
+                consumption, inverterTotalPower, totalAllowance,
+                coveredBySolar, batteryAllowance, coveredByBattery);
+    }
+
+    _lastExpectedInverterOutput = coveredBySolar + coveredByBattery;
+
+    bool limitUpdated = updateInverters();
 
     _lastCalculation = millis();
 
@@ -301,6 +322,25 @@ void PowerLimiterClass::loop()
     _calculationBackoffMs = _calculationBackoffMsDefault;
 }
 
+std::pair<float, char const*> PowerLimiterClass::getInverterDcVoltage() {
+    auto const& config = Configuration.get();
+
+    auto iter = _inverters.begin();
+    while(iter != _inverters.end()) {
+        if ((*iter)->getSerial() == config.PowerLimiter.InverterSerialForDcVoltage) {
+            break;
+        }
+        ++iter;
+    }
+
+    if (iter == _inverters.end()) {
+        return { -1.0, "<unknown>" };
+    }
+
+    auto voltage = (*iter)->getDcVoltage(config.PowerLimiter.InverterChannelIdForDcVoltage);
+    return { voltage, (*iter)->getSerialStr() };
+}
+
 /**
  * determines the battery's voltage, trying multiple data providers. the most
  * accurate data is expected to be delivered by a BMS, if it's available. more
@@ -309,16 +349,12 @@ void PowerLimiterClass::loop()
  * the voltage reported by the inverter is used.
  */
 float PowerLimiterClass::getBatteryVoltage(bool log) {
-    if (!_inverter) {
-        // there should be no need to call this method if no target inverter is known
-        MessageOutput.println("[DPL::getBatteryVoltage] no inverter (programmer error)");
-        return 0.0;
-    }
-
     auto const& config = Configuration.get();
-    auto channel = static_cast<ChannelNum_t>(config.PowerLimiter.InverterChannelId);
-    float inverterVoltage = _inverter->Statistics()->getChannelFieldValue(TYPE_DC, channel, FLD_UDC);
-    float res = inverterVoltage;
+
+    float res = 0;
+
+    auto inverter = getInverterDcVoltage();
+    if (inverter.first > 0) { res = inverter.first; }
 
     float chargeControllerVoltage = -1;
     if (VictronMppt.isDataValid()) {
@@ -334,558 +370,289 @@ float PowerLimiterClass::getBatteryVoltage(bool log) {
     }
 
     if (log) {
-        MessageOutput.printf("[DPL::getBatteryVoltage] BMS: %.2f V, MPPT: %.2f V, inverter: %.2f V, returning: %.2fV\r\n",
-                bmsVoltage, chargeControllerVoltage, inverterVoltage, res);
+        MessageOutput.printf("[DPL::getBatteryVoltage] BMS: %.2f V, MPPT: %.2f V, "
+                "inverter %s: %.2f V, returning: %.2fV\r\n", bmsVoltage,
+                chargeControllerVoltage, inverter.second, inverter.first, res);
     }
 
     return res;
 }
 
-static float getInverterEfficiency(std::shared_ptr<InverterAbstract> inverter)
-{
-    float inverterEfficiencyPercent = inverter->Statistics()->getChannelFieldValue(
-        TYPE_INV, CH0, FLD_EFF);
-
-    // fall back to hoymiles peak efficiency as per datasheet if inverter
-    // is currently not producing (efficiency is zero in that case)
-    return  (inverterEfficiencyPercent > 0) ? inverterEfficiencyPercent/100 : 0.967;
-}
-
 /**
  * calculate the AC output power (limit) to set, such that the inverter uses
  * the given power on its DC side, i.e., adjust the power for the inverter's
  * efficiency.
  */
-int32_t PowerLimiterClass::inverterPowerDcToAc(std::shared_ptr<InverterAbstract> inverter, int32_t dcPower)
+uint16_t PowerLimiterClass::solarDcToInverterAc(uint16_t dcPower)
 {
-    CONFIG_T& config = Configuration.get();
-
-    float inverterEfficiencyFactor = getInverterEfficiency(inverter);
-
     // account for losses between solar charger and inverter (cables, junctions...)
+    auto const& config = Configuration.get();
     float lossesFactor = 1.00 - static_cast<float>(config.PowerLimiter.SolarPassThroughLosses)/100;
 
-    return dcPower * inverterEfficiencyFactor * lossesFactor;
+    // we cannot know the efficiency at the new limit. even if we could we
+    // cannot know which inverter is assigned which limit. hence we use a
+    // reasonable, conservative, fixed inverter efficiency.
+    return 0.95 * lossesFactor * dcPower;
 }
 
 /**
- * implements the "unconditional solar passthrough" mode of operation, which
- * can currently only be set using MQTT. in this mode of operation, the
- * inverter shall behave as if it was connected to the solar panels directly,
- * i.e., all solar power (and only solar power) is fed to the AC side,
- * independent from the power meter reading. if the inverter is actually
- * already connected to solar modules rather than a battery, the upper power
- * limit is set as the inverter limit.
+ * implements the "full solar passthrough" mode of operation. in this mode of
+ * operation, the inverters shall behave as if they were connected to the solar
+ * panels directly, i.e., all solar power (and only solar power) is converted
+ * to AC power, independent from the power meter reading.
  */
-void PowerLimiterClass::unconditionalSolarPassthrough(std::shared_ptr<InverterAbstract> inverter)
+void PowerLimiterClass::fullSolarPassthrough(PowerLimiterClass::Status reason)
 {
     if ((millis() - _lastCalculation) < _calculationBackoffMs) { return; }
     _lastCalculation = millis();
 
-    auto const& config = Configuration.get();
-
-    if (config.PowerLimiter.IsInverterSolarPowered) {
-        _calculationBackoffMs = 10 * 1000;
-        setNewPowerLimit(inverter, config.PowerLimiter.UpperPowerLimit);
-        announceStatus(Status::UnconditionalSolarPassthrough);
-        return;
+    for (auto& upInv : _inverters) {
+        if (upInv->isSolarPowered()) { upInv->setMaxOutput(); }
     }
 
-    if (!VictronMppt.isDataValid()) {
-        shutdown(Status::NoVeDirect);
-        return;
+    uint16_t targetOutput = 0;
+
+    if (VictronMppt.isDataValid()) {
+        targetOutput = static_cast<uint16_t>(std::max<int32_t>(0, VictronMppt.getPowerOutputWatts()));
+        targetOutput = solarDcToInverterAc(targetOutput);
     }
 
     _calculationBackoffMs = 1 * 1000;
-    int32_t solarPower = VictronMppt.getPowerOutputWatts();
-    setNewPowerLimit(inverter, inverterPowerDcToAc(inverter, solarPower));
-    announceStatus(Status::UnconditionalSolarPassthrough);
+    updateInverterLimits(targetOutput, sBatteryPoweredFilter, sBatteryPoweredExpression);
+    return announceStatus(reason);
 }
 
-uint8_t PowerLimiterClass::getPowerLimiterState() {
-    if (_inverter == nullptr || !_inverter->isReachable()) {
+uint8_t PowerLimiterClass::getInverterUpdateTimeouts() const
+{
+    uint8_t res = 0;
+    for (auto const& upInv : _inverters) {
+        res += upInv->getUpdateTimeouts();
+    }
+    return res;
+}
+
+uint8_t PowerLimiterClass::getPowerLimiterState()
+{
+    bool reachable = false;
+    bool producing = false;
+    for (auto const& upInv : _inverters) {
+        reachable |= upInv->isReachable();
+        producing |= upInv->isProducing();
+    }
+
+    if (!reachable) {
         return PL_UI_STATE_INACTIVE;
     }
 
-    if (_inverter->isProducing() && _batteryDischargeEnabled) {
-      return PL_UI_STATE_USE_SOLAR_AND_BATTERY;
+    if (!producing) {
+        return PL_UI_STATE_CHARGING;
     }
 
-    if (_inverter->isProducing() && !_batteryDischargeEnabled) {
-      return PL_UI_STATE_USE_SOLAR_ONLY;
-    }
-
-    if(!_inverter->isProducing()) {
-       return PL_UI_STATE_CHARGING;
-    }
-
-    return PL_UI_STATE_INACTIVE;
+    return _batteryDischargeEnabled ? PL_UI_STATE_USE_SOLAR_AND_BATTERY : PL_UI_STATE_USE_SOLAR_ONLY;
 }
 
-// Logic table ("PowerMeter value" can be "base load setting" as a fallback)
-// | Case # | batteryPower | solarPower     | batteryLimit   | useFullSolarPassthrough | Resulting inverter limit                               |
-// | 1      | false        |  < 20 W        | doesn't matter | doesn't matter          | 0 (inverter off)                                       |
-// | 2      | false        | >= 20 W        | doesn't matter | doesn't matter          | min(PowerMeter value, solarPower)                      |
-// | 3      | true         | fully passed   | applied        | false                   | min(PowerMeter value  batteryLimit+solarPower)         |
-// | 4      | true         | fully passed   | doesn't matter | true                    | max(PowerMeter value, solarPower)                      |
-
-bool PowerLimiterClass::calcPowerLimit(std::shared_ptr<InverterAbstract> inverter, int32_t solarPowerDC, int32_t batteryPowerLimitDC, bool batteryPower)
+int16_t PowerLimiterClass::calcHouseholdConsumption()
 {
-    if (_verboseLogging) {
-        MessageOutput.printf("[DPL::calcPowerLimit] battery use %s, solar power (DC): %d W, battery limit (DC): %d W\r\n",
-                (batteryPower?"allowed":"prevented"), solarPowerDC, batteryPowerLimitDC);
-    }
-
-    // Case 1:
-    if (solarPowerDC <= 0 && !batteryPower) {
-        return shutdown(Status::NoEnergy);
-    }
-
-    // We check if the PSU is on and disable the Power Limiter in this case.
-    // The PSU should reduce power or shut down first before the Power Limiter
-    // kicks in. The only case where this is not desired is if the battery is
-    // over the Full Solar Passthrough Threshold. In this case the Power
-    // Limiter should run and the PSU will shut down as a consequence.
-    if (!useFullSolarPassthrough() && HuaweiCan.getAutoPowerStatus()) {
-        return shutdown(Status::HuaweiPsu);
-    }
-
-    auto meterValid = PowerMeter.isDataValid();
-
-    auto meterValue = static_cast<int32_t>(PowerMeter.getPowerTotal());
-
-    // We don't use FLD_PAC from the statistics, because that data might be too
-    // old and unreliable. TODO(schlimmchen): is this comment outdated?
-    auto inverterOutput = static_cast<int32_t>(inverter->Statistics()->getChannelFieldValue(TYPE_AC, CH0, FLD_PAC));
-
-    auto batteryPowerLimitAC = inverterPowerDcToAc(inverter, batteryPowerLimitDC);
-    auto solarPowerAC = inverterPowerDcToAc(inverter, solarPowerDC);
-
     auto const& config = Configuration.get();
     auto targetConsumption = config.PowerLimiter.TargetPowerConsumption;
     auto baseLoad = config.PowerLimiter.BaseLoadLimit;
-    bool meterIncludesInv = config.PowerLimiter.IsInverterBehindPowerMeter;
+
+    auto meterValid = PowerMeter.isDataValid();
+    auto meterValue = PowerMeter.getPowerTotal();
 
     if (_verboseLogging) {
-        MessageOutput.printf("[DPL::calcPowerLimit] target consumption: %d W, "
-                "base load: %d W, power meter does %sinclude inverter output\r\n",
-                targetConsumption,
-                baseLoad,
-                (meterIncludesInv?"":"NOT "));
+        MessageOutput.printf("[DPL::calcHouseholdConsumption] target "
+                "consumption: %d W, base load: %u W\r\n",
+                targetConsumption, baseLoad);
 
-        MessageOutput.printf("[DPL::calcPowerLimit] power meter value: %d W, "
-                "power meter valid: %s, inverter output: %d W, solar power (AC): %d W, battery limit (AC): %d W\r\n",
-                meterValue,
-                (meterValid?"yes":"no"),
-                inverterOutput,
-                solarPowerAC,
-                batteryPowerLimitAC);
+        MessageOutput.printf("[DPL::calcHouseholdConsumption] power meter "
+                "value: %.1f W, power meter valid: %s\r\n",
+                meterValue, (meterValid?"yes":"no"));
     }
 
-    auto newPowerLimit = baseLoad;
+    if (!meterValid) { return baseLoad; }
 
-    if (meterValid) {
-        newPowerLimit = meterValue;
+    auto consumption = static_cast<int16_t>(meterValue + (meterValue > 0 ? 0.5 : -0.5));
 
-        if (meterIncludesInv) {
-            // If the inverter is wired behind the power meter, i.e., if its
-            // output is part of the power meter measurement, the produced
-            // power of this inverter has to be taken into account.
-            newPowerLimit += inverterOutput;
-        }
+    for (auto const& upInv : _inverters) {
+        if (!upInv->isBehindPowerMeter()) { continue; }
 
-        newPowerLimit -= targetConsumption;
-    }
-
-    // Case 2:
-    if (!batteryPower) {
-        newPowerLimit = std::min(newPowerLimit, solarPowerAC);
-
-        // do not drain the battery. use as much power as needed to match the
-        // household consumption, but not more than the available solar power.
+        // If the inverter is wired behind the power meter, i.e., if its
+        // output is part of the power meter measurement, the produced
+        // power of this inverter has to be taken into account.
+        auto invOutput = upInv->getCurrentOutputAcWatts();
+        consumption += invOutput;
         if (_verboseLogging) {
-            MessageOutput.printf("[DPL::calcPowerLimit] limited to solar power: %d W\r\n",
-                newPowerLimit);
+            MessageOutput.printf("[DPL::calcHouseholdConsumption] inverter %s is "
+                    "behind power meter producing %u W\r\n", upInv->getSerialStr(), invOutput);
         }
+    }
 
-        return setNewPowerLimit(inverter, newPowerLimit);
-    } else { // on batteryPower
-        // Apply battery-provided discharge power limit.
-        if (newPowerLimit > batteryPowerLimitAC + solarPowerAC) {
-            newPowerLimit = batteryPowerLimitAC + solarPowerAC;
+    return consumption - targetConsumption;
+}
+
+/**
+ * assigns new limits to all inverters matching the filter. returns the total
+ * amount of power these inverters are expected to produce after the new limits
+ * were applied.
+ */
+uint16_t PowerLimiterClass::updateInverterLimits(uint16_t powerRequested,
+        PowerLimiterClass::inverter_filter_t filter, std::string const& filterExpression)
+{
+    std::vector<PowerLimiterInverter*> matchingInverters;
+    uint16_t producing = 0; // sum of AC power the matching inverters produce now
+
+    for (auto& upInv : _inverters) {
+        if (!filter(*upInv)) { continue; }
+
+        if (!upInv->isReachable()) {
             if (_verboseLogging) {
-                MessageOutput.printf("[DPL::calcPowerLimit] limited by battery to: %d W\r\n",
-                newPowerLimit);
+                MessageOutput.printf("[DPL::updateInverterLimits] skipping %s "
+                        "as it is not reachable\r\n", upInv->getSerialStr());
             }
+            continue;
+        }
+
+        if (!upInv->isSendingCommandsEnabled()) {
+            if (_verboseLogging) {
+                MessageOutput.printf("[DPL::updateInverterLimits] skipping %s "
+                        "as sending commands is disabled\r\n", upInv->getSerialStr());
+            }
+            continue;
+        }
+
+        producing += upInv->getCurrentOutputAcWatts();
+        matchingInverters.push_back(upInv.get());
+    }
+
+    int32_t diff = powerRequested - producing;
+
+    auto const& config = Configuration.get();
+    uint16_t hysteresis = config.PowerLimiter.TargetPowerConsumptionHysteresis;
+
+    if (_verboseLogging) {
+        MessageOutput.printf("[DPL::updateInverterLimits] requested: %d W, "
+                "producing: %d W using %d %s, diff: %i W, hysteresis: %d W\r\n",
+                powerRequested, producing, matchingInverters.size(),
+                filterExpression.c_str(), diff, hysteresis);
+    }
+
+    if (matchingInverters.empty()) { return 0; }
+
+    if (std::abs(diff) < static_cast<int32_t>(hysteresis)) { return producing; }
+
+    uint16_t covered = 0;
+
+    if (diff < 0) {
+        uint16_t reduction = static_cast<uint16_t>(diff * -1);
+
+        uint16_t totalMaxReduction = 0;
+        for (auto const pInv : matchingInverters) {
+            totalMaxReduction += pInv->getMaxReductionWatts(false/*no standby*/);
+        }
+
+        // test whether we need to put at least one of the inverters into
+        // standby to achieve the requested reduction.
+        bool allowStandby = (totalMaxReduction < reduction);
+
+        std::sort(matchingInverters.begin(), matchingInverters.end(),
+                [allowStandby](auto const a, auto const b) {
+                    auto aReduction = a->getMaxReductionWatts(allowStandby);
+                    auto bReduction = b->getMaxReductionWatts(allowStandby);
+                    return aReduction > bReduction;
+                });
+
+        for (auto pInv : matchingInverters) {
+            auto maxReduction = pInv->getMaxReductionWatts(allowStandby);
+            if (reduction >= hysteresis && maxReduction >= hysteresis) {
+                reduction -= pInv->applyReduction(reduction, allowStandby);
+            }
+            covered += pInv->getExpectedOutputAcWatts();
+        }
+    }
+    else {
+        uint16_t increase = static_cast<uint16_t>(diff);
+
+        std::sort(matchingInverters.begin(), matchingInverters.end(),
+                [](auto const a, auto const b) {
+                    return a->getMaxIncreaseWatts() > b->getMaxIncreaseWatts();
+                });
+
+        for (auto pInv : matchingInverters) {
+            auto maxIncrease = pInv->getMaxIncreaseWatts();
+            if (increase >= hysteresis && maxIncrease >= hysteresis) {
+                increase -= pInv->applyIncrease(increase);
+            }
+            covered += pInv->getExpectedOutputAcWatts();
         }
     }
 
-    // Case 4:
-    // convert all solar power if full solar-passthrough is active
-    if (useFullSolarPassthrough()) {
-        newPowerLimit = std::max(newPowerLimit, solarPowerAC);
+    if (_verboseLogging) {
+        MessageOutput.printf("[DPL::updateInverterLimits] will cover %d W using "
+                "%s\r\n", covered, filterExpression.c_str());
+        for (auto pInv : matchingInverters) { pInv->debug(); }
+    }
+
+    return covered;
+}
+
+uint16_t PowerLimiterClass::calcBatteryAllowance(uint16_t powerRequested)
+{
+    if (_verboseLogging) {
+        MessageOutput.printf("[DPL::calcBatteryAllowance] power requested: %d W\r\n",
+                powerRequested);
+    }
+
+    // We check if the PSU is on and disable battery-powered inverters in this
+    // case. The PSU should reduce power or shut down first before the
+    // battery-powered inverters kick in. The only case where this is not
+    // desired is if the battery is over the Full Solar Passthrough Threshold.
+    // In this case battery-powered inverters should produce power and the PSU
+    // will shut down as a consequence.
+    if (!isFullSolarPassthroughActive() && HuaweiCan.getAutoPowerStatus()) {
+        if (_verboseLogging) {
+            MessageOutput.println("[DPL::calcBatteryAllowance] disabled "
+                    "by HuaweiCan auto power");
+        }
+        return 0;
+    }
+
+    auto oBatteryPowerDc = getBatteryDischargeLimit();
+    if (!oBatteryPowerDc.has_value()) { return powerRequested; }
+
+    auto batteryPowerAC = solarDcToInverterAc(*oBatteryPowerDc);
+    auto solarPowerAC = solarDcToInverterAc(getSolarPassthroughPower());
+
+    if (powerRequested > batteryPowerAC + solarPowerAC) {
+        // respect battery-provided discharge power limit
+        auto res = batteryPowerAC + solarPowerAC;
 
         if (_verboseLogging) {
-            MessageOutput.printf("[DPL::calcPowerLimit] full solar-passthrough active: %d W\r\n",
-                newPowerLimit);
+            MessageOutput.printf("[DPL::calcBatteryAllowance] limited by "
+                    "battery (%d W) and/or solar power (%d W): %d W\r\n",
+                    batteryPowerAC, solarPowerAC, res);
         }
 
-        return setNewPowerLimit(inverter, newPowerLimit);
+        return res;
     }
 
-    if (_verboseLogging) {
-        MessageOutput.printf("[DPL::calcPowerLimit] match household consumption with limit of %d W\r\n",
-            newPowerLimit);
-    }
-
-    // Case 3:
-    return setNewPowerLimit(inverter, newPowerLimit);
+    return powerRequested;
 }
 
-/**
- * updates the inverter state (power production and limit). returns true if a
- * change to its state was requested or is pending. this function only requests
- * one change (limit value or production on/off) at a time.
- */
-bool PowerLimiterClass::updateInverter()
+bool PowerLimiterClass::updateInverters()
 {
-    auto reset = [this]() -> bool {
-        _oTargetPowerState = std::nullopt;
-        _oTargetPowerLimitWatts = std::nullopt;
-        _oUpdateStartMillis = std::nullopt;
-        return false;
-    };
+    bool busy = false;
 
-    if (nullptr == _inverter) { return reset(); }
-
-    // do not reset _inverterUpdateTimeouts below if no state change requested
-    if (!_oTargetPowerState.has_value() && !_oTargetPowerLimitWatts.has_value()) {
-        return reset();
+    for (auto& upInv : _inverters) {
+        if (upInv->update()) { busy = true; }
     }
 
-    if (!_oUpdateStartMillis.has_value()) {
-        _oUpdateStartMillis = millis();
-    }
-
-    if ((millis() - *_oUpdateStartMillis) > 30 * 1000) {
-        ++_inverterUpdateTimeouts;
-        MessageOutput.printf("[DPL::updateInverter] timeout (%d in succession), "
-                "state transition pending: %s, limit pending: %s\r\n",
-                _inverterUpdateTimeouts,
-                (_oTargetPowerState.has_value()?"yes":"no"),
-                (_oTargetPowerLimitWatts.has_value()?"yes":"no"));
-
-        // NOTE that this is not always 5 minutes, since this counts timeouts,
-        // not absolute time. after any timeout, an update cycle ends. a new
-        // timeout can only happen after starting a new update cycle, which in
-        // turn is only started if the DPL did calculate a new limit, which in
-        // turn does not happen while the inverter is unreachable, no matter
-        // how long (a whole night) that might be.
-        if (_inverterUpdateTimeouts >= 10) {
-            MessageOutput.println("[DPL::loop] issuing inverter restart command after update timed out repeatedly");
-            _inverter->sendRestartControlRequest();
-        }
-
-        if (_inverterUpdateTimeouts >= 20) {
-            MessageOutput.println("[DPL::loop] restarting system since inverter is unresponsive");
-            RestartHelper.triggerRestart();
-        }
-
-        return reset();
-    }
-
-    auto constexpr halfOfAllMillis = std::numeric_limits<uint32_t>::max() / 2;
-
-    auto switchPowerState = [this](bool transitionOn) -> bool {
-        // no power state transition requested at all
-        if (!_oTargetPowerState.has_value()) { return false; }
-
-        // the transition that may be started is not the one which is requested
-        if (transitionOn != *_oTargetPowerState) { return false; }
-
-        // wait for pending power command(s) to complete
-        auto lastPowerCommandState = _inverter->PowerCommand()->getLastPowerCommandSuccess();
-        if (CMD_PENDING == lastPowerCommandState) {
-            announceStatus(Status::InverterPowerCmdPending);
-            return true;
-        }
-
-        // we need to wait for statistics that are more recent than the last
-        // power update command to reliably use _inverter->isProducing()
-        auto lastPowerCommandMillis = _inverter->PowerCommand()->getLastUpdateCommand();
-        auto lastStatisticsMillis = _inverter->Statistics()->getLastUpdate();
-        if ((lastStatisticsMillis - lastPowerCommandMillis) > halfOfAllMillis) { return true; }
-
-        if (_inverter->isProducing() != *_oTargetPowerState) {
-            MessageOutput.printf("[DPL::updateInverter] %s inverter...\r\n",
-                    ((*_oTargetPowerState)?"Starting":"Stopping"));
-            _inverter->sendPowerControlRequest(*_oTargetPowerState);
-            return true;
-        }
-
-        _oTargetPowerState = std::nullopt; // target power state reached
-        return false;
-    };
-
-    // we use a lambda function here to be able to use return statements,
-    // which allows to avoid if-else-indentions and improves code readability
-    auto updateLimit = [this]() -> bool {
-        // no limit update requested at all
-        if (!_oTargetPowerLimitWatts.has_value()) { return false; }
-
-        // wait for pending limit command(s) to complete
-        auto lastLimitCommandState = _inverter->SystemConfigPara()->getLastLimitCommandSuccess();
-        if (CMD_PENDING == lastLimitCommandState) {
-            announceStatus(Status::InverterLimitPending);
-            return true;
-        }
-
-        auto maxPower = _inverter->DevInfo()->getMaxPower();
-        auto newRelativeLimit = static_cast<float>(*_oTargetPowerLimitWatts * 100) / maxPower;
-
-        // if no limit command is pending, the SystemConfigPara does report the
-        // current limit, as the answer by the inverter to a limit command is
-        // the canonical source that updates the known current limit.
-        auto currentRelativeLimit = _inverter->SystemConfigPara()->getLimitPercent();
-
-        // we assume having exclusive control over the inverter. if the last
-        // limit command was successful and sent after we started the last
-        // update cycle, we should assume *our* requested limit was set.
-        uint32_t lastLimitCommandMillis = _inverter->SystemConfigPara()->getLastUpdateCommand();
-        if ((lastLimitCommandMillis - *_oUpdateStartMillis) < halfOfAllMillis &&
-                CMD_OK == lastLimitCommandState) {
-            MessageOutput.printf("[DPL::updateInverter] actual limit is %.1f %% "
-                    "(%.0f W respectively), effective %d ms after update started, "
-                    "requested were %.1f %%\r\n",
-                    currentRelativeLimit,
-                    (currentRelativeLimit * maxPower / 100),
-                    (lastLimitCommandMillis - *_oUpdateStartMillis),
-                    newRelativeLimit);
-
-            if (std::abs(newRelativeLimit - currentRelativeLimit) > 2.0) {
-                MessageOutput.printf("[DPL::updateInverter] NOTE: expected limit of %.1f %% "
-                        "and actual limit of %.1f %% mismatch by more than 2 %%, "
-                        "is the DPL in exclusive control over the inverter?\r\n",
-                        newRelativeLimit, currentRelativeLimit);
-            }
-
-            _oTargetPowerLimitWatts = std::nullopt;
-            return false;
-        }
-
-        MessageOutput.printf("[DPL::updateInverter] sending limit of %.1f %% "
-                "(%.0f W respectively), max output is %d W\r\n",
-                newRelativeLimit, (newRelativeLimit * maxPower / 100), maxPower);
-
-        _inverter->sendActivePowerControlRequest(static_cast<float>(newRelativeLimit),
-                PowerLimitControlType::RelativNonPersistent);
-
-        _lastRequestedPowerLimit = *_oTargetPowerLimitWatts;
-        return true;
-    };
-
-    // disable power production as soon as possible.
-    // setting the power limit is less important once the inverter is off.
-    if (switchPowerState(false)) { return true; }
-
-    if (updateLimit()) { return true; }
-
-    // enable power production only after setting the desired limit
-    if (switchPowerState(true)) { return true; }
-
-    _inverterUpdateTimeouts = 0;
-
-    return reset();
+    return busy;
 }
 
-/**
- * scale the desired inverter limit such that the actual inverter AC output is
- * close to the desired power limit, even if some input channels are producing
- * less than the limit allows. this happens because the inverter seems to split
- * the total power limit equally among all MPPTs (not inputs; some inputs share
- * the same MPPT on some models).
- *
- * TODO(schlimmchen): the current implementation is broken and is in need of
- * refactoring. currently it only works for inverters that provide one MPPT for
- * each input.
- */
-static int32_t scalePowerLimit(std::shared_ptr<InverterAbstract> inverter, int32_t newLimit, int32_t currentLimitWatts, bool log)
-{
-    // prevent scaling if inverter is not producing, as input channels are not
-    // producing energy and hence are detected as not-producing, causing
-    // unreasonable scaling.
-    if (!inverter->isProducing()) { return newLimit; }
-
-    std::list<ChannelNum_t> dcChnls = inverter->Statistics()->getChannelsByType(TYPE_DC);
-    size_t dcTotalChnls = dcChnls.size();
-
-    // according to the upstream projects README (table with supported devs),
-    // every 2 channel inverter has 2 MPPTs. then there are the HM*S* 4 channel
-    // models which have 4 MPPTs. all others have a different number of MPPTs
-    // than inputs. those are not supported by the current scaling mechanism.
-    bool supported = dcTotalChnls == 2;
-    supported |= dcTotalChnls == 4 && HMS_4CH::isValidSerial(inverter->serial());
-    if (!supported) { return newLimit; }
-
-    // test for a reasonable power limit that allows us to assume that an input
-    // channel with little energy is actually not producing, rather than
-    // producing very little due to the very low limit.
-    if (currentLimitWatts < dcTotalChnls * 10) { return newLimit; }
-
-    auto const& config = Configuration.get();
-    auto allowOverscaling = config.PowerLimiter.UseOverscalingToCompensateShading;
-    auto isInverterSolarPowered = config.PowerLimiter.IsInverterSolarPowered;
-
-    // overscalling allows us to compensate for shaded panels by increasing the
-    // total power limit, if the inverter is solar powered.
-    if (allowOverscaling && isInverterSolarPowered) {
-        auto inverterOutputAC = inverter->Statistics()->getChannelFieldValue(TYPE_AC, CH0, FLD_PAC);
-        float inverterEfficiencyFactor = getInverterEfficiency(inverter);
-
-        // 98% of the expected power is good enough
-        auto expectedAcPowerPerChannel = (currentLimitWatts / dcTotalChnls) * 0.98;
-
-        if (log) {
-            MessageOutput.printf("[DPL::scalePowerLimit] expected AC power per channel %f W\r\n",
-                    expectedAcPowerPerChannel);
-        }
-
-        size_t dcShadedChnls = 0;
-        auto shadedChannelACPowerSum = 0.0;
-
-        for (auto& c : dcChnls) {
-            auto channelPowerAC = inverter->Statistics()->getChannelFieldValue(TYPE_DC, c, FLD_PDC) * inverterEfficiencyFactor;
-
-            if (channelPowerAC < expectedAcPowerPerChannel) {
-                dcShadedChnls++;
-                shadedChannelACPowerSum += channelPowerAC;
-            }
-
-            if (log) {
-                MessageOutput.printf("[DPL::scalePowerLimit] ch %d AC power %f W\r\n",
-                        c, channelPowerAC);
-            }
-        }
-
-        // no shading or the shaded channels provide more power than what
-        // we currently need.
-        if (dcShadedChnls == 0 || shadedChannelACPowerSum >= newLimit) { return newLimit; }
-
-        if (dcShadedChnls == dcTotalChnls) {
-            // keep the currentLimit when:
-            // - all channels are shaded
-            // - currentLimit >= newLimit
-            // - we get the expected AC power or less and
-            if (currentLimitWatts >= newLimit && inverterOutputAC <= newLimit) {
-                if (log) {
-                    MessageOutput.printf("[DPL::scalePowerLimit] all channels are shaded, "
-                            "keeping the current limit of %d W\r\n", currentLimitWatts);
-                }
-
-                return currentLimitWatts;
-
-            } else {
-                return newLimit;
-            }
-        }
-
-        size_t dcNonShadedChnls = dcTotalChnls - dcShadedChnls;
-        auto overScaledLimit = static_cast<int32_t>((newLimit - shadedChannelACPowerSum) / dcNonShadedChnls * dcTotalChnls);
-
-        if (overScaledLimit <= newLimit) { return newLimit; }
-
-        if (log) {
-            MessageOutput.printf("[DPL::scalePowerLimit] %d/%d channels are shaded, "
-                    "scaling %d W\r\n", dcShadedChnls, dcTotalChnls, overScaledLimit);
-        }
-
-        return overScaledLimit;
-    }
-
-    size_t dcProdChnls = 0;
-    for (auto& c : dcChnls) {
-        if (inverter->Statistics()->getChannelFieldValue(TYPE_DC, c, FLD_PDC) > 2.0) {
-            dcProdChnls++;
-        }
-    }
-
-    if (dcProdChnls == 0 || dcProdChnls == dcTotalChnls) { return newLimit; }
-
-    auto scaled = static_cast<int32_t>(newLimit * static_cast<float>(dcTotalChnls) / dcProdChnls);
-    MessageOutput.printf("[DPL::scalePowerLimit] %d/%d channels are producing, "
-            "scaling from %d to %d W\r\n", dcProdChnls, dcTotalChnls, newLimit, scaled);
-    return scaled;
-}
-
-/**
- * enforces limits on the requested power limit, after scaling the power limit
- * to the ratio of total and producing inverter channels. commits the sanitized
- * power limit. returns true if an inverter update was committed, false
- * otherwise.
- */
-bool PowerLimiterClass::setNewPowerLimit(std::shared_ptr<InverterAbstract> inverter, int32_t newPowerLimit)
+uint16_t PowerLimiterClass::getSolarPassthroughPower()
 {
     auto const& config = Configuration.get();
-    auto lowerLimit = config.PowerLimiter.LowerPowerLimit;
-    auto upperLimit = config.PowerLimiter.UpperPowerLimit;
-    auto hysteresis = config.PowerLimiter.TargetPowerConsumptionHysteresis;
-
-    if (_verboseLogging) {
-        MessageOutput.printf("[DPL::setNewPowerLimit] input limit: %d W, "
-                "min limit: %d W, max limit: %d W, hysteresis: %d W\r\n",
-                newPowerLimit, lowerLimit, upperLimit, hysteresis);
-    }
-
-    if (newPowerLimit < lowerLimit) {
-        if (!config.PowerLimiter.IsInverterSolarPowered) {
-            return shutdown(Status::CalculatedLimitBelowMinLimit);
-        }
-
-        MessageOutput.println("[DPL::setNewPowerLimit] keep solar-powered "
-                "inverter running at min limit");
-        newPowerLimit = lowerLimit;
-    }
-
-    // enforce configured upper power limit
-    int32_t effPowerLimit = std::min(newPowerLimit, upperLimit);
-
-    // early in the loop we make it a pre-requisite that this
-    // value is non-zero, so we can assume it to be valid.
-    auto maxPower = inverter->DevInfo()->getMaxPower();
-
-    float currentLimitPercent = inverter->SystemConfigPara()->getLimitPercent();
-    auto currentLimitAbs = static_cast<int32_t>(currentLimitPercent * maxPower / 100);
-
-    effPowerLimit = scalePowerLimit(inverter, effPowerLimit, currentLimitAbs, _verboseLogging);
-
-    effPowerLimit = std::min<int32_t>(effPowerLimit, maxPower);
-
-    auto diff = std::abs(currentLimitAbs - effPowerLimit);
-
-    if (_verboseLogging) {
-        MessageOutput.printf("[DPL::setNewPowerLimit] inverter max: %d W, "
-                "inverter %s producing, requesting: %d W, reported: %d W, "
-                "diff: %d W\r\n", maxPower, (inverter->isProducing()?"is":"is NOT"),
-                effPowerLimit, currentLimitAbs, diff);
-    }
-
-    if (diff > hysteresis) {
-        _oTargetPowerLimitWatts = effPowerLimit;
-    }
-
-    _oTargetPowerState = true;
-    return updateInverter();
-}
-
-int32_t PowerLimiterClass::getSolarPower()
-{
-    auto const& config = Configuration.get();
-
-    if (config.PowerLimiter.IsInverterSolarPowered) {
-        // the returned value is arbitrary, as long as it's
-        // greater than the inverters max DC power consumption.
-        return 10 * 1000;
-    }
 
     if (!config.PowerLimiter.SolarPassThroughEnabled
             || isBelowStopThreshold()
@@ -893,43 +660,53 @@ int32_t PowerLimiterClass::getSolarPower()
         return 0;
     }
 
-    auto solarPower = VictronMppt.getPowerOutputWatts();
-    if (solarPower < 20) { return 0; } // too little to work with
-
-    return solarPower;
+    return VictronMppt.getPowerOutputWatts();
 }
 
-int32_t PowerLimiterClass::getBatteryDischargeLimit()
+float PowerLimiterClass::getBatteryInvertersOutputAcWatts()
 {
-    auto currentLimit = Battery.getDischargeCurrentLimit();
+    float res = 0;
 
-    if (currentLimit == FLT_MAX) {
-        // the returned value is arbitrary, as long as it's
-        // greater than the inverters max DC power consumption.
-        return 10 * 1000;
+    for (auto const& upInv : _inverters) {
+        if (upInv->isSolarPowered()) { continue; }
+        // TODO(schlimmchen): we must use the DC power instead, as the battery
+        // voltage drops proportional to the DC current draw, but the AC power
+        // output does not correlate with the battery current or voltage.
+        res += upInv->getCurrentOutputAcWatts();
     }
 
-    // This uses inverter voltage since there is a voltage drop between
+    return res;
+}
+
+std::optional<uint16_t> PowerLimiterClass::getBatteryDischargeLimit()
+{
+    if (!_batteryDischargeEnabled) { return 0; }
+
+    auto currentLimit = Battery.getDischargeCurrentLimit();
+    if (currentLimit == FLT_MAX) { return std::nullopt; }
+
+    if (currentLimit <= 0) { currentLimit = -currentLimit; }
+
+    // this uses inverter voltage since there is a voltage drop between
     // battery and inverter, so since we are regulating the inverter
     // power we should use its voltage.
-    auto const& config = Configuration.get();
-    auto channel = static_cast<ChannelNum_t>(config.PowerLimiter.InverterChannelId);
-    float inverterVoltage = _inverter->Statistics()->getChannelFieldValue(TYPE_DC, channel, FLD_UDC);
+    auto inverter = getInverterDcVoltage();
+    if (inverter.first <= 0) {
+        MessageOutput.println("[DPL::getBatteryDischargeLimit]: could not "
+                "determine inverter voltage");
+        return 0;
+    }
 
-    return static_cast<int32_t>(inverterVoltage * currentLimit);
+    return inverter.first * currentLimit;
 }
 
 float PowerLimiterClass::getLoadCorrectedVoltage()
 {
-    if (!_inverter) {
-        // there should be no need to call this method if no target inverter is known
-        MessageOutput.println("[DPL::getLoadCorrectedVoltage] no inverter (programmer error)");
-        return 0.0;
-    }
+    auto const& config = Configuration.get();
 
-    CONFIG_T& config = Configuration.get();
-
-    float acPower = _inverter->Statistics()->getChannelFieldValue(TYPE_AC, CH0, FLD_PAC);
+    // TODO(schlimmchen): use the battery's data if available,
+    // i.e., the current drawn from the battery as reported by the battery.
+    float acPower = getBatteryInvertersOutputAcWatts();
     float dcVoltage = getBatteryVoltage();
 
     if (dcVoltage <= 0.0) {
@@ -942,7 +719,7 @@ float PowerLimiterClass::getLoadCorrectedVoltage()
 bool PowerLimiterClass::testThreshold(float socThreshold, float voltThreshold,
         std::function<bool(float, float)> compare)
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     // prefer SoC provided through battery interface, unless disabled by user
     auto stats = Battery.getStats();
@@ -962,7 +739,7 @@ bool PowerLimiterClass::testThreshold(float socThreshold, float voltThreshold,
 
 bool PowerLimiterClass::isStartThresholdReached()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     return testThreshold(
             config.PowerLimiter.BatterySocStartThreshold,
@@ -973,7 +750,7 @@ bool PowerLimiterClass::isStartThresholdReached()
 
 bool PowerLimiterClass::isStopThresholdReached()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     return testThreshold(
             config.PowerLimiter.BatterySocStopThreshold,
@@ -984,7 +761,7 @@ bool PowerLimiterClass::isStopThresholdReached()
 
 bool PowerLimiterClass::isBelowStopThreshold()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     return testThreshold(
             config.PowerLimiter.BatterySocStopThreshold,
@@ -993,58 +770,59 @@ bool PowerLimiterClass::isBelowStopThreshold()
     );
 }
 
-/// @brief calculate next inverter restart in millis
 void PowerLimiterClass::calcNextInverterRestart()
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
-    // first check if restart is configured at all
     if (config.PowerLimiter.RestartHour < 0) {
-        _nextInverterRestart = 1;
-        MessageOutput.println("[DPL::calcNextInverterRestart] _nextInverterRestart disabled");
+        _nextInverterRestart = { false, 0 };
+        MessageOutput.println("[DPL::calcNextInverterRestart] automatic inverter restart disabled");
         return;
     }
 
-    if (config.PowerLimiter.IsInverterSolarPowered) {
-        _nextInverterRestart = 1;
-        MessageOutput.println("[DPL::calcNextInverterRestart] not restarting solar-powered inverters");
-        return;
-    }
-
-    // read time from timeserver, if time is not synced then return
     struct tm timeinfo;
-    if (getLocalTime(&timeinfo, 5)) {
-        // calculation first step is offset to next restart in minutes
-        uint16_t dayMinutes = timeinfo.tm_hour * 60 + timeinfo.tm_min;
-        uint16_t targetMinutes = config.PowerLimiter.RestartHour * 60;
-        if (config.PowerLimiter.RestartHour > timeinfo.tm_hour) {
-            // next restart is on the same day
-            _nextInverterRestart = targetMinutes - dayMinutes;
-        } else {
-            // next restart is on next day
-            _nextInverterRestart = 1440 - dayMinutes + targetMinutes;
-        }
-        if (_verboseLogging) {
-            MessageOutput.printf("[DPL::calcNextInverterRestart] Localtime read %d %d / configured RestartHour %d\r\n", timeinfo.tm_hour, timeinfo.tm_min, config.PowerLimiter.RestartHour);
-            MessageOutput.printf("[DPL::calcNextInverterRestart] dayMinutes %d / targetMinutes %d\r\n", dayMinutes, targetMinutes);
-            MessageOutput.printf("[DPL::calcNextInverterRestart] next inverter restart in %d minutes\r\n", _nextInverterRestart);
-        }
-        // then convert unit for next restart to milliseconds and add current uptime millis()
-        _nextInverterRestart *= 60000;
-        _nextInverterRestart += millis();
+    getLocalTime(&timeinfo, 5); // always succeeds as we call this method only
+                                // from the DPL loop *after* we already made
+                                // sure that time information is available.
+
+    // calculation first step is offset to next restart in minutes
+    uint16_t dayMinutes = timeinfo.tm_hour * 60 + timeinfo.tm_min;
+    uint16_t targetMinutes = config.PowerLimiter.RestartHour * 60;
+    uint32_t restartMillis = 0;
+    if (config.PowerLimiter.RestartHour > timeinfo.tm_hour) {
+        // next restart is on the same day
+        restartMillis = targetMinutes - dayMinutes;
     } else {
-        MessageOutput.println("[DPL::calcNextInverterRestart] getLocalTime not successful, no calculation");
-        _nextInverterRestart = 0;
+        // next restart is on next day
+        restartMillis = 1440 - dayMinutes + targetMinutes;
     }
-    MessageOutput.printf("[DPL::calcNextInverterRestart] _nextInverterRestart @ %d millis\r\n", _nextInverterRestart);
+
+    if (_verboseLogging) {
+        MessageOutput.printf("[DPL::calcNextInverterRestart] Localtime "
+                "read %02d:%02d / configured RestartHour %d\r\n", timeinfo.tm_hour,
+                timeinfo.tm_min, config.PowerLimiter.RestartHour);
+        MessageOutput.printf("[DPL::calcNextInverterRestart] dayMinutes %d / "
+                "targetMinutes %d\r\n", dayMinutes, targetMinutes);
+        MessageOutput.printf("[DPL::calcNextInverterRestart] next inverter "
+                "restart in %d minutes\r\n", restartMillis);
+    }
+
+    // convert unit for next restart to milliseconds and add current uptime
+    restartMillis *= 60000;
+    restartMillis += millis();
+
+    MessageOutput.printf("[DPL::calcNextInverterRestart] next inverter "
+            "restart @ %d millis\r\n", restartMillis);
+
+    _nextInverterRestart = { true, restartMillis };
 }
 
-bool PowerLimiterClass::useFullSolarPassthrough()
+bool PowerLimiterClass::isFullSolarPassthroughActive()
 {
     auto const& config = Configuration.get();
 
     // solar passthrough only applies to setups with battery-powered inverters
-    if (config.PowerLimiter.IsInverterSolarPowered) { return false; }
+    if (!usesBatteryPoweredInverter()) { return false; }
 
     // We only do full solar PT if general solar PT is enabled
     if(!config.PowerLimiter.SolarPassThroughEnabled) { return false; }
@@ -1063,3 +841,20 @@ bool PowerLimiterClass::useFullSolarPassthrough()
 
     return _fullSolarPassThroughEnabled;
 }
+
+bool PowerLimiterClass::usesBatteryPoweredInverter()
+{
+    for (auto const& upInv : _inverters) {
+        if (!upInv->isSolarPowered()) { return true; }
+    }
+
+    return false;
+}
+
+bool PowerLimiterClass::isGovernedInverterProducing()
+{
+    for (auto const& upInv : _inverters) {
+        if (upInv->isProducing()) { return true; }
+    }
+    return false;
+}
diff --git a/src/PowerLimiterBatteryInverter.cpp b/src/PowerLimiterBatteryInverter.cpp
new file mode 100644
index 00000000..f4eaf1a6
--- /dev/null
+++ b/src/PowerLimiterBatteryInverter.cpp
@@ -0,0 +1,104 @@
+#include "PowerLimiterBatteryInverter.h"
+
+PowerLimiterBatteryInverter::PowerLimiterBatteryInverter(bool verboseLogging, PowerLimiterInverterConfig const& config)
+    : PowerLimiterInverter(verboseLogging, config) { }
+
+uint16_t PowerLimiterBatteryInverter::getMaxReductionWatts(bool allowStandby) const
+{
+    if (!isEligible()) { return 0; }
+
+    if (!isProducing()) { return 0; }
+
+    if (allowStandby) { return getCurrentOutputAcWatts(); }
+
+    if (getCurrentOutputAcWatts() <= _config.LowerPowerLimit) { return 0; }
+
+    return getCurrentOutputAcWatts() - _config.LowerPowerLimit;
+}
+
+uint16_t PowerLimiterBatteryInverter::getMaxIncreaseWatts() const
+{
+    if (!isEligible()) { return 0; }
+
+    if (!isProducing()) {
+        return getConfiguredMaxPowerWatts();
+    }
+
+    // this should not happen for battery-powered inverters, but we want to
+    // be robust in case something else set a limit on the inverter (or in
+    // case we did something wrong...).
+    if (getCurrentLimitWatts() >= getConfiguredMaxPowerWatts()) { return 0; }
+
+    // we must not substract the current AC output here, but the current
+    // limit value, so we avoid trying to produce even more even if the
+    // inverter is already at the maximum limit value (the actual AC
+    // output may be less than the inverter's current power limit).
+    return getConfiguredMaxPowerWatts() - getCurrentLimitWatts();
+}
+
+uint16_t PowerLimiterBatteryInverter::applyReduction(uint16_t reduction, bool allowStandby)
+{
+    if (!isEligible()) { return 0; }
+
+    if (reduction == 0) { return 0; }
+
+    auto low = std::min(getCurrentLimitWatts(), getCurrentOutputAcWatts());
+    if (low <= _config.LowerPowerLimit) {
+        if (allowStandby) {
+            standby();
+            return std::min(reduction, getCurrentOutputAcWatts());
+        }
+        return 0;
+    }
+
+    if ((getCurrentLimitWatts() - _config.LowerPowerLimit) >= reduction) {
+        setAcOutput(getCurrentLimitWatts() - reduction);
+        return reduction;
+    }
+
+    if (allowStandby) {
+        standby();
+        return std::min(reduction, getCurrentOutputAcWatts());
+    }
+
+    setAcOutput(_config.LowerPowerLimit);
+    return getCurrentOutputAcWatts() - _config.LowerPowerLimit;
+}
+
+uint16_t PowerLimiterBatteryInverter::applyIncrease(uint16_t increase)
+{
+    if (!isEligible()) { return 0; }
+
+    if (increase == 0) { return 0; }
+
+    // do not wake inverter up if it would produce too much power
+    if (!isProducing() && _config.LowerPowerLimit > increase) { return 0; }
+
+    auto baseline = getCurrentLimitWatts();
+
+    // battery-powered inverters in standby can have an arbitrary limit, yet
+    // the baseline is 0 in case we are about to wake it up from standby.
+    if (!isProducing()) { baseline = 0; }
+
+    auto actualIncrease = std::min(increase, getMaxIncreaseWatts());
+    setAcOutput(baseline + actualIncrease);
+    return actualIncrease;
+}
+
+uint16_t PowerLimiterBatteryInverter::standby()
+{
+    setTargetPowerState(false);
+    setExpectedOutputAcWatts(0);
+    return getCurrentOutputAcWatts();
+}
+
+void PowerLimiterBatteryInverter::setAcOutput(uint16_t expectedOutputWatts)
+{
+    // make sure to enforce the lower and upper bounds
+    expectedOutputWatts = std::min(expectedOutputWatts, getConfiguredMaxPowerWatts());
+    expectedOutputWatts = std::max(expectedOutputWatts, _config.LowerPowerLimit);
+
+    setExpectedOutputAcWatts(expectedOutputWatts);
+    setTargetPowerLimitWatts(expectedOutputWatts);
+    setTargetPowerState(true);
+}
diff --git a/src/PowerLimiterInverter.cpp b/src/PowerLimiterInverter.cpp
new file mode 100644
index 00000000..c4fc0e9f
--- /dev/null
+++ b/src/PowerLimiterInverter.cpp
@@ -0,0 +1,311 @@
+#include "RestartHelper.h"
+#include "MessageOutput.h"
+#include "PowerLimiterInverter.h"
+#include "PowerLimiterBatteryInverter.h"
+#include "PowerLimiterSolarInverter.h"
+
+std::unique_ptr<PowerLimiterInverter> PowerLimiterInverter::create(
+        bool verboseLogging, PowerLimiterInverterConfig const& config)
+{
+    std::unique_ptr<PowerLimiterInverter> upInverter;
+
+    if (config.IsSolarPowered) {
+        upInverter = std::make_unique<PowerLimiterSolarInverter>(verboseLogging, config);
+    }
+    else {
+        upInverter = std::make_unique<PowerLimiterBatteryInverter>(verboseLogging, config);
+    }
+
+    if (nullptr == upInverter->_spInverter) { return nullptr; }
+
+    return std::move(upInverter);
+}
+
+PowerLimiterInverter::PowerLimiterInverter(bool verboseLogging, PowerLimiterInverterConfig const& config)
+    : _config(config)
+    , _verboseLogging(verboseLogging)
+{
+    _spInverter = Hoymiles.getInverterBySerial(config.Serial);
+    if (!_spInverter) { return; }
+
+    snprintf(_serialStr, sizeof(_serialStr), "%0x%08x",
+            static_cast<uint32_t>((config.Serial >> 32) & 0xFFFFFFFF),
+            static_cast<uint32_t>(config.Serial & 0xFFFFFFFF));
+
+    snprintf(_logPrefix, sizeof(_logPrefix), "[DPL inverter %s]:", _serialStr);
+}
+
+bool PowerLimiterInverter::isEligible() const
+{
+    if (!isReachable() || !isSendingCommandsEnabled()) { return false; }
+
+    // after startup, the limit effective at the inverter is not known. the
+    // respective message to request this info is only sent after a significant
+    // backoff (4 minutes). this is to avoid error messages to appear in the
+    // inverter's event log. we will wait until the current limit is known.
+    if (getCurrentLimitWatts() == 0) { return false; }
+
+    // the model-dependent maximum AC power output is only known after the
+    // first DevInfoSimpleCommand succeeded. we desperately need this info, so
+    // the inverter is not eligible until this value is known.
+    if (getInverterMaxPowerWatts() == 0) { return false; }
+
+    return true;
+}
+
+bool PowerLimiterInverter::update()
+{
+    auto reset = [this]() -> bool {
+        _oTargetPowerState = std::nullopt;
+        _oTargetPowerLimitWatts = std::nullopt;
+        _oUpdateStartMillis = std::nullopt;
+        return false;
+    };
+
+    // do not reset _updateTimeouts below if no state change requested
+    if (!_oTargetPowerState.has_value() && !_oTargetPowerLimitWatts.has_value()) {
+        return reset();
+    }
+
+    if (!_oUpdateStartMillis.has_value()) {
+        _oUpdateStartMillis = millis();
+    }
+
+    if ((millis() - *_oUpdateStartMillis) > 30 * 1000) {
+        ++_updateTimeouts;
+        MessageOutput.printf("%s timeout (%d in succession), "
+                "state transition pending: %s, limit pending: %s\r\n",
+                _logPrefix, _updateTimeouts,
+                (_oTargetPowerState.has_value()?"yes":"no"),
+                (_oTargetPowerLimitWatts.has_value()?"yes":"no"));
+
+        // NOTE that this is not always 5 minutes, since this counts timeouts,
+        // not absolute time. after any timeout, an update cycle ends. a new
+        // timeout can only happen after starting a new update cycle, which in
+        // turn is only started if the DPL did calculate a new limit, which in
+        // turn does not happen while the inverter is unreachable, no matter
+        // how long (a whole night) that might be.
+        if (_updateTimeouts >= 10) {
+            MessageOutput.printf("%s issuing restart command after update "
+                    "timed out repeatedly\r\n", _logPrefix);
+            _spInverter->sendRestartControlRequest();
+        }
+
+        if (_updateTimeouts >= 20) {
+            MessageOutput.printf("%s restarting system since inverter is "
+                    "unresponsive\r\n", _logPrefix);
+            RestartHelper.triggerRestart();
+        }
+
+        return reset();
+    }
+
+    auto constexpr halfOfAllMillis = std::numeric_limits<uint32_t>::max() / 2;
+
+    auto switchPowerState = [this](bool transitionOn) -> bool {
+        // no power state transition requested at all
+        if (!_oTargetPowerState.has_value()) { return false; }
+
+        // the transition that may be started is not the one which is requested
+        if (transitionOn != *_oTargetPowerState) { return false; }
+
+        // wait for pending power command(s) to complete
+        auto lastPowerCommandState = _spInverter->PowerCommand()->getLastPowerCommandSuccess();
+        if (CMD_PENDING == lastPowerCommandState) {
+            return true;
+        }
+
+        // we need to wait for statistics that are more recent than
+        // the last power update command to reliably use isProducing()
+        auto lastPowerCommandMillis = _spInverter->PowerCommand()->getLastUpdateCommand();
+        auto lastStatisticsMillis = _spInverter->Statistics()->getLastUpdate();
+        if ((lastStatisticsMillis - lastPowerCommandMillis) > halfOfAllMillis) { return true; }
+
+        if (isProducing() != *_oTargetPowerState) {
+            MessageOutput.printf("%s %s inverter...\r\n", _logPrefix,
+                    ((*_oTargetPowerState)?"Starting":"Stopping"));
+            _spInverter->sendPowerControlRequest(*_oTargetPowerState);
+            return true;
+        }
+
+        _oTargetPowerState = std::nullopt; // target power state reached
+        return false;
+    };
+
+    // we use a lambda function here to be able to use return statements,
+    // which allows to avoid if-else-indentions and improves code readability
+    auto updateLimit = [this]() -> bool {
+        // no limit update requested at all
+        if (!_oTargetPowerLimitWatts.has_value()) { return false; }
+
+        // wait for pending limit command(s) to complete
+        auto lastLimitCommandState = _spInverter->SystemConfigPara()->getLastLimitCommandSuccess();
+        if (CMD_PENDING == lastLimitCommandState) {
+            return true;
+        }
+
+        float newRelativeLimit = static_cast<float>(*_oTargetPowerLimitWatts * 100) / getInverterMaxPowerWatts();
+
+        // if no limit command is pending, the SystemConfigPara does report the
+        // current limit, as the answer by the inverter to a limit command is
+        // the canonical source that updates the known current limit.
+        auto currentRelativeLimit = _spInverter->SystemConfigPara()->getLimitPercent();
+
+        // we assume having exclusive control over the inverter. if the last
+        // limit command was successful and sent after we started the last
+        // update cycle, we should assume *our* requested limit was set.
+        uint32_t lastLimitCommandMillis = _spInverter->SystemConfigPara()->getLastUpdateCommand();
+        if ((lastLimitCommandMillis - *_oUpdateStartMillis) < halfOfAllMillis &&
+                CMD_OK == lastLimitCommandState) {
+            MessageOutput.printf("%s actual limit is %.1f %% (%.0f W "
+                    "respectively), effective %d ms after update started, "
+                    "requested were %.1f %%\r\n",
+                    _logPrefix, currentRelativeLimit,
+                    (currentRelativeLimit * getInverterMaxPowerWatts() / 100),
+                    (lastLimitCommandMillis - *_oUpdateStartMillis),
+                    newRelativeLimit);
+
+            if (std::abs(newRelativeLimit - currentRelativeLimit) > 2.0) {
+                MessageOutput.printf("%s NOTE: expected limit of %.1f %% "
+                        "and actual limit of %.1f %% mismatch by more than 2 %%, "
+                        "is the DPL in exclusive control over the inverter?\r\n",
+                        _logPrefix, newRelativeLimit, currentRelativeLimit);
+            }
+
+            _oTargetPowerLimitWatts = std::nullopt;
+            return false;
+        }
+
+        MessageOutput.printf("%s sending limit of %.1f %% (%.0f W "
+                "respectively), max output is %d W\r\n", _logPrefix,
+                newRelativeLimit, (newRelativeLimit * getInverterMaxPowerWatts() / 100),
+                getInverterMaxPowerWatts());
+
+        _spInverter->sendActivePowerControlRequest(newRelativeLimit,
+                PowerLimitControlType::RelativNonPersistent);
+
+        return true;
+    };
+
+    // disable power production as soon as possible.
+    // setting the power limit is less important once the inverter is off.
+    if (switchPowerState(false)) { return true; }
+
+    if (updateLimit()) { return true; }
+
+    // enable power production only after setting the desired limit
+    if (switchPowerState(true)) { return true; }
+
+    _updateTimeouts = 0;
+
+    return reset();
+}
+
+std::optional<uint32_t> PowerLimiterInverter::getLatestStatsMillis() const
+{
+    uint32_t now = millis();
+
+    // concerns both power limits and start/stop/restart commands and is
+    // only updated if a respective response was received from the inverter
+    auto lastUpdateCmdAge = std::min(
+            now - _spInverter->SystemConfigPara()->getLastUpdateCommand(),
+            now - _spInverter->PowerCommand()->getLastUpdateCommand()
+    );
+
+    // we use _oStatsMillis to persist a stats update timestamp, as we are
+    // looking for the single oldest inverter stats which is still younger than
+    // the last update command. we shall not just return the actual youngest
+    // stats timestamp if newer stats arrived while no update command was sent
+    // in the meantime.
+    if (_oStatsMillis && lastUpdateCmdAge < (now - *_oStatsMillis)) {
+        _oStatsMillis.reset();
+    }
+
+    if (!_oStatsMillis) {
+        auto lastStatsMillis = _spInverter->Statistics()->getLastUpdate();
+        auto lastStatsAge = now - lastStatsMillis;
+        if (lastStatsAge > lastUpdateCmdAge) {
+            return std::nullopt;
+        }
+
+        _oStatsMillis = lastStatsMillis;
+    }
+
+    return _oStatsMillis;
+}
+
+uint16_t PowerLimiterInverter::getInverterMaxPowerWatts() const
+{
+    return _spInverter->DevInfo()->getMaxPower();
+}
+
+uint16_t PowerLimiterInverter::getConfiguredMaxPowerWatts() const
+{
+    return std::min(getInverterMaxPowerWatts(), _config.UpperPowerLimit);
+}
+
+uint16_t PowerLimiterInverter::getCurrentOutputAcWatts() const
+{
+    return _spInverter->Statistics()->getChannelFieldValue(TYPE_AC, CH0, FLD_PAC);
+}
+
+uint16_t PowerLimiterInverter::getExpectedOutputAcWatts() const
+{
+    if (!_oTargetPowerLimitWatts && !_oTargetPowerState) {
+        // the inverter's output will not change due to commands being sent
+        return getCurrentOutputAcWatts();
+    }
+
+    return _expectedOutputAcWatts;
+}
+
+void PowerLimiterInverter::setMaxOutput()
+{
+    _oTargetPowerState = true;
+    setAcOutput(getConfiguredMaxPowerWatts());
+}
+
+void PowerLimiterInverter::restart()
+{
+    _spInverter->sendRestartControlRequest();
+}
+
+float PowerLimiterInverter::getDcVoltage(uint8_t input)
+{
+    return _spInverter->Statistics()->getChannelFieldValue(TYPE_DC,
+            static_cast<ChannelNum_t>(input), FLD_UDC);
+}
+
+uint16_t PowerLimiterInverter::getCurrentLimitWatts() const
+{
+    auto currentLimitPercent = _spInverter->SystemConfigPara()->getLimitPercent();
+    return static_cast<uint16_t>(currentLimitPercent * getInverterMaxPowerWatts() / 100);
+}
+
+void PowerLimiterInverter::debug() const
+{
+    if (!_verboseLogging) { return; }
+
+    MessageOutput.printf(
+        "%s\r\n"
+        "    %s-powered, %s %d W\r\n"
+        "    lower/current/upper limit: %d/%d/%d W, output capability: %d W\r\n"
+        "    sending commands %s, %s, %s\r\n"
+        "    max reduction production/standby: %d/%d W, max increase: %d W\r\n"
+        "    target limit/output/state: %i W (%s)/%d W/%s, %d update timeouts\r\n",
+        _logPrefix,
+        (isSolarPowered()?"solar":"battery"),
+        (isProducing()?"producing":"standing by at"), getCurrentOutputAcWatts(),
+        _config.LowerPowerLimit, getCurrentLimitWatts(), _config.UpperPowerLimit,
+        getInverterMaxPowerWatts(),
+        (isSendingCommandsEnabled()?"enabled":"disabled"),
+        (isReachable()?"reachable":"offline"),
+        (isEligible()?"eligible":"disqualified"),
+        getMaxReductionWatts(false), getMaxReductionWatts(true), getMaxIncreaseWatts(),
+        (_oTargetPowerLimitWatts.has_value()?*_oTargetPowerLimitWatts:-1),
+        (_oTargetPowerLimitWatts.has_value()?"update":"unchanged"),
+        getExpectedOutputAcWatts(),
+        (_oTargetPowerState.has_value()?(*_oTargetPowerState?"production":"standby"):"unchanged"),
+        getUpdateTimeouts()
+    );
+}
diff --git a/src/PowerLimiterSolarInverter.cpp b/src/PowerLimiterSolarInverter.cpp
new file mode 100644
index 00000000..548e7c04
--- /dev/null
+++ b/src/PowerLimiterSolarInverter.cpp
@@ -0,0 +1,248 @@
+#include "MessageOutput.h"
+#include "PowerLimiterSolarInverter.h"
+
+PowerLimiterSolarInverter::PowerLimiterSolarInverter(bool verboseLogging, PowerLimiterInverterConfig const& config)
+    : PowerLimiterInverter(verboseLogging, config) { }
+
+uint16_t PowerLimiterSolarInverter::getMaxReductionWatts(bool) const
+{
+    if (!isEligible()) { return 0; }
+
+    auto low = std::min(getCurrentLimitWatts(), getCurrentOutputAcWatts());
+    if (low <= _config.LowerPowerLimit) { return 0; }
+
+    return getCurrentOutputAcWatts() - _config.LowerPowerLimit;
+}
+
+uint16_t PowerLimiterSolarInverter::getMaxIncreaseWatts() const
+{
+    if (!isEligible()) { return 0; }
+
+    // the maximum increase possible for this inverter
+    int16_t maxTotalIncrease = getConfiguredMaxPowerWatts() - getCurrentOutputAcWatts();
+
+    if (!isProducing()) {
+        // the inverter is not producing, we don't know how much we can increase
+        // the power, so we return the maximum possible increase
+        return maxTotalIncrease;
+    }
+
+    auto pStats = _spInverter->Statistics();
+    std::vector<MpptNum_t> dcMppts = _spInverter->getMppts();
+    size_t dcTotalMppts = dcMppts.size();
+
+    float inverterEfficiencyFactor = pStats->getChannelFieldValue(TYPE_INV, CH0, FLD_EFF) / 100;
+
+    // 98% of the expected power is good enough
+    auto expectedAcPowerPerMppt = (getCurrentLimitWatts() / dcTotalMppts) * 0.98;
+
+    size_t dcNonShadedMppts = 0;
+    auto nonShadedMpptACPowerSum = 0.0;
+
+    for (auto& m : dcMppts) {
+        float mpptPowerAC = 0.0;
+        std::vector<ChannelNum_t> mpptChnls = _spInverter->getChannelsDCByMppt(m);
+
+        for (auto& c : mpptChnls) {
+            mpptPowerAC += pStats->getChannelFieldValue(TYPE_DC, c, FLD_PDC) * inverterEfficiencyFactor;
+        }
+
+        if (mpptPowerAC >= expectedAcPowerPerMppt) {
+            nonShadedMpptACPowerSum += mpptPowerAC;
+            dcNonShadedMppts++;
+        }
+    }
+
+    if (dcNonShadedMppts == 0) {
+        // all mppts are shaded, we can't increase the power
+        return 0;
+    }
+
+    if (dcNonShadedMppts == dcTotalMppts) {
+        // no MPPT is shaded, we assume that we can increase the power by the maximum
+        return maxTotalIncrease;
+    }
+
+    int16_t maxPowerPerMppt = getConfiguredMaxPowerWatts() / dcTotalMppts;
+
+    int16_t currentPowerPerNonShadedMppt = nonShadedMpptACPowerSum / dcNonShadedMppts;
+
+    int16_t maxIncreasePerNonShadedMppt = maxPowerPerMppt - currentPowerPerNonShadedMppt;
+
+    // maximum increase based on the non-shaded mppts
+    return maxIncreasePerNonShadedMppt * dcNonShadedMppts;
+}
+
+uint16_t PowerLimiterSolarInverter::applyReduction(uint16_t reduction, bool)
+{
+    if (!isEligible()) { return 0; }
+
+    if (reduction == 0) { return 0; }
+
+    if ((getCurrentOutputAcWatts() - _config.LowerPowerLimit) >= reduction) {
+        setAcOutput(getCurrentOutputAcWatts() - reduction);
+        return reduction;
+    }
+
+    setAcOutput(_config.LowerPowerLimit);
+    return getCurrentOutputAcWatts() - _config.LowerPowerLimit;
+}
+
+uint16_t PowerLimiterSolarInverter::applyIncrease(uint16_t increase)
+{
+    if (!isEligible()) { return 0; }
+
+    if (increase == 0) { return 0; }
+
+    // do not wake inverter up if it would produce too much power
+    if (!isProducing() && _config.LowerPowerLimit > increase) { return 0; }
+
+    // the limit for solar-powered inverters might be scaled, so we use the
+    // current output as the baseline. solar-powered inverters in standby have
+    // no output (baseline is zero).
+    auto baseline = getCurrentOutputAcWatts();
+
+    auto actualIncrease = std::min(increase, getMaxIncreaseWatts());
+    setAcOutput(baseline + actualIncrease);
+    return actualIncrease;
+}
+
+uint16_t PowerLimiterSolarInverter::standby()
+{
+    // solar-powered inverters are never actually put into standby (by the
+    // DPL), but only set to the configured lower power limit instead.
+    setAcOutput(_config.LowerPowerLimit);
+    return getCurrentOutputAcWatts() - _config.LowerPowerLimit;
+}
+
+uint16_t PowerLimiterSolarInverter::scaleLimit(uint16_t expectedOutputWatts)
+{
+    // prevent scaling if inverter is not producing, as input channels are not
+    // producing energy and hence are detected as not-producing, causing
+    // unreasonable scaling.
+    if (!isProducing()) { return expectedOutputWatts; }
+
+    auto pStats = _spInverter->Statistics();
+    std::vector<ChannelNum_t> dcChnls = _spInverter->getChannelsDC();
+    std::vector<MpptNum_t> dcMppts = _spInverter->getMppts();
+    size_t dcTotalChnls = dcChnls.size();
+    size_t dcTotalMppts = dcMppts.size();
+
+    // if there is only one MPPT available, there is nothing we can do
+    if (dcTotalMppts <= 1) { return expectedOutputWatts; }
+
+    // test for a reasonable power limit that allows us to assume that an input
+    // channel with little energy is actually not producing, rather than
+    // producing very little due to the very low limit.
+    if (getCurrentLimitWatts() < dcTotalChnls * 10) { return expectedOutputWatts; }
+
+    // overscalling allows us to compensate for shaded panels by increasing the
+    // total power limit, if the inverter is solar powered.
+    if (_config.UseOverscalingToCompensateShading) {
+        auto inverterOutputAC = pStats->getChannelFieldValue(TYPE_AC, CH0, FLD_PAC);
+
+        float inverterEfficiencyFactor = pStats->getChannelFieldValue(TYPE_INV, CH0, FLD_EFF);
+
+        // fall back to hoymiles peak efficiency as per datasheet if inverter
+        // is currently not producing (efficiency is zero in that case)
+        inverterEfficiencyFactor = (inverterEfficiencyFactor > 0) ? inverterEfficiencyFactor/100 : 0.967;
+
+        // 98% of the expected power is good enough
+        auto expectedAcPowerPerMppt = (getCurrentLimitWatts() / dcTotalMppts) * 0.98;
+
+        if (_verboseLogging) {
+            MessageOutput.printf("%s expected AC power per MPPT %.0f W\r\n",
+                    _logPrefix, expectedAcPowerPerMppt);
+        }
+
+        size_t dcShadedMppts = 0;
+        auto shadedChannelACPowerSum = 0.0;
+
+        for (auto& m : dcMppts) {
+            float mpptPowerAC = 0.0;
+            std::vector<ChannelNum_t> mpptChnls = _spInverter->getChannelsDCByMppt(m);
+
+            for (auto& c : mpptChnls) {
+                mpptPowerAC += pStats->getChannelFieldValue(TYPE_DC, c, FLD_PDC) * inverterEfficiencyFactor;
+            }
+
+            if (mpptPowerAC < expectedAcPowerPerMppt) {
+                dcShadedMppts++;
+                shadedChannelACPowerSum += mpptPowerAC;
+            }
+
+            if (_verboseLogging) {
+                MessageOutput.printf("%s MPPT-%c AC power %.0f W\r\n",
+                        _logPrefix, m + 'a', mpptPowerAC);
+            }
+        }
+
+        // no shading or the shaded channels provide more power than what
+        // we currently need.
+        if (dcShadedMppts == 0 || shadedChannelACPowerSum >= expectedOutputWatts) {
+            return expectedOutputWatts;
+        }
+
+        if (dcShadedMppts == dcTotalMppts) {
+            // keep the currentLimit when:
+            // - all channels are shaded
+            // - currentLimit >= expectedOutputWatts
+            // - we get the expected AC power or less and
+            if (getCurrentLimitWatts() >= expectedOutputWatts &&
+                    inverterOutputAC <= expectedOutputWatts) {
+                if (_verboseLogging) {
+                    MessageOutput.printf("%s all mppts are shaded, "
+                            "keeping the current limit of %d W\r\n",
+                            _logPrefix, getCurrentLimitWatts());
+                }
+
+                return getCurrentLimitWatts();
+
+            } else {
+                return expectedOutputWatts;
+            }
+        }
+
+        size_t dcNonShadedMppts = dcTotalMppts - dcShadedMppts;
+        uint16_t overScaledLimit = (expectedOutputWatts - shadedChannelACPowerSum) / dcNonShadedMppts * dcTotalMppts;
+
+        if (overScaledLimit <= expectedOutputWatts) { return expectedOutputWatts; }
+
+        if (_verboseLogging) {
+            MessageOutput.printf("%s %d/%d mppts are shaded, scaling %d W\r\n",
+                    _logPrefix, dcShadedMppts, dcTotalMppts, overScaledLimit);
+        }
+
+        return overScaledLimit;
+    }
+
+    size_t dcProdMppts = 0;
+    for (auto& m : dcMppts) {
+        float dcPowerMppt = 0.0;
+        std::vector<ChannelNum_t> mpptChnls = _spInverter->getChannelsDCByMppt(m);
+
+        for (auto& c : mpptChnls) {
+            dcPowerMppt += pStats->getChannelFieldValue(TYPE_DC, c, FLD_PDC);
+        }
+
+        if (dcPowerMppt > 2.0 * mpptChnls.size()) {
+            dcProdMppts++;
+        }
+    }
+
+    if (dcProdMppts == 0 || dcProdMppts == dcTotalMppts) { return expectedOutputWatts; }
+
+    uint16_t scaled = expectedOutputWatts / dcProdMppts * dcTotalMppts;
+    MessageOutput.printf("%s %d/%d mppts are producing, scaling from %d to "
+            "%d W\r\n", _logPrefix, dcProdMppts, dcTotalMppts,
+            expectedOutputWatts, scaled);
+
+    return scaled;
+}
+
+void PowerLimiterSolarInverter::setAcOutput(uint16_t expectedOutputWatts)
+{
+    setExpectedOutputAcWatts(expectedOutputWatts);
+    setTargetPowerLimitWatts(scaleLimit(expectedOutputWatts));
+    setTargetPowerState(true);
+}
diff --git a/src/SBSCanReceiver.cpp b/src/SBSCanReceiver.cpp
index 9150075c..9d225d21 100644
--- a/src/SBSCanReceiver.cpp
+++ b/src/SBSCanReceiver.cpp
@@ -74,10 +74,10 @@ void SBSCanReceiver::onMessage(twai_message_t rx_message)
 
         case 0x640: {
             _stats->_chargeCurrentLimitation = (this->readSignedInt24(rx_message.data + 3) * 0.001);
-            _stats->_dischargeCurrentLimitation = (this->readSignedInt24(rx_message.data)) * 0.001;
+            _stats->setDischargeCurrentLimit(this->readSignedInt24(rx_message.data) * 0.001, millis());
 
             if (_verboseLogging) {
-                MessageOutput.printf("[SBS Unipower] 1600 Currents  %f, %f \r\n", _stats->_chargeCurrentLimitation, _stats->_dischargeCurrentLimitation);
+                MessageOutput.printf("[SBS Unipower] 1600 Currents  %f, %f \r\n", _stats->_chargeCurrentLimitation, _stats->getDischargeCurrentLimit());
             }
             break;
         }
@@ -144,7 +144,7 @@ void SBSCanReceiver::dummyData()
     _stats->setSoC(42, 0/*precision*/, millis());
     _stats->_chargeVoltage = dummyFloat(50);
     _stats->_chargeCurrentLimitation = dummyFloat(33);
-    _stats->_dischargeCurrentLimitation = dummyFloat(12);
+    _stats->setDischargeCurrentLimit(dummyFloat(12), millis());
     _stats->_stateOfHealth = 99;
     _stats->setVoltage(48.67, millis());
     _stats->_current = dummyFloat(-1);
diff --git a/src/SunPosition.cpp b/src/SunPosition.cpp
index f1e1bee4..5a2f27a2 100644
--- a/src/SunPosition.cpp
+++ b/src/SunPosition.cpp
@@ -7,6 +7,8 @@
 #include "Utils.h"
 #include <Arduino.h>
 
+#define CALC_UNIQUE_ID (((timeinfo.tm_year << 9) | (timeinfo.tm_mon << 5) | timeinfo.tm_mday) << 1 | timeinfo.tm_isdst)
+
 SunPositionClass SunPosition;
 
 SunPositionClass::SunPositionClass()
@@ -57,7 +59,7 @@ bool SunPositionClass::checkRecalcDayChanged() const
     time(&now);
     localtime_r(&now, &timeinfo); // don't use getLocalTime() as there could be a delay of 10ms
 
-    const uint32_t ymd = (timeinfo.tm_year << 9) | (timeinfo.tm_mon << 5) | timeinfo.tm_mday;
+    const uint32_t ymd = CALC_UNIQUE_ID;
 
     return _lastSunPositionCalculatedYMD != ymd;
 }
@@ -67,7 +69,7 @@ void SunPositionClass::updateSunData()
     struct tm timeinfo;
     const bool gotLocalTime = getLocalTime(&timeinfo, 5);
 
-    _lastSunPositionCalculatedYMD = (timeinfo.tm_year << 9) | (timeinfo.tm_mon << 5) | timeinfo.tm_mday;
+    _lastSunPositionCalculatedYMD = CALC_UNIQUE_ID;
     setDoRecalc(false);
 
     if (!gotLocalTime) {
diff --git a/src/Utils.cpp b/src/Utils.cpp
index db3bd4bf..f1602a9a 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -7,6 +7,7 @@
 #include "MessageOutput.h"
 #include "PinMapping.h"
 #include <LittleFS.h>
+#include <MD5Builder.h>
 
 uint32_t Utils::getChipId()
 {
@@ -81,6 +82,48 @@ void Utils::removeAllFiles()
     }
 }
 
+String Utils::generateMd5FromFile(String file)
+{
+    if (!LittleFS.exists(file)) {
+        return String();
+    }
+
+    File f = LittleFS.open(file, "r");
+    if (!file) {
+        return String();
+    }
+
+    MD5Builder md5;
+    md5.begin();
+
+    // Read the file in chunks to avoid using too much memory
+    uint8_t buffer[512];
+
+    while (f.available()) {
+        size_t bytesRead = f.read(buffer, sizeof(buffer) / sizeof(buffer[0]));
+        md5.add(buffer, bytesRead);
+    }
+
+    // Finalize and calculate the MD5 hash
+    md5.calculate();
+
+    f.close();
+
+    return md5.toString();
+}
+
+void Utils::skipBom(File& f)
+{
+    // skip Byte Order Mask (BOM). valid JSON docs always start with '{' or '['.
+    while (f.available() > 0) {
+        int c = f.peek();
+        if (c == '{' || c == '[') {
+            break;
+        }
+        f.read();
+    }
+}
+
 /* OpenDTU-OnBatter-specific utils go here: */
 template<typename T>
 std::optional<T> getFromString(char const* val);
diff --git a/src/VictronMppt.cpp b/src/VictronMppt.cpp
index a994e20d..86373f45 100644
--- a/src/VictronMppt.cpp
+++ b/src/VictronMppt.cpp
@@ -27,7 +27,7 @@ void VictronMpptClass::updateSettings()
     }
     _serialPortOwners.clear();
 
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     if (!config.Vedirect.Enabled) { return; }
 
     const PinMapping_t& pin = PinMapping.get();
@@ -226,3 +226,39 @@ float VictronMpptClass::getOutputVoltage() const
 
     return min;
 }
+
+std::optional<uint8_t> VictronMpptClass::getStateOfOperation() const
+{
+    for (const auto& upController : _controllers) {
+        if (upController->isDataValid()) {
+            return upController->getData().currentState_CS;
+        }
+    }
+
+    return std::nullopt;
+}
+
+std::optional<float> VictronMpptClass::getVoltage(MPPTVoltage kindOf) const
+{
+    for (const auto& upController : _controllers) {
+        switch (kindOf) {
+            case MPPTVoltage::ABSORPTION: {
+                auto const& absorptionVoltage = upController->getData().BatteryAbsorptionMilliVolt;
+                if (absorptionVoltage.first > 0) { return absorptionVoltage.second; }
+                break;
+            }
+            case MPPTVoltage::FLOAT: {
+                auto const& floatVoltage = upController->getData().BatteryFloatMilliVolt;
+                if (floatVoltage.first > 0) { return floatVoltage.second; }
+                break;
+            }
+            case MPPTVoltage::BATTERY: {
+                auto const& batteryVoltage = upController->getData().batteryVoltage_V_mV;
+                if (upController->isDataValid()) { return batteryVoltage; }
+                break;
+            }
+        }
+    }
+
+    return std::nullopt;
+}
diff --git a/src/WebApi.cpp b/src/WebApi.cpp
index 7d23e5fb..08026c4e 100644
--- a/src/WebApi.cpp
+++ b/src/WebApi.cpp
@@ -15,13 +15,14 @@ WebApiClass::WebApiClass()
 
 void WebApiClass::init(Scheduler& scheduler)
 {
-    _webApiConfig.init(_server, scheduler);
     _webApiDevice.init(_server, scheduler);
     _webApiDevInfo.init(_server, scheduler);
     _webApiDtu.init(_server, scheduler);
     _webApiEventlog.init(_server, scheduler);
+    _webApiFile.init(_server, scheduler);
     _webApiFirmware.init(_server, scheduler);
     _webApiGridprofile.init(_server, scheduler);
+    _webApiI18n.init(_server, scheduler);
     _webApiInverter.init(_server, scheduler);
     _webApiLimit.init(_server, scheduler);
     _webApiMaintenance.init(_server, scheduler);
@@ -58,7 +59,7 @@ void WebApiClass::reload()
 
 bool WebApiClass::checkCredentials(AsyncWebServerRequest* request)
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     if (request->authenticate(AUTH_USERNAME, config.Security.Password)) {
         return true;
     }
@@ -76,7 +77,7 @@ bool WebApiClass::checkCredentials(AsyncWebServerRequest* request)
 
 bool WebApiClass::checkCredentialsReadonly(AsyncWebServerRequest* request)
 {
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     if (config.Security.AllowReadonly) {
         return true;
     } else {
diff --git a/src/WebApi_Huawei.cpp b/src/WebApi_Huawei.cpp
index e836842e..dc8f4ad7 100644
--- a/src/WebApi_Huawei.cpp
+++ b/src/WebApi_Huawei.cpp
@@ -153,7 +153,7 @@ void WebApiHuaweiClass::onAdminGet(AsyncWebServerRequest* request)
 
     AsyncJsonResponse* response = new AsyncJsonResponse();
     auto& root = response->getRoot();
-    const CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     root["enabled"] = config.Huawei.Enabled;
     root["verbose_logging"] = config.Huawei.VerboseLogging;
@@ -200,19 +200,22 @@ void WebApiHuaweiClass::onAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    CONFIG_T& config = Configuration.get();
-    config.Huawei.Enabled = root["enabled"].as<bool>();
-    config.Huawei.VerboseLogging = root["verbose_logging"];
-    config.Huawei.CAN_Controller_Frequency = root["can_controller_frequency"].as<uint32_t>();
-    config.Huawei.Auto_Power_Enabled = root["auto_power_enabled"].as<bool>();
-    config.Huawei.Auto_Power_BatterySoC_Limits_Enabled = root["auto_power_batterysoc_limits_enabled"].as<bool>();
-    config.Huawei.Emergency_Charge_Enabled = root["emergency_charge_enabled"].as<bool>();
-    config.Huawei.Auto_Power_Voltage_Limit = root["voltage_limit"].as<float>();
-    config.Huawei.Auto_Power_Enable_Voltage_Limit = root["enable_voltage_limit"].as<float>();
-    config.Huawei.Auto_Power_Lower_Power_Limit = root["lower_power_limit"].as<float>();
-    config.Huawei.Auto_Power_Upper_Power_Limit = root["upper_power_limit"].as<float>();
-    config.Huawei.Auto_Power_Stop_BatterySoC_Threshold = root["stop_batterysoc_threshold"];
-    config.Huawei.Auto_Power_Target_Power_Consumption = root["target_power_consumption"];
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+        config.Huawei.Enabled = root["enabled"].as<bool>();
+        config.Huawei.VerboseLogging = root["verbose_logging"];
+        config.Huawei.CAN_Controller_Frequency = root["can_controller_frequency"].as<uint32_t>();
+        config.Huawei.Auto_Power_Enabled = root["auto_power_enabled"].as<bool>();
+        config.Huawei.Auto_Power_BatterySoC_Limits_Enabled = root["auto_power_batterysoc_limits_enabled"].as<bool>();
+        config.Huawei.Emergency_Charge_Enabled = root["emergency_charge_enabled"].as<bool>();
+        config.Huawei.Auto_Power_Voltage_Limit = root["voltage_limit"].as<float>();
+        config.Huawei.Auto_Power_Enable_Voltage_Limit = root["enable_voltage_limit"].as<float>();
+        config.Huawei.Auto_Power_Lower_Power_Limit = root["lower_power_limit"].as<float>();
+        config.Huawei.Auto_Power_Upper_Power_Limit = root["upper_power_limit"].as<float>();
+        config.Huawei.Auto_Power_Stop_BatterySoC_Threshold = root["stop_batterysoc_threshold"];
+        config.Huawei.Auto_Power_Target_Power_Consumption = root["target_power_consumption"];
+    }
 
     WebApi.writeConfig(retMsg);
 
@@ -226,6 +229,8 @@ void WebApiHuaweiClass::onAdminPost(AsyncWebServerRequest* request)
     yield();
     ESP.restart();
 
+    auto const& config = Configuration.get();
+
     const PinMapping_t& pin = PinMapping.get();
     // Properly turn this on
     if (config.Huawei.Enabled) {
diff --git a/src/WebApi_battery.cpp b/src/WebApi_battery.cpp
index bc3081e9..9e6679c3 100644
--- a/src/WebApi_battery.cpp
+++ b/src/WebApi_battery.cpp
@@ -33,7 +33,7 @@ void WebApiBatteryClass::onStatus(AsyncWebServerRequest* request)
 
     AsyncJsonResponse* response = new AsyncJsonResponse();
     auto root = response->getRoot().as<JsonObject>();
-    auto& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     ConfigurationClass::serializeBatteryConfig(config.Battery, root);
 
@@ -70,8 +70,11 @@ void WebApiBatteryClass::onAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    auto& config = Configuration.get();
-    ConfigurationClass::deserializeBatteryConfig(root.as<JsonObject>(), config.Battery);
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+        ConfigurationClass::deserializeBatteryConfig(root.as<JsonObject>(), config.Battery);
+    }
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_device.cpp b/src/WebApi_device.cpp
index 40560224..f5b46a80 100644
--- a/src/WebApi_device.cpp
+++ b/src/WebApi_device.cpp
@@ -86,7 +86,7 @@ void WebApiDeviceClass::onDeviceAdminGet(AsyncWebServerRequest* request)
     display["power_safe"] = config.Display.PowerSafe;
     display["screensaver"] = config.Display.ScreenSaver;
     display["contrast"] = config.Display.Contrast;
-    display["language"] = config.Display.Language;
+    display["locale"] = config.Display.Locale;
     display["diagramduration"] = config.Display.Diagram.Duration;
     display["diagrammode"] = config.Display.Diagram.Mode;
 
@@ -158,29 +158,34 @@ void WebApiDeviceClass::onDeviceAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    CONFIG_T& config = Configuration.get();
-    bool performRestart = root["curPin"]["name"].as<String>() != config.Dev_PinMapping;
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
 
-    strlcpy(config.Dev_PinMapping, root["curPin"]["name"].as<String>().c_str(), sizeof(config.Dev_PinMapping));
-    config.Display.Rotation = root["display"]["rotation"].as<uint8_t>();
-    config.Display.PowerSafe = root["display"]["power_safe"].as<bool>();
-    config.Display.ScreenSaver = root["display"]["screensaver"].as<bool>();
-    config.Display.Contrast = root["display"]["contrast"].as<uint8_t>();
-    config.Display.Language = root["display"]["language"].as<uint8_t>();
-    config.Display.Diagram.Duration = root["display"]["diagramduration"].as<uint32_t>();
-    config.Display.Diagram.Mode = root["display"]["diagrammode"].as<DiagramMode_t>();
+        strlcpy(config.Dev_PinMapping, root["curPin"]["name"].as<String>().c_str(), sizeof(config.Dev_PinMapping));
+        config.Display.Rotation = root["display"]["rotation"].as<uint8_t>();
+        config.Display.PowerSafe = root["display"]["power_safe"].as<bool>();
+        config.Display.ScreenSaver = root["display"]["screensaver"].as<bool>();
+        config.Display.Contrast = root["display"]["contrast"].as<uint8_t>();
+        strlcpy(config.Display.Locale, root["display"]["locale"].as<String>().c_str(), sizeof(config.Display.Locale));
+        config.Display.Diagram.Duration = root["display"]["diagramduration"].as<uint32_t>();
+        config.Display.Diagram.Mode = root["display"]["diagrammode"].as<DiagramMode_t>();
 
-    for (uint8_t i = 0; i < PINMAPPING_LED_COUNT; i++) {
-        config.Led_Single[i].Brightness = root["led"][i]["brightness"].as<uint8_t>();
-        config.Led_Single[i].Brightness = min<uint8_t>(100, config.Led_Single[i].Brightness);
+        for (uint8_t i = 0; i < PINMAPPING_LED_COUNT; i++) {
+            config.Led_Single[i].Brightness = root["led"][i]["brightness"].as<uint8_t>();
+            config.Led_Single[i].Brightness = min<uint8_t>(100, config.Led_Single[i].Brightness);
+        }
     }
 
+    auto const& config = Configuration.get();
+    bool performRestart = root["curPin"]["name"].as<String>() != config.Dev_PinMapping;
+
     Display.setDiagramMode(static_cast<DiagramMode_t>(config.Display.Diagram.Mode));
     Display.setOrientation(config.Display.Rotation);
     Display.enablePowerSafe = config.Display.PowerSafe;
     Display.enableScreensaver = config.Display.ScreenSaver;
     Display.setContrast(config.Display.Contrast);
-    Display.setLanguage(config.Display.Language);
+    Display.setLocale(config.Display.Locale);
     Display.Diagram().updatePeriod();
 
     WebApi.writeConfig(retMsg);
diff --git a/src/WebApi_dtu.cpp b/src/WebApi_dtu.cpp
index 8d9f1c43..e87538bc 100644
--- a/src/WebApi_dtu.cpp
+++ b/src/WebApi_dtu.cpp
@@ -27,7 +27,7 @@ void WebApiDtuClass::init(AsyncWebServer& server, Scheduler& scheduler)
 void WebApiDtuClass::applyDataTaskCb()
 {
     // Execute stuff in main thread to avoid busy SPI bus
-    CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
     Hoymiles.getRadioNrf()->setPALevel((rf24_pa_dbm_e)config.Dtu.Nrf.PaLevel);
     Hoymiles.getRadioCmt()->setPALevel(config.Dtu.Cmt.PaLevel);
     Hoymiles.getRadioNrf()->setDtuSerial(config.Dtu.Serial);
@@ -50,8 +50,8 @@ void WebApiDtuClass::onDtuAdminGet(AsyncWebServerRequest* request)
     // DTU Serial is read as HEX
     char buffer[sizeof(uint64_t) * 8 + 1];
     snprintf(buffer, sizeof(buffer), "%0" PRIx32 "%08" PRIx32,
-        ((uint32_t)((config.Dtu.Serial >> 32) & 0xFFFFFFFF)),
-        ((uint32_t)(config.Dtu.Serial & 0xFFFFFFFF)));
+        static_cast<uint32_t>((config.Dtu.Serial >> 32) & 0xFFFFFFFF),
+        static_cast<uint32_t>(config.Dtu.Serial & 0xFFFFFFFF));
     root["serial"] = buffer;
     root["pollinterval"] = config.Dtu.PollInterval;
     root["verbose_logging"] = config.Dtu.VerboseLogging;
@@ -155,15 +155,17 @@ void WebApiDtuClass::onDtuAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    CONFIG_T& config = Configuration.get();
-
-    config.Dtu.Serial = serial;
-    config.Dtu.PollInterval = root["pollinterval"].as<uint32_t>();
-    config.Dtu.VerboseLogging = root["verbose_logging"].as<bool>();
-    config.Dtu.Nrf.PaLevel = root["nrf_palevel"].as<uint8_t>();
-    config.Dtu.Cmt.PaLevel = root["cmt_palevel"].as<int8_t>();
-    config.Dtu.Cmt.Frequency = root["cmt_frequency"].as<uint32_t>();
-    config.Dtu.Cmt.CountryMode = root["cmt_country"].as<CountryModeId_t>();
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+        config.Dtu.Serial = serial;
+        config.Dtu.PollInterval = root["pollinterval"].as<uint32_t>();
+        config.Dtu.VerboseLogging = root["verbose_logging"].as<bool>();
+        config.Dtu.Nrf.PaLevel = root["nrf_palevel"].as<uint8_t>();
+        config.Dtu.Cmt.PaLevel = root["cmt_palevel"].as<int8_t>();
+        config.Dtu.Cmt.Frequency = root["cmt_frequency"].as<uint32_t>();
+        config.Dtu.Cmt.CountryMode = root["cmt_country"].as<CountryModeId_t>();
+    }
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_config.cpp b/src/WebApi_file.cpp
similarity index 61%
rename from src/WebApi_config.cpp
rename to src/WebApi_file.cpp
index 51a7aab1..60c0bea0 100644
--- a/src/WebApi_config.cpp
+++ b/src/WebApi_file.cpp
@@ -2,7 +2,7 @@
 /*
  * Copyright (C) 2022-2024 Thomas Basler and others
  */
-#include "WebApi_config.h"
+#include "WebApi_file.h"
 #include "Configuration.h"
 #include "RestartHelper.h"
 #include "Utils.h"
@@ -11,7 +11,7 @@
 #include <AsyncJson.h>
 #include <LittleFS.h>
 
-void WebApiConfigClass::init(AsyncWebServer& server, Scheduler& scheduler)
+void WebApiFileClass::init(AsyncWebServer& server, Scheduler& scheduler)
 {
     using std::placeholders::_1;
     using std::placeholders::_2;
@@ -20,15 +20,43 @@ void WebApiConfigClass::init(AsyncWebServer& server, Scheduler& scheduler)
     using std::placeholders::_5;
     using std::placeholders::_6;
 
-    server.on("/api/config/get", HTTP_GET, std::bind(&WebApiConfigClass::onConfigGet, this, _1));
-    server.on("/api/config/delete", HTTP_POST, std::bind(&WebApiConfigClass::onConfigDelete, this, _1));
-    server.on("/api/config/list", HTTP_GET, std::bind(&WebApiConfigClass::onConfigListGet, this, _1));
-    server.on("/api/config/upload", HTTP_POST,
-        std::bind(&WebApiConfigClass::onConfigUploadFinish, this, _1),
-        std::bind(&WebApiConfigClass::onConfigUpload, this, _1, _2, _3, _4, _5, _6));
+    server.on("/api/file/get", HTTP_GET, std::bind(&WebApiFileClass::onFileGet, this, _1));
+    server.on("/api/file/delete", HTTP_POST, std::bind(&WebApiFileClass::onFileDelete, this, _1));
+    server.on("/api/file/delete_all", HTTP_POST, std::bind(&WebApiFileClass::onFileDeleteAll, this, _1));
+    server.on("/api/file/list", HTTP_GET, std::bind(&WebApiFileClass::onFileListGet, this, _1));
+    server.on("/api/file/upload", HTTP_POST,
+        std::bind(&WebApiFileClass::onFileUploadFinish, this, _1),
+        std::bind(&WebApiFileClass::onFileUpload, this, _1, _2, _3, _4, _5, _6));
 }
 
-void WebApiConfigClass::onConfigGet(AsyncWebServerRequest* request)
+void WebApiFileClass::onFileListGet(AsyncWebServerRequest* request)
+{
+    if (!WebApi.checkCredentials(request)) {
+        return;
+    }
+
+    AsyncJsonResponse* response = new AsyncJsonResponse();
+    auto& root = response->getRoot();
+    auto data = root.to<JsonArray>();
+
+    File rootfs = LittleFS.open("/");
+    File file = rootfs.openNextFile();
+    while (file) {
+        if (file.isDirectory()) {
+            continue;
+        }
+        JsonObject obj = data.add<JsonObject>();
+        obj["name"] = String(file.name());
+        obj["size"] = file.size();
+
+        file = rootfs.openNextFile();
+    }
+    file.close();
+
+    WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
+}
+
+void WebApiFileClass::onFileGet(AsyncWebServerRequest* request)
 {
     if (!WebApi.checkCredentials(request)) {
         return;
@@ -48,7 +76,43 @@ void WebApiConfigClass::onConfigGet(AsyncWebServerRequest* request)
     request->send(LittleFS, requestFile, String(), true);
 }
 
-void WebApiConfigClass::onConfigDelete(AsyncWebServerRequest* request)
+void WebApiFileClass::onFileDelete(AsyncWebServerRequest* request)
+{
+    if (!WebApi.checkCredentials(request)) {
+        return;
+    }
+
+    AsyncJsonResponse* response = new AsyncJsonResponse();
+    JsonDocument root;
+    if (!WebApi.parseRequestData(request, response, root)) {
+        return;
+    }
+
+    auto& retMsg = response->getRoot();
+
+    if (!(root["file"].is<String>())) {
+        retMsg["message"] = "Values are missing!";
+        retMsg["code"] = WebApiError::GenericValueMissing;
+        WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
+        return;
+    }
+
+    String name = "/" + root["file"].as<String>();
+    if (!LittleFS.exists(name)) {
+        request->send(404);
+        return;
+    }
+
+    LittleFS.remove(name);
+
+    retMsg["type"] = "success";
+    retMsg["message"] = "File deleted";
+    retMsg["code"] = WebApiError::FileDeleteSuccess;
+
+    WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
+}
+
+void WebApiFileClass::onFileDeleteAll(AsyncWebServerRequest* request)
 {
     if (!WebApi.checkCredentials(request)) {
         return;
@@ -71,14 +135,14 @@ void WebApiConfigClass::onConfigDelete(AsyncWebServerRequest* request)
 
     if (root["delete"].as<bool>() == false) {
         retMsg["message"] = "Not deleted anything!";
-        retMsg["code"] = WebApiError::ConfigNotDeleted;
+        retMsg["code"] = WebApiError::FileNotDeleted;
         WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
         return;
     }
 
     retMsg["type"] = "success";
     retMsg["message"] = "Configuration resettet. Rebooting now...";
-    retMsg["code"] = WebApiError::ConfigSuccess;
+    retMsg["code"] = WebApiError::FileSuccess;
 
     WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
 
@@ -86,49 +150,7 @@ void WebApiConfigClass::onConfigDelete(AsyncWebServerRequest* request)
     RestartHelper.triggerRestart();
 }
 
-void WebApiConfigClass::onConfigListGet(AsyncWebServerRequest* request)
-{
-    if (!WebApi.checkCredentials(request)) {
-        return;
-    }
-
-    AsyncJsonResponse* response = new AsyncJsonResponse();
-    auto& root = response->getRoot();
-    auto data = root["configs"].to<JsonArray>();
-
-    File rootfs = LittleFS.open("/");
-    File file = rootfs.openNextFile();
-    while (file) {
-        if (file.isDirectory()) {
-            continue;
-        }
-        JsonObject obj = data.add<JsonObject>();
-        obj["name"] = String(file.name());
-
-        file = rootfs.openNextFile();
-    }
-    file.close();
-
-    WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
-}
-
-void WebApiConfigClass::onConfigUploadFinish(AsyncWebServerRequest* request)
-{
-    if (!WebApi.checkCredentials(request)) {
-        return;
-    }
-
-    // the request handler is triggered after the upload has finished...
-    // create the response, add header, and send response
-
-    AsyncWebServerResponse* response = request->beginResponse(200, "text/plain", "OK");
-    response->addHeader("Connection", "close");
-    response->addHeader("Access-Control-Allow-Origin", "*");
-    request->send(response);
-    RestartHelper.triggerRestart();
-}
-
-void WebApiConfigClass::onConfigUpload(AsyncWebServerRequest* request, String filename, size_t index, uint8_t* data, size_t len, bool final)
+void WebApiFileClass::onFileUpload(AsyncWebServerRequest* request, String filename, size_t index, uint8_t* data, size_t len, bool final)
 {
     if (!WebApi.checkCredentials(request)) {
         return;
@@ -154,3 +176,19 @@ void WebApiConfigClass::onConfigUpload(AsyncWebServerRequest* request, String fi
         request->_tempFile.close();
     }
 }
+
+void WebApiFileClass::onFileUploadFinish(AsyncWebServerRequest* request)
+{
+    if (!WebApi.checkCredentials(request)) {
+        return;
+    }
+
+    // the request handler is triggered after the upload has finished...
+    // create the response, add header, and send response
+
+    AsyncWebServerResponse* response = request->beginResponse(200, "text/plain", "OK");
+    response->addHeader("Connection", "close");
+    response->addHeader("Access-Control-Allow-Origin", "*");
+    request->send(response);
+    RestartHelper.triggerRestart();
+}
diff --git a/src/WebApi_i18n.cpp b/src/WebApi_i18n.cpp
new file mode 100644
index 00000000..6a43072f
--- /dev/null
+++ b/src/WebApi_i18n.cpp
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2024 Thomas Basler and others
+ */
+#include "WebApi_i18n.h"
+#include "I18n.h"
+#include "Utils.h"
+#include "WebApi.h"
+#include <AsyncJson.h>
+#include <LittleFS.h>
+
+void WebApiI18nClass::init(AsyncWebServer& server, Scheduler& scheduler)
+{
+    using std::placeholders::_1;
+
+    server.on("/api/i18n/languages", HTTP_GET, std::bind(&WebApiI18nClass::onI18nLanguages, this, _1));
+    server.on("/api/i18n/language", HTTP_GET, std::bind(&WebApiI18nClass::onI18nLanguage, this, _1));
+}
+
+void WebApiI18nClass::onI18nLanguages(AsyncWebServerRequest* request)
+{
+    AsyncJsonResponse* response = new AsyncJsonResponse(true);
+    auto& root = response->getRoot();
+    const auto& languages = I18n.getAvailableLanguages();
+
+    for (auto& language : languages) {
+        auto jsonLang = root.add<JsonObject>();
+
+        jsonLang["code"] = language.code;
+        jsonLang["name"] = language.name;
+    }
+
+    WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
+}
+
+void WebApiI18nClass::onI18nLanguage(AsyncWebServerRequest* request)
+{
+    if (request->hasParam("code")) {
+        String code = request->getParam("code")->value();
+
+        String filename = I18n.getFilenameByLocale(code);
+
+        if (filename != "") {
+            String md5 = Utils::generateMd5FromFile(filename);
+
+            String expectedEtag;
+            expectedEtag = "\"";
+            expectedEtag += md5;
+            expectedEtag += "\"";
+
+            bool eTagMatch = false;
+            if (request->hasHeader("If-None-Match")) {
+                const AsyncWebHeader* h = request->getHeader("If-None-Match");
+                eTagMatch = h->value().equals(expectedEtag);
+            }
+
+            // begin response 200 or 304
+            AsyncWebServerResponse* response;
+            if (eTagMatch) {
+                response = request->beginResponse(304);
+            } else {
+                response = request->beginResponse(LittleFS, filename, asyncsrv::T_application_json);
+            }
+
+            // HTTP requires cache headers in 200 and 304 to be identical
+            response->addHeader("Cache-Control", "public, must-revalidate");
+            response->addHeader("ETag", expectedEtag);
+
+            request->send(response);
+            return;
+        }
+    }
+
+    request->send(404);
+    return;
+}
diff --git a/src/WebApi_inverter.cpp b/src/WebApi_inverter.cpp
index ef353158..caf5fcd1 100644
--- a/src/WebApi_inverter.cpp
+++ b/src/WebApi_inverter.cpp
@@ -5,6 +5,7 @@
 #include "WebApi_inverter.h"
 #include "Configuration.h"
 #include "MqttHandleHass.h"
+#include "PowerLimiter.h"
 #include "WebApi.h"
 #include "WebApi_errors.h"
 #include "defaults.h"
@@ -46,8 +47,8 @@ void WebApiInverterClass::onInverterList(AsyncWebServerRequest* request)
             // Inverter Serial is read as HEX
             char buffer[sizeof(uint64_t) * 8 + 1];
             snprintf(buffer, sizeof(buffer), "%0" PRIx32 "%08" PRIx32,
-                ((uint32_t)((config.Inverter[i].Serial >> 32) & 0xFFFFFFFF)),
-                ((uint32_t)(config.Inverter[i].Serial & 0xFFFFFFFF)));
+                static_cast<uint32_t>((config.Inverter[i].Serial >> 32) & 0xFFFFFFFF),
+                static_cast<uint32_t>(config.Inverter[i].Serial & 0xFFFFFFFF));
             obj["serial"] = buffer;
             obj["poll_enable"] = config.Inverter[i].Poll_Enable;
             obj["poll_enable_night"] = config.Inverter[i].Poll_Enable_Night;
@@ -150,6 +151,8 @@ void WebApiInverterClass::onInverterAdd(AsyncWebServerRequest* request)
     }
 
     MqttHandleHass.forceUpdate();
+
+    PowerLimiter.triggerReloadingConfig();
 }
 
 void WebApiInverterClass::onInverterEdit(AsyncWebServerRequest* request)
@@ -184,9 +187,9 @@ void WebApiInverterClass::onInverterEdit(AsyncWebServerRequest* request)
     }
 
     // Interpret the string as a hex value and convert it to uint64_t
-    const uint64_t serial = strtoll(root["serial"].as<String>().c_str(), NULL, 16);
+    const uint64_t new_serial = strtoll(root["serial"].as<String>().c_str(), NULL, 16);
 
-    if (serial == 0) {
+    if (new_serial == 0) {
         retMsg["message"] = "Serial must be a number > 0!";
         retMsg["code"] = WebApiError::InverterSerialZero;
         WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
@@ -209,37 +212,42 @@ void WebApiInverterClass::onInverterEdit(AsyncWebServerRequest* request)
         return;
     }
 
-    INVERTER_CONFIG_T& inverter = Configuration.get().Inverter[root["id"].as<uint8_t>()];
+    uint64_t old_serial = 0;
 
-    uint64_t new_serial = serial;
-    uint64_t old_serial = inverter.Serial;
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
 
-    // Interpret the string as a hex value and convert it to uint64_t
-    inverter.Serial = new_serial;
-    strncpy(inverter.Name, root["name"].as<String>().c_str(), INV_MAX_NAME_STRLEN);
+        INVERTER_CONFIG_T& inverter = config.Inverter[root["id"].as<uint8_t>()];
 
-    inverter.Poll_Enable = root["poll_enable"] | true;
-    inverter.Poll_Enable_Night = root["poll_enable_night"] | true;
-    inverter.Command_Enable = root["command_enable"] | true;
-    inverter.Command_Enable_Night = root["command_enable_night"] | true;
-    inverter.ReachableThreshold = root["reachable_threshold"] | REACHABLE_THRESHOLD;
-    inverter.ZeroRuntimeDataIfUnrechable = root["zero_runtime"] | false;
-    inverter.ZeroYieldDayOnMidnight = root["zero_day"] | false;
-    inverter.ClearEventlogOnMidnight = root["clear_eventlog"] | false;
-    inverter.YieldDayCorrection = root["yieldday_correction"] | false;
+        old_serial = inverter.Serial;
+        inverter.Serial = new_serial;
+        strncpy(inverter.Name, root["name"].as<String>().c_str(), INV_MAX_NAME_STRLEN);
 
-    uint8_t arrayCount = 0;
-    for (JsonVariant channel : channelArray) {
-        inverter.channel[arrayCount].MaxChannelPower = channel["max_power"].as<uint16_t>();
-        inverter.channel[arrayCount].YieldTotalOffset = channel["yield_total_offset"].as<float>();
-        strncpy(inverter.channel[arrayCount].Name, channel["name"] | "", sizeof(inverter.channel[arrayCount].Name));
-        arrayCount++;
+        inverter.Poll_Enable = root["poll_enable"] | true;
+        inverter.Poll_Enable_Night = root["poll_enable_night"] | true;
+        inverter.Command_Enable = root["command_enable"] | true;
+        inverter.Command_Enable_Night = root["command_enable_night"] | true;
+        inverter.ReachableThreshold = root["reachable_threshold"] | REACHABLE_THRESHOLD;
+        inverter.ZeroRuntimeDataIfUnrechable = root["zero_runtime"] | false;
+        inverter.ZeroYieldDayOnMidnight = root["zero_day"] | false;
+        inverter.ClearEventlogOnMidnight = root["clear_eventlog"] | false;
+        inverter.YieldDayCorrection = root["yieldday_correction"] | false;
+
+        uint8_t arrayCount = 0;
+        for (JsonVariant channel : channelArray) {
+            inverter.channel[arrayCount].MaxChannelPower = channel["max_power"].as<uint16_t>();
+            inverter.channel[arrayCount].YieldTotalOffset = channel["yield_total_offset"].as<float>();
+            strncpy(inverter.channel[arrayCount].Name, channel["name"] | "", sizeof(inverter.channel[arrayCount].Name));
+            arrayCount++;
+        }
     }
 
     WebApi.writeConfig(retMsg, WebApiError::InverterChanged, "Inverter changed!");
 
     WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
 
+    INVERTER_CONFIG_T const& inverter = Configuration.get().Inverter[root["id"].as<uint8_t>()];
     std::shared_ptr<InverterAbstract> inv = Hoymiles.getInverterBySerial(old_serial);
 
     if (inv != nullptr && new_serial != old_serial) {
@@ -269,6 +277,8 @@ void WebApiInverterClass::onInverterEdit(AsyncWebServerRequest* request)
     }
 
     MqttHandleHass.forceUpdate();
+
+    PowerLimiter.triggerReloadingConfig();
 }
 
 void WebApiInverterClass::onInverterDelete(AsyncWebServerRequest* request)
@@ -300,7 +310,7 @@ void WebApiInverterClass::onInverterDelete(AsyncWebServerRequest* request)
     }
 
     uint8_t inverter_id = root["id"].as<uint8_t>();
-    INVERTER_CONFIG_T& inverter = Configuration.get().Inverter[inverter_id];
+    INVERTER_CONFIG_T const& inverter = Configuration.get().Inverter[inverter_id];
 
     Hoymiles.removeInverterBySerial(inverter.Serial);
 
@@ -311,6 +321,8 @@ void WebApiInverterClass::onInverterDelete(AsyncWebServerRequest* request)
     WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
 
     MqttHandleHass.forceUpdate();
+
+    PowerLimiter.triggerReloadingConfig();
 }
 
 void WebApiInverterClass::onInverterOrder(AsyncWebServerRequest* request)
@@ -337,13 +349,18 @@ void WebApiInverterClass::onInverterOrder(AsyncWebServerRequest* request)
     // The order array contains list or id in the right order
     JsonArray orderArray = root["order"].as<JsonArray>();
     uint8_t order = 0;
-    for (JsonVariant id : orderArray) {
-        uint8_t inverter_id = id.as<uint8_t>();
-        if (inverter_id < INV_MAX_COUNT) {
-            INVERTER_CONFIG_T& inverter = Configuration.get().Inverter[inverter_id];
-            inverter.Order = order;
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+
+        for (JsonVariant id : orderArray) {
+            uint8_t inverter_id = id.as<uint8_t>();
+            if (inverter_id < INV_MAX_COUNT) {
+                INVERTER_CONFIG_T& inverter = config.Inverter[inverter_id];
+                inverter.Order = order;
+            }
+            order++;
         }
-        order++;
     }
 
     WebApi.writeConfig(retMsg, WebApiError::InverterOrdered, "Inverter order saved!");
diff --git a/src/WebApi_mqtt.cpp b/src/WebApi_mqtt.cpp
index 9f04d622..1d0c2ab1 100644
--- a/src/WebApi_mqtt.cpp
+++ b/src/WebApi_mqtt.cpp
@@ -282,42 +282,47 @@ void WebApiMqttClass::onMqttAdminPost(AsyncWebServerRequest* request)
         }
     }
 
-    CONFIG_T& config = Configuration.get();
-    config.Mqtt.Enabled = root["mqtt_enabled"].as<bool>();
-    config.Mqtt.VerboseLogging = root["mqtt_verbose_logging"].as<bool>();
-    config.Mqtt.Retain = root["mqtt_retain"].as<bool>();
-    config.Mqtt.Tls.Enabled = root["mqtt_tls"].as<bool>();
-    strlcpy(config.Mqtt.Tls.RootCaCert, root["mqtt_root_ca_cert"].as<String>().c_str(), sizeof(config.Mqtt.Tls.RootCaCert));
-    config.Mqtt.Tls.CertLogin = root["mqtt_tls_cert_login"].as<bool>();
-    strlcpy(config.Mqtt.Tls.ClientCert, root["mqtt_client_cert"].as<String>().c_str(), sizeof(config.Mqtt.Tls.ClientCert));
-    strlcpy(config.Mqtt.Tls.ClientKey, root["mqtt_client_key"].as<String>().c_str(), sizeof(config.Mqtt.Tls.ClientKey));
-    config.Mqtt.Port = root["mqtt_port"].as<uint>();
-    strlcpy(config.Mqtt.Hostname, root["mqtt_hostname"].as<String>().c_str(), sizeof(config.Mqtt.Hostname));
-    strlcpy(config.Mqtt.ClientId, root["mqtt_clientid"].as<String>().c_str(), sizeof(config.Mqtt.ClientId));
-    strlcpy(config.Mqtt.Username, root["mqtt_username"].as<String>().c_str(), sizeof(config.Mqtt.Username));
-    strlcpy(config.Mqtt.Password, root["mqtt_password"].as<String>().c_str(), sizeof(config.Mqtt.Password));
-    strlcpy(config.Mqtt.Lwt.Topic, root["mqtt_lwt_topic"].as<String>().c_str(), sizeof(config.Mqtt.Lwt.Topic));
-    strlcpy(config.Mqtt.Lwt.Value_Online, root["mqtt_lwt_online"].as<String>().c_str(), sizeof(config.Mqtt.Lwt.Value_Online));
-    strlcpy(config.Mqtt.Lwt.Value_Offline, root["mqtt_lwt_offline"].as<String>().c_str(), sizeof(config.Mqtt.Lwt.Value_Offline));
-    config.Mqtt.Lwt.Qos = root["mqtt_lwt_qos"].as<uint8_t>();
-    config.Mqtt.PublishInterval = root["mqtt_publish_interval"].as<uint32_t>();
-    config.Mqtt.CleanSession = root["mqtt_clean_session"].as<bool>();
-    config.Mqtt.Hass.Enabled = root["mqtt_hass_enabled"].as<bool>();
-    config.Mqtt.Hass.Expire = root["mqtt_hass_expire"].as<bool>();
-    config.Mqtt.Hass.Retain = root["mqtt_hass_retain"].as<bool>();
-    config.Mqtt.Hass.IndividualPanels = root["mqtt_hass_individualpanels"].as<bool>();
-    strlcpy(config.Mqtt.Hass.Topic, root["mqtt_hass_topic"].as<String>().c_str(), sizeof(config.Mqtt.Hass.Topic));
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
 
-    // Check if base topic was changed
-    if (strcmp(config.Mqtt.Topic, root["mqtt_topic"].as<String>().c_str())) {
-        MqttHandleInverter.unsubscribeTopics();
-        MqttHandleHuawei.unsubscribeTopics();
-        MqttHandlePowerLimiter.unsubscribeTopics();
+        config.Mqtt.Enabled = root["mqtt_enabled"].as<bool>();
+        config.Mqtt.VerboseLogging = root["mqtt_verbose_logging"].as<bool>();
+        config.Mqtt.Retain = root["mqtt_retain"].as<bool>();
+        config.Mqtt.Tls.Enabled = root["mqtt_tls"].as<bool>();
+        strlcpy(config.Mqtt.Tls.RootCaCert, root["mqtt_root_ca_cert"].as<String>().c_str(), sizeof(config.Mqtt.Tls.RootCaCert));
+        config.Mqtt.Tls.CertLogin = root["mqtt_tls_cert_login"].as<bool>();
+        strlcpy(config.Mqtt.Tls.ClientCert, root["mqtt_client_cert"].as<String>().c_str(), sizeof(config.Mqtt.Tls.ClientCert));
+        strlcpy(config.Mqtt.Tls.ClientKey, root["mqtt_client_key"].as<String>().c_str(), sizeof(config.Mqtt.Tls.ClientKey));
+        config.Mqtt.Port = root["mqtt_port"].as<uint>();
+        strlcpy(config.Mqtt.Hostname, root["mqtt_hostname"].as<String>().c_str(), sizeof(config.Mqtt.Hostname));
+        strlcpy(config.Mqtt.ClientId, root["mqtt_clientid"].as<String>().c_str(), sizeof(config.Mqtt.ClientId));
+        strlcpy(config.Mqtt.Username, root["mqtt_username"].as<String>().c_str(), sizeof(config.Mqtt.Username));
+        strlcpy(config.Mqtt.Password, root["mqtt_password"].as<String>().c_str(), sizeof(config.Mqtt.Password));
+        strlcpy(config.Mqtt.Lwt.Topic, root["mqtt_lwt_topic"].as<String>().c_str(), sizeof(config.Mqtt.Lwt.Topic));
+        strlcpy(config.Mqtt.Lwt.Value_Online, root["mqtt_lwt_online"].as<String>().c_str(), sizeof(config.Mqtt.Lwt.Value_Online));
+        strlcpy(config.Mqtt.Lwt.Value_Offline, root["mqtt_lwt_offline"].as<String>().c_str(), sizeof(config.Mqtt.Lwt.Value_Offline));
+        config.Mqtt.Lwt.Qos = root["mqtt_lwt_qos"].as<uint8_t>();
+        config.Mqtt.PublishInterval = root["mqtt_publish_interval"].as<uint32_t>();
+        config.Mqtt.CleanSession = root["mqtt_clean_session"].as<bool>();
+        config.Mqtt.Hass.Enabled = root["mqtt_hass_enabled"].as<bool>();
+        config.Mqtt.Hass.Expire = root["mqtt_hass_expire"].as<bool>();
+        config.Mqtt.Hass.Retain = root["mqtt_hass_retain"].as<bool>();
+        config.Mqtt.Hass.IndividualPanels = root["mqtt_hass_individualpanels"].as<bool>();
+        strlcpy(config.Mqtt.Hass.Topic, root["mqtt_hass_topic"].as<String>().c_str(), sizeof(config.Mqtt.Hass.Topic));
 
-        strlcpy(config.Mqtt.Topic, root["mqtt_topic"].as<String>().c_str(), sizeof(config.Mqtt.Topic));
-        MqttHandleInverter.subscribeTopics();
-        MqttHandleHuawei.subscribeTopics();
-        MqttHandlePowerLimiter.subscribeTopics();
+        // Check if base topic was changed
+        if (strcmp(config.Mqtt.Topic, root["mqtt_topic"].as<String>().c_str())) {
+            MqttHandleInverter.unsubscribeTopics();
+            MqttHandleHuawei.unsubscribeTopics();
+            MqttHandlePowerLimiter.unsubscribeTopics();
+
+            strlcpy(config.Mqtt.Topic, root["mqtt_topic"].as<String>().c_str(), sizeof(config.Mqtt.Topic));
+
+            MqttHandleInverter.subscribeTopics();
+            MqttHandleHuawei.subscribeTopics();
+            MqttHandlePowerLimiter.subscribeTopics();
+        }
     }
 
     WebApi.writeConfig(retMsg);
diff --git a/src/WebApi_network.cpp b/src/WebApi_network.cpp
index 98ebe23c..16a2f181 100644
--- a/src/WebApi_network.cpp
+++ b/src/WebApi_network.cpp
@@ -184,40 +184,45 @@ void WebApiNetworkClass::onNetworkAdminPost(AsyncWebServerRequest* request)
 
     }
 
-    CONFIG_T& config = Configuration.get();
-    config.WiFi.Ip[0] = ipaddress[0];
-    config.WiFi.Ip[1] = ipaddress[1];
-    config.WiFi.Ip[2] = ipaddress[2];
-    config.WiFi.Ip[3] = ipaddress[3];
-    config.WiFi.Netmask[0] = netmask[0];
-    config.WiFi.Netmask[1] = netmask[1];
-    config.WiFi.Netmask[2] = netmask[2];
-    config.WiFi.Netmask[3] = netmask[3];
-    config.WiFi.Gateway[0] = gateway[0];
-    config.WiFi.Gateway[1] = gateway[1];
-    config.WiFi.Gateway[2] = gateway[2];
-    config.WiFi.Gateway[3] = gateway[3];
-    config.WiFi.Dns1[0] = dns1[0];
-    config.WiFi.Dns1[1] = dns1[1];
-    config.WiFi.Dns1[2] = dns1[2];
-    config.WiFi.Dns1[3] = dns1[3];
-    config.WiFi.Dns2[0] = dns2[0];
-    config.WiFi.Dns2[1] = dns2[1];
-    config.WiFi.Dns2[2] = dns2[2];
-    config.WiFi.Dns2[3] = dns2[3];
-    strlcpy(config.WiFi.Ssid, root["ssid"].as<String>().c_str(), sizeof(config.WiFi.Ssid));
-    strlcpy(config.WiFi.Password, root["password"].as<String>().c_str(), sizeof(config.WiFi.Password));
-    strlcpy(config.WiFi.Hostname, root["hostname"].as<String>().c_str(), sizeof(config.WiFi.Hostname));
-    if (root["dhcp"].as<bool>()) {
-        config.WiFi.Dhcp = true;
-    } else {
-        config.WiFi.Dhcp = false;
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+
+        config.WiFi.Ip[0] = ipaddress[0];
+        config.WiFi.Ip[1] = ipaddress[1];
+        config.WiFi.Ip[2] = ipaddress[2];
+        config.WiFi.Ip[3] = ipaddress[3];
+        config.WiFi.Netmask[0] = netmask[0];
+        config.WiFi.Netmask[1] = netmask[1];
+        config.WiFi.Netmask[2] = netmask[2];
+        config.WiFi.Netmask[3] = netmask[3];
+        config.WiFi.Gateway[0] = gateway[0];
+        config.WiFi.Gateway[1] = gateway[1];
+        config.WiFi.Gateway[2] = gateway[2];
+        config.WiFi.Gateway[3] = gateway[3];
+        config.WiFi.Dns1[0] = dns1[0];
+        config.WiFi.Dns1[1] = dns1[1];
+        config.WiFi.Dns1[2] = dns1[2];
+        config.WiFi.Dns1[3] = dns1[3];
+        config.WiFi.Dns2[0] = dns2[0];
+        config.WiFi.Dns2[1] = dns2[1];
+        config.WiFi.Dns2[2] = dns2[2];
+        config.WiFi.Dns2[3] = dns2[3];
+        strlcpy(config.WiFi.Ssid, root["ssid"].as<String>().c_str(), sizeof(config.WiFi.Ssid));
+        strlcpy(config.WiFi.Password, root["password"].as<String>().c_str(), sizeof(config.WiFi.Password));
+        strlcpy(config.WiFi.Hostname, root["hostname"].as<String>().c_str(), sizeof(config.WiFi.Hostname));
+        if (root["dhcp"].as<bool>()) {
+            config.WiFi.Dhcp = true;
+        } else {
+            config.WiFi.Dhcp = false;
+        }
+        config.WiFi.ApTimeout = root["aptimeout"].as<uint>();
+        config.Mdns.Enabled = root["mdnsenabled"].as<bool>();
+
+        config.Syslog.Enabled = root["syslogenabled"].as<bool>();
+        strlcpy(config.Syslog.Hostname, root["sysloghostname"].as<String>().c_str(), sizeof(config.Syslog.Hostname));
+        config.Syslog.Port = root["syslogport"].as<uint>();
     }
-    config.WiFi.ApTimeout = root["aptimeout"].as<uint>();
-    config.Mdns.Enabled = root["mdnsenabled"].as<bool>();
-    config.Syslog.Enabled = root["syslogenabled"].as<bool>();
-    strlcpy(config.Syslog.Hostname, root["sysloghostname"].as<String>().c_str(), sizeof(config.Syslog.Hostname));
-    config.Syslog.Port = root["syslogport"].as<uint>();
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_ntp.cpp b/src/WebApi_ntp.cpp
index 5dc874b5..f58a2bbd 100644
--- a/src/WebApi_ntp.cpp
+++ b/src/WebApi_ntp.cpp
@@ -135,13 +135,17 @@ void WebApiNtpClass::onNtpAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    CONFIG_T& config = Configuration.get();
-    strlcpy(config.Ntp.Server, root["ntp_server"].as<String>().c_str(), sizeof(config.Ntp.Server));
-    strlcpy(config.Ntp.Timezone, root["ntp_timezone"].as<String>().c_str(), sizeof(config.Ntp.Timezone));
-    strlcpy(config.Ntp.TimezoneDescr, root["ntp_timezone_descr"].as<String>().c_str(), sizeof(config.Ntp.TimezoneDescr));
-    config.Ntp.Latitude = root["latitude"].as<double>();
-    config.Ntp.Longitude = root["longitude"].as<double>();
-    config.Ntp.SunsetType = root["sunsettype"].as<uint8_t>();
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+
+        strlcpy(config.Ntp.Server, root["ntp_server"].as<String>().c_str(), sizeof(config.Ntp.Server));
+        strlcpy(config.Ntp.Timezone, root["ntp_timezone"].as<String>().c_str(), sizeof(config.Ntp.Timezone));
+        strlcpy(config.Ntp.TimezoneDescr, root["ntp_timezone_descr"].as<String>().c_str(), sizeof(config.Ntp.TimezoneDescr));
+        config.Ntp.Latitude = root["latitude"].as<double>();
+        config.Ntp.Longitude = root["longitude"].as<double>();
+        config.Ntp.SunsetType = root["sunsettype"].as<uint8_t>();
+    }
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_powerlimiter.cpp b/src/WebApi_powerlimiter.cpp
index 89e671d8..8301c738 100644
--- a/src/WebApi_powerlimiter.cpp
+++ b/src/WebApi_powerlimiter.cpp
@@ -12,6 +12,7 @@
 #include "WebApi.h"
 #include "helper.h"
 #include "WebApi_errors.h"
+#include "Configuration.h"
 
 void WebApiPowerLimiterClass::init(AsyncWebServer& server, Scheduler& scheduler)
 {
@@ -27,36 +28,14 @@ void WebApiPowerLimiterClass::init(AsyncWebServer& server, Scheduler& scheduler)
 
 void WebApiPowerLimiterClass::onStatus(AsyncWebServerRequest* request)
 {
+    if (!WebApi.checkCredentialsReadonly(request)) {
+        return;
+    }
+
     AsyncJsonResponse* response = new AsyncJsonResponse();
-    auto& root = response->getRoot();
+    auto root = response->getRoot().as<JsonObject>();
     auto const& config = Configuration.get();
-
-    root["enabled"] = config.PowerLimiter.Enabled;
-    root["verbose_logging"] = config.PowerLimiter.VerboseLogging;
-    root["solar_passthrough_enabled"] = config.PowerLimiter.SolarPassThroughEnabled;
-    root["solar_passthrough_losses"] = config.PowerLimiter.SolarPassThroughLosses;
-    root["battery_always_use_at_night"] = config.PowerLimiter.BatteryAlwaysUseAtNight;
-    root["is_inverter_behind_powermeter"] = config.PowerLimiter.IsInverterBehindPowerMeter;
-    root["is_inverter_solar_powered"] = config.PowerLimiter.IsInverterSolarPowered;
-    root["use_overscaling_to_compensate_shading"] = config.PowerLimiter.UseOverscalingToCompensateShading;
-    root["inverter_serial"] = String(config.PowerLimiter.InverterId);
-    root["inverter_channel_id"] = config.PowerLimiter.InverterChannelId;
-    root["target_power_consumption"] = config.PowerLimiter.TargetPowerConsumption;
-    root["target_power_consumption_hysteresis"] = config.PowerLimiter.TargetPowerConsumptionHysteresis;
-    root["lower_power_limit"] = config.PowerLimiter.LowerPowerLimit;
-    root["base_load_limit"] = config.PowerLimiter.BaseLoadLimit;
-    root["upper_power_limit"] = config.PowerLimiter.UpperPowerLimit;
-    root["ignore_soc"] = config.PowerLimiter.IgnoreSoc;
-    root["battery_soc_start_threshold"] = config.PowerLimiter.BatterySocStartThreshold;
-    root["battery_soc_stop_threshold"] = config.PowerLimiter.BatterySocStopThreshold;
-    root["voltage_start_threshold"] = static_cast<int>(config.PowerLimiter.VoltageStartThreshold * 100 +0.5) / 100.0;
-    root["voltage_stop_threshold"] = static_cast<int>(config.PowerLimiter.VoltageStopThreshold * 100 +0.5) / 100.0;;
-    root["voltage_load_correction_factor"] = config.PowerLimiter.VoltageLoadCorrectionFactor;
-    root["inverter_restart_hour"] = config.PowerLimiter.RestartHour;
-    root["full_solar_passthrough_soc"] = config.PowerLimiter.FullSolarPassThroughSoc;
-    root["full_solar_passthrough_start_voltage"] = static_cast<int>(config.PowerLimiter.FullSolarPassThroughStartVoltage * 100 + 0.5) / 100.0;
-    root["full_solar_passthrough_stop_voltage"] = static_cast<int>(config.PowerLimiter.FullSolarPassThroughStopVoltage * 100 + 0.5) / 100.0;
-
+    ConfigurationClass::serializePowerLimiterConfig(config.PowerLimiter, root);
     WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
 }
 
@@ -66,11 +45,6 @@ void WebApiPowerLimiterClass::onMetaData(AsyncWebServerRequest* request)
 
     auto const& config = Configuration.get();
 
-    size_t invAmount = 0;
-    for (uint8_t i = 0; i < INV_MAX_COUNT; i++) {
-        if (config.Inverter[i].Serial != 0) { ++invAmount; }
-    }
-
     AsyncJsonResponse* response = new AsyncJsonResponse();
     auto& root = response->getRoot();
 
@@ -78,30 +52,24 @@ void WebApiPowerLimiterClass::onMetaData(AsyncWebServerRequest* request)
     root["battery_enabled"] = config.Battery.Enabled;
     root["charge_controller_enabled"] = config.Vedirect.Enabled;
 
-    JsonObject inverters = root["inverters"].to<JsonObject>();
+    JsonArray inverters = root["inverters"].to<JsonArray>();
     for (uint8_t i = 0; i < INV_MAX_COUNT; i++) {
-        if (config.Inverter[i].Serial == 0) { continue; }
+        auto inv = Hoymiles.getInverterBySerial(config.Inverter[i].Serial);
+        if (!inv) { continue; }
 
-        // we use the integer (base 10) representation of the inverter serial,
-        // rather than the hex represenation as used when handling the inverter
-        // serial elsewhere in the web application, because in this case, the
-        // serial is actually not displayed but only used as a value/index.
-        JsonObject obj = inverters[String(config.Inverter[i].Serial)].to<JsonObject>();
+        JsonObject obj = inverters.add<JsonObject>();
+        obj["serial"] = inv->serialString();
         obj["pos"] = i;
+        obj["order"] = config.Inverter[i].Order;
         obj["name"] = String(config.Inverter[i].Name);
         obj["poll_enable"] = config.Inverter[i].Poll_Enable;
         obj["poll_enable_night"] = config.Inverter[i].Poll_Enable_Night;
         obj["command_enable"] = config.Inverter[i].Command_Enable;
         obj["command_enable_night"] = config.Inverter[i].Command_Enable_Night;
-
-        obj["type"] = "Unknown";
-        obj["channels"] = 1;
-        auto inv = Hoymiles.getInverterBySerial(config.Inverter[i].Serial);
-        if (inv != nullptr) {
-            obj["type"] = inv->typeName();
-            auto channels = inv->Statistics()->getChannelsByType(TYPE_DC);
-            obj["channels"] = channels.size();
-        }
+        obj["max_power"] = inv->DevInfo()->getMaxPower(); // okay if zero/unknown
+        obj["type"] = inv->typeName();
+        auto channels = inv->Statistics()->getChannelsByType(TYPE_DC);
+        obj["channels"] = channels.size();
     }
 
     WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
@@ -130,67 +98,18 @@ void WebApiPowerLimiterClass::onAdminPost(AsyncWebServerRequest* request)
 
     auto& retMsg = response->getRoot();
 
-    // we were not actually checking for all the keys we (unconditionally)
-    // access below for a long time, and it is technically not needed if users
-    // use the web application to submit settings. the web app will always
-    // submit all keys. users who send HTTP requests manually need to beware
-    // anyways to always include the keys accessed below. if we wanted to
-    // support a simpler API, like only sending the "enabled" key which only
-    // changes that key, we need to refactor all of the code below.
-    if (!root["enabled"].is<bool>()) {
-        retMsg["message"] = "Values are missing!";
-        retMsg["code"] = WebApiError::GenericValueMissing;
-        response->setLength();
-        request->send(response);
-        return;
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+        ConfigurationClass::deserializePowerLimiterConfig(root.as<JsonObject>(), config.PowerLimiter);
     }
 
-    CONFIG_T& config = Configuration.get();
-    config.PowerLimiter.Enabled = root["enabled"].as<bool>();
-    PowerLimiter.setMode(PowerLimiterClass::Mode::Normal);  // User input sets PL to normal operation
-    config.PowerLimiter.VerboseLogging = root["verbose_logging"].as<bool>();
-
-    if (config.Vedirect.Enabled) {
-        config.PowerLimiter.SolarPassThroughEnabled = root["solar_passthrough_enabled"].as<bool>();
-        config.PowerLimiter.SolarPassThroughLosses = root["solar_passthrough_losses"].as<uint8_t>();
-        config.PowerLimiter.FullSolarPassThroughStartVoltage = static_cast<int>(root["full_solar_passthrough_start_voltage"].as<float>() * 100) / 100.0;
-        config.PowerLimiter.FullSolarPassThroughStopVoltage = static_cast<int>(root["full_solar_passthrough_stop_voltage"].as<float>() * 100) / 100.0;
-    }
-
-    config.PowerLimiter.IsInverterBehindPowerMeter = root["is_inverter_behind_powermeter"].as<bool>();
-    config.PowerLimiter.IsInverterSolarPowered = root["is_inverter_solar_powered"].as<bool>();
-    config.PowerLimiter.BatteryAlwaysUseAtNight = root["battery_always_use_at_night"].as<bool>();
-    config.PowerLimiter.UseOverscalingToCompensateShading = root["use_overscaling_to_compensate_shading"].as<bool>();
-    config.PowerLimiter.InverterId = root["inverter_serial"].as<uint64_t>();
-    config.PowerLimiter.InverterChannelId = root["inverter_channel_id"].as<uint8_t>();
-    config.PowerLimiter.TargetPowerConsumption = root["target_power_consumption"].as<int32_t>();
-    config.PowerLimiter.TargetPowerConsumptionHysteresis = root["target_power_consumption_hysteresis"].as<int32_t>();
-    config.PowerLimiter.LowerPowerLimit = root["lower_power_limit"].as<int32_t>();
-    config.PowerLimiter.BaseLoadLimit = root["base_load_limit"].as<int32_t>();
-    config.PowerLimiter.UpperPowerLimit = root["upper_power_limit"].as<int32_t>();
-
-    if (config.Battery.Enabled) {
-        config.PowerLimiter.IgnoreSoc = root["ignore_soc"].as<bool>();
-        config.PowerLimiter.BatterySocStartThreshold = root["battery_soc_start_threshold"].as<uint32_t>();
-        config.PowerLimiter.BatterySocStopThreshold = root["battery_soc_stop_threshold"].as<uint32_t>();
-        if (config.Vedirect.Enabled) {
-            config.PowerLimiter.FullSolarPassThroughSoc = root["full_solar_passthrough_soc"].as<uint32_t>();
-        }
-    }
-
-    config.PowerLimiter.VoltageStartThreshold = root["voltage_start_threshold"].as<float>();
-    config.PowerLimiter.VoltageStartThreshold = static_cast<int>(config.PowerLimiter.VoltageStartThreshold * 100) / 100.0;
-    config.PowerLimiter.VoltageStopThreshold = root["voltage_stop_threshold"].as<float>();
-    config.PowerLimiter.VoltageStopThreshold = static_cast<int>(config.PowerLimiter.VoltageStopThreshold * 100) / 100.0;
-    config.PowerLimiter.VoltageLoadCorrectionFactor = root["voltage_load_correction_factor"].as<float>();
-    config.PowerLimiter.RestartHour = root["inverter_restart_hour"].as<int8_t>();
-
     WebApi.writeConfig(retMsg);
 
     response->setLength();
     request->send(response);
 
-    PowerLimiter.calcNextInverterRestart();
+    PowerLimiter.triggerReloadingConfig();
 
     // potentially make thresholds auto-discoverable
     MqttHandlePowerLimiterHass.forceUpdate();
diff --git a/src/WebApi_powermeter.cpp b/src/WebApi_powermeter.cpp
index d27fd65d..911bcd39 100644
--- a/src/WebApi_powermeter.cpp
+++ b/src/WebApi_powermeter.cpp
@@ -38,7 +38,7 @@ void WebApiPowerMeterClass::onStatus(AsyncWebServerRequest* request)
 
     AsyncJsonResponse* response = new AsyncJsonResponse();
     auto& root = response->getRoot();
-    const CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     root["enabled"] = config.PowerMeter.Enabled;
     root["verbose_logging"] = config.PowerMeter.VerboseLogging;
@@ -151,22 +151,25 @@ void WebApiPowerMeterClass::onAdminPost(AsyncWebServerRequest* request)
         }
     }
 
-    CONFIG_T& config = Configuration.get();
-    config.PowerMeter.Enabled = root["enabled"].as<bool>();
-    config.PowerMeter.VerboseLogging = root["verbose_logging"].as<bool>();
-    config.PowerMeter.Source = root["source"].as<uint8_t>();
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+        config.PowerMeter.Enabled = root["enabled"].as<bool>();
+        config.PowerMeter.VerboseLogging = root["verbose_logging"].as<bool>();
+        config.PowerMeter.Source = root["source"].as<uint8_t>();
 
-    Configuration.deserializePowerMeterMqttConfig(root["mqtt"].as<JsonObject>(),
-            config.PowerMeter.Mqtt);
+        Configuration.deserializePowerMeterMqttConfig(root["mqtt"].as<JsonObject>(),
+                config.PowerMeter.Mqtt);
 
-    Configuration.deserializePowerMeterSerialSdmConfig(root["serial_sdm"].as<JsonObject>(),
-            config.PowerMeter.SerialSdm);
+        Configuration.deserializePowerMeterSerialSdmConfig(root["serial_sdm"].as<JsonObject>(),
+                config.PowerMeter.SerialSdm);
 
-    Configuration.deserializePowerMeterHttpJsonConfig(root["http_json"].as<JsonObject>(),
-            config.PowerMeter.HttpJson);
+        Configuration.deserializePowerMeterHttpJsonConfig(root["http_json"].as<JsonObject>(),
+                config.PowerMeter.HttpJson);
 
-    Configuration.deserializePowerMeterHttpSmlConfig(root["http_sml"].as<JsonObject>(),
-            config.PowerMeter.HttpSml);
+        Configuration.deserializePowerMeterHttpSmlConfig(root["http_sml"].as<JsonObject>(),
+                config.PowerMeter.HttpSml);
+    }
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_security.cpp b/src/WebApi_security.cpp
index 6be21ca6..8ebd6fb6 100644
--- a/src/WebApi_security.cpp
+++ b/src/WebApi_security.cpp
@@ -64,9 +64,13 @@ void WebApiSecurityClass::onSecurityPost(AsyncWebServerRequest* request)
         return;
     }
 
-    CONFIG_T& config = Configuration.get();
-    strlcpy(config.Security.Password, root["password"].as<String>().c_str(), sizeof(config.Security.Password));
-    config.Security.AllowReadonly = root["allow_readonly"].as<bool>();
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+
+        strlcpy(config.Security.Password, root["password"].as<String>().c_str(), sizeof(config.Security.Password));
+        config.Security.AllowReadonly = root["allow_readonly"].as<bool>();
+    }
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_vedirect.cpp b/src/WebApi_vedirect.cpp
index 653ab8ca..06493ab8 100644
--- a/src/WebApi_vedirect.cpp
+++ b/src/WebApi_vedirect.cpp
@@ -31,7 +31,7 @@ void WebApiVedirectClass::onVedirectStatus(AsyncWebServerRequest* request)
     
     AsyncJsonResponse* response = new AsyncJsonResponse();
     auto& root = response->getRoot();
-    const CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     root["vedirect_enabled"] = config.Vedirect.Enabled;
     root["verbose_logging"] = config.Vedirect.VerboseLogging;
@@ -49,7 +49,7 @@ void WebApiVedirectClass::onVedirectAdminGet(AsyncWebServerRequest* request)
 
     AsyncJsonResponse* response = new AsyncJsonResponse();
     auto& root = response->getRoot();
-    const CONFIG_T& config = Configuration.get();
+    auto const& config = Configuration.get();
 
     root["vedirect_enabled"] = config.Vedirect.Enabled;
     root["verbose_logging"] = config.Vedirect.VerboseLogging;
@@ -83,10 +83,13 @@ void WebApiVedirectClass::onVedirectAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    CONFIG_T& config = Configuration.get();
-    config.Vedirect.Enabled = root["vedirect_enabled"].as<bool>();
-    config.Vedirect.VerboseLogging = root["verbose_logging"].as<bool>();
-    config.Vedirect.UpdatesOnly = root["vedirect_updatesonly"].as<bool>();
+    {
+        auto guard = Configuration.getWriteGuard();
+        auto& config = guard.getConfig();
+        config.Vedirect.Enabled = root["vedirect_enabled"].as<bool>();
+        config.Vedirect.VerboseLogging = root["verbose_logging"].as<bool>();
+        config.Vedirect.UpdatesOnly = root["vedirect_updatesonly"].as<bool>();
+    }
 
     WebApi.writeConfig(retMsg);
 
diff --git a/src/WebApi_ws_vedirect_live.cpp b/src/WebApi_ws_vedirect_live.cpp
index 2a539af7..5189d0b3 100644
--- a/src/WebApi_ws_vedirect_live.cpp
+++ b/src/WebApi_ws_vedirect_live.cpp
@@ -154,7 +154,7 @@ void WebApiWsVedirectLiveClass::generateCommonJsonResponse(JsonVariant& root, bo
     root["dpl"]["PLSTATE"] = -1;
     if (Configuration.get().PowerLimiter.Enabled)
         root["dpl"]["PLSTATE"] = PowerLimiter.getPowerLimiterState();
-    root["dpl"]["PLLIMIT"] = PowerLimiter.getLastRequestedPowerLimit();
+    root["dpl"]["PLLIMIT"] = PowerLimiter.getInverterOutput();
 }
 
 void WebApiWsVedirectLiveClass::populateJson(const JsonObject &root, const VeDirectMpptController::data_t &mpptData) {
@@ -164,10 +164,26 @@ void WebApiWsVedirectLiveClass::populateJson(const JsonObject &root, const VeDir
     const JsonObject values = root["values"].to<JsonObject>();
 
     const JsonObject device = values["device"].to<JsonObject>();
-    device["LOAD"] = mpptData.loadOutputState_LOAD ? "ON" : "OFF";
+
+    // LOAD     IL      UI label    result
+    // ------------------------------------
+    // false    false               Do not display LOAD and IL (device has no physical load output and virtual load is not configured)
+    // true     false   "VIRTLOAD"  We display just LOAD (device has no physical load output and virtual load is configured)
+    // true     true    "LOAD"      We display LOAD and IL (device has physical load output, regardless if virtual load is configured or not)
+    if (mpptData.loadOutputState_LOAD.first > 0) {
+        device[(mpptData.loadCurrent_IL_mA.first > 0) ? "LOAD" : "VIRTLOAD"] = mpptData.loadOutputState_LOAD.second ? "ON" : "OFF";
+    }
+    if (mpptData.loadCurrent_IL_mA.first > 0) {
+        device["IL"]["v"] = mpptData.loadCurrent_IL_mA.second / 1000.0;
+        device["IL"]["u"] = "A";
+        device["IL"]["d"] = 2;
+    }
     device["CS"] = mpptData.getCsAsString();
     device["MPPT"] = mpptData.getMpptAsString();
     device["OR"] = mpptData.getOrAsString();
+    if (mpptData.relayState_RELAY.first > 0) {
+        device["RELAY"] = mpptData.relayState_RELAY.second ? "ON" : "OFF";
+    }
     device["ERR"] = mpptData.getErrAsString();
     device["HSDS"]["v"] = mpptData.daySequenceNr_HSDS;
     device["HSDS"]["u"] = "d";
@@ -195,6 +211,16 @@ void WebApiWsVedirectLiveClass::populateJson(const JsonObject &root, const VeDir
         output["SBSTemperature"]["u"] = "°C";
         output["SBSTemperature"]["d"] = "0";
     }
+    if (mpptData.BatteryAbsorptionMilliVolt.first > 0) {
+        output["AbsorptionVoltage"]["v"] = mpptData.BatteryAbsorptionMilliVolt.second / 1000.0;
+        output["AbsorptionVoltage"]["u"] = "V";
+        output["AbsorptionVoltage"]["d"] = "2";
+    }
+    if (mpptData.BatteryFloatMilliVolt.first > 0) {
+        output["FloatVoltage"]["v"] = mpptData.BatteryFloatMilliVolt.second / 1000.0;
+        output["FloatVoltage"]["u"] = "V";
+        output["FloatVoltage"]["d"] = "2";
+    }
 
     const JsonObject input = values["input"].to<JsonObject>();
     if (mpptData.NetworkTotalDcInputPowerMilliWatts.first > 0) {
diff --git a/src/main.cpp b/src/main.cpp
index 00d38bb3..f9a042c8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -5,6 +5,7 @@
 #include "Configuration.h"
 #include "Datastore.h"
 #include "Display_Graphic.h"
+#include "I18n.h"
 #include "InverterSettings.h"
 #include "Led_Single.h"
 #include "MessageOutput.h"
@@ -36,11 +37,9 @@
 #include "defaults.h"
 #include <Arduino.h>
 #include <LittleFS.h>
+#include <SpiManager.h>
 #include <TaskScheduler.h>
 #include <esp_heap_caps.h>
-#include <SpiManager.h>
-
-#include <driver/uart.h>
 
 void setup()
 {
@@ -78,10 +77,9 @@ void setup()
     }
 
     // Read configuration values
+    Configuration.init(scheduler);
     MessageOutput.print("Reading configuration... ");
     if (!Configuration.read()) {
-        MessageOutput.print("initializing... ");
-        Configuration.init();
         if (Configuration.write()) {
             MessageOutput.print("written... ");
         } else {
@@ -95,6 +93,11 @@ void setup()
     auto& config = Configuration.get();
     MessageOutput.println("done");
 
+    // Read languate pack
+    MessageOutput.print("Reading language pack... ");
+    I18n.init(scheduler);
+    MessageOutput.println("done");
+
     // Load PinMapping
     MessageOutput.print("Reading PinMapping... ");
     if (PinMapping.init(String(Configuration.get().Dev_PinMapping))) {
@@ -157,7 +160,7 @@ void setup()
     Display.enablePowerSafe = config.Display.PowerSafe;
     Display.enableScreensaver = config.Display.ScreenSaver;
     Display.setContrast(config.Display.Contrast);
-    Display.setLanguage(config.Display.Language);
+    Display.setLocale(config.Display.Locale);
     Display.setStartupDisplay();
     MessageOutput.println("done");
 
@@ -166,19 +169,6 @@ void setup()
     LedSingle.init(scheduler);
     MessageOutput.println("done");
 
-    // Check for default DTU serial
-    MessageOutput.print("Check for default DTU serial... ");
-    if (config.Dtu.Serial == DTU_SERIAL) {
-        MessageOutput.print("generate serial based on ESP chip id: ");
-        const uint64_t dtuId = Utils::generateDtuSerial();
-        MessageOutput.printf("%0" PRIx32 "%08" PRIx32 "... ",
-            ((uint32_t)((dtuId >> 32) & 0xFFFFFFFF)),
-            ((uint32_t)(dtuId & 0xFFFFFFFF)));
-        config.Dtu.Serial = dtuId;
-        Configuration.write();
-    }
-    MessageOutput.println("done");
-
     InverterSettings.init(scheduler);
 
     Datastore.init(scheduler);
diff --git a/webapp/index.html b/webapp/index.html
index bbb68b54..c9038613 100644
--- a/webapp/index.html
+++ b/webapp/index.html
@@ -11,7 +11,7 @@
   </head>
   <body>
     <noscript>
-        <strong>We're sorry but OpenDTU doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
+        <strong>We're sorry but OpenDTU-OnBattery doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
     </noscript>
     <div id="app"></div>
     <script type="module" src="/src/main.ts"></script>
diff --git a/webapp/package.json b/webapp/package.json
index 05489324..a646f6c0 100644
--- a/webapp/package.json
+++ b/webapp/package.json
@@ -27,25 +27,25 @@
     "@intlify/unplugin-vue-i18n": "^5.2.0",
     "@tsconfig/node22": "^22.0.0",
     "@types/bootstrap": "^5.2.10",
-    "@types/node": "^22.7.4",
+    "@types/node": "^22.9.0",
     "@types/pulltorefreshjs": "^0.1.7",
     "@types/sortablejs": "^1.15.8",
-    "@types/spark-md5": "^3.0.4",
+    "@types/spark-md5": "^3.0.5",
     "@vitejs/plugin-vue": "^5.1.4",
-    "@vue/eslint-config-typescript": "^14.1.1",
+    "@vue/eslint-config-typescript": "^14.1.3",
     "@vue/tsconfig": "^0.5.1",
-    "eslint": "^9.12.0",
-    "eslint-plugin-vue": "^9.29.0",
+    "eslint": "^9.14.0",
+    "eslint-plugin-vue": "^9.30.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.3.3",
     "pulltorefreshjs": "^0.1.22",
     "sass": "=1.77.6",
-    "terser": "^5.34.1",
+    "terser": "^5.36.0",
     "typescript": "^5.6.3",
-    "vite": "^5.4.9",
+    "vite": "^5.4.10",
     "vite-plugin-compression": "^0.5.1",
     "vite-plugin-css-injected-by-js": "^3.5.2",
-    "vue-tsc": "^2.1.6"
+    "vue-tsc": "^2.1.10"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }
diff --git a/webapp/src/App.vue b/webapp/src/App.vue
index 200ce669..8c5f2f98 100644
--- a/webapp/src/App.vue
+++ b/webapp/src/App.vue
@@ -18,7 +18,7 @@ export default defineComponent({
 <style>
 /* Show it is fixed to the top */
 body {
-    min-height: 75rem;
+    padding-bottom: 1rem;
     padding-top: 4.5rem;
 }
 </style>
diff --git a/webapp/src/components/BasePage.vue b/webapp/src/components/BasePage.vue
index 4ac0f80e..d94e3219 100644
--- a/webapp/src/components/BasePage.vue
+++ b/webapp/src/components/BasePage.vue
@@ -1,9 +1,9 @@
 <template>
     <div :class="{ 'container-xxl': !isWideScreen, 'container-fluid': isWideScreen }" role="main">
         <div class="page-header">
-            <div class="row">
-                <div class="col-sm-11">
-                    <h1>
+            <div class="row mb-3">
+                <div :class="'align-content-center ' + (showReload ? 'col-10' : 'col-12')">
+                    <h1 class="mb-0">
                         {{ title }}
                         <span
                             v-if="showWebSocket"
@@ -14,10 +14,10 @@
                         ></span>
                     </h1>
                 </div>
-                <div class="col-sm-1" v-if="showReload">
+                <div class="col-2 align-content-center" v-if="showReload">
                     <button
                         type="button"
-                        class="float-end btn btn-outline-primary"
+                        class="float-end btn btn-outline-primary fs-5"
                         @click="$emit('reload')"
                         v-tooltip
                         :title="$t('base.Reload')"
diff --git a/webapp/src/components/BatteryView.vue b/webapp/src/components/BatteryView.vue
index d7a9665d..78e15128 100644
--- a/webapp/src/components/BatteryView.vue
+++ b/webapp/src/components/BatteryView.vue
@@ -45,7 +45,7 @@
                                 v-bind:key="section"
                                 class="col order-0"
                             >
-                                <div class="card" :class="{ 'border-info': true }">
+                                <div class="card card-table" :class="{ 'border-info': true }">
                                     <div class="card-header text-bg-info">{{ $t('battery.' + section) }}</div>
                                     <div class="card-body">
                                         <div class="table-responsive">
@@ -53,7 +53,7 @@
                                                 <thead>
                                                     <tr>
                                                         <th scope="col">{{ $t('battery.Property') }}</th>
-                                                        <th style="text-align: right" scope="col">
+                                                        <th class="value" scope="col">
                                                             {{ $t('battery.Value') }}
                                                         </th>
                                                         <th scope="col">{{ $t('battery.Unit') }}</th>
@@ -62,7 +62,7 @@
                                                 <tbody>
                                                     <tr v-for="(prop, key) in values" v-bind:key="key">
                                                         <th scope="row">{{ $t('battery.' + key) }}</th>
-                                                        <td style="text-align: right">
+                                                        <td class="value">
                                                             <template v-if="isStringValue(prop) && prop.translate">
                                                                 {{ $t('battery.' + prop.value) }}
                                                             </template>
@@ -91,7 +91,7 @@
                                 </div>
                             </div>
                             <div class="col order-1" v-show="batteryData.showIssues">
-                                <div class="card">
+                                <div class="card card-table">
                                     <div :class="{ 'card-header': true, 'border-bottom-0': maxIssueValue === 0 }">
                                         <div class="d-flex flex-row justify-content-between align-items-baseline">
                                             {{ $t('battery.issues') }}
diff --git a/webapp/src/components/CardElement.vue b/webapp/src/components/CardElement.vue
index e7027367..28a0fd53 100644
--- a/webapp/src/components/CardElement.vue
+++ b/webapp/src/components/CardElement.vue
@@ -1,5 +1,5 @@
 <template>
-    <div :class="['card', addSpace ? 'mt-5' : '']">
+    <div :class="['card', table ? 'card-table' : '', addSpace ? 'mt-5' : '']">
         <div :class="['card-header', textVariant]">{{ text }}</div>
         <div :class="['card-body', 'card-text', centerContent ? 'text-center' : '', flexChildren ? 'd-flex' : '']">
             <slot />
@@ -14,6 +14,7 @@ export default defineComponent({
     props: {
         text: String,
         textVariant: String,
+        table: Boolean,
         addSpace: Boolean,
         centerContent: Boolean,
         flexChildren: Boolean,
diff --git a/webapp/src/components/FirmwareInfo.vue b/webapp/src/components/FirmwareInfo.vue
index e1f5d1ef..e49c2c7e 100644
--- a/webapp/src/components/FirmwareInfo.vue
+++ b/webapp/src/components/FirmwareInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('firmwareinfo.FirmwareInformation')" textVariant="text-bg-primary">
+    <CardElement :text="$t('firmwareinfo.FirmwareInformation')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/FormFooter.vue b/webapp/src/components/FormFooter.vue
index d91b8bc6..3df3e3fc 100644
--- a/webapp/src/components/FormFooter.vue
+++ b/webapp/src/components/FormFooter.vue
@@ -7,3 +7,9 @@
         <button type="submit" class="btn btn-primary">{{ $t('base.Save') }}</button>
     </div>
 </template>
+
+<script lang="ts">
+export default {
+    emits: ['reload'],
+};
+</script>
diff --git a/webapp/src/components/GridProfile.vue b/webapp/src/components/GridProfile.vue
index 8385dd47..a9e7f26d 100644
--- a/webapp/src/components/GridProfile.vue
+++ b/webapp/src/components/GridProfile.vue
@@ -19,7 +19,11 @@
         </table>
 
         <div class="accordion" id="accordionProfile">
-            <div class="accordion-item" v-for="(section, index) in gridProfileList.sections" :key="index">
+            <div
+                class="accordion-item accordion-table"
+                v-for="(section, index) in gridProfileList.sections"
+                :key="index"
+            >
                 <h2 class="accordion-header">
                     <button
                         class="accordion-button collapsed"
diff --git a/webapp/src/components/HardwareInfo.vue b/webapp/src/components/HardwareInfo.vue
index 372eeff0..982549d6 100644
--- a/webapp/src/components/HardwareInfo.vue
+++ b/webapp/src/components/HardwareInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('hardwareinfo.HardwareInformation')" textVariant="text-bg-primary">
+    <CardElement :text="$t('hardwareinfo.HardwareInformation')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/HeapDetails.vue b/webapp/src/components/HeapDetails.vue
index bb2c8a27..32d2ffd6 100644
--- a/webapp/src/components/HeapDetails.vue
+++ b/webapp/src/components/HeapDetails.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('heapdetails.HeapDetails')" textVariant="text-bg-primary">
+    <CardElement :text="$t('heapdetails.HeapDetails')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/HttpRequestSettings.vue b/webapp/src/components/HttpRequestSettings.vue
index 66b252ef..ef15ce56 100644
--- a/webapp/src/components/HttpRequestSettings.vue
+++ b/webapp/src/components/HttpRequestSettings.vue
@@ -1,70 +1,68 @@
 <template>
-    <div>
-        <InputElement
-            :label="$t('httprequestsettings.url')"
-            v-model="cfg.url"
-            type="text"
-            maxlength="1024"
-            placeholder="http://admin:supersecret@mypowermeter.home/status"
-            prefix="GET "
-            :tooltip="$t('httprequestsettings.urlDescription')"
-            wide
-        />
+    <InputElement
+        :label="$t('httprequestsettings.url')"
+        v-model="cfg.url"
+        type="text"
+        maxlength="1024"
+        placeholder="http://admin:supersecret@mypowermeter.home/status"
+        prefix="GET "
+        :tooltip="$t('httprequestsettings.urlDescription')"
+        wide
+    />
 
-        <div class="row mb-3">
-            <label for="auth_type" class="col-sm-4 col-form-label">{{ $t('httprequestsettings.authorization') }}</label>
-            <div class="col-sm-8">
-                <select id="auth_type" class="form-select" v-model="cfg.auth_type">
-                    <option v-for="a in authTypeList" :key="a.key" :value="a.key">
-                        {{ $t('httprequestsettings.authType' + a.value) }}
-                    </option>
-                </select>
-            </div>
+    <div class="row mb-3">
+        <label for="auth_type" class="col-sm-4 col-form-label">{{ $t('httprequestsettings.authorization') }}</label>
+        <div class="col-sm-8">
+            <select id="auth_type" class="form-select" v-model="cfg.auth_type">
+                <option v-for="a in authTypeList" :key="a.key" :value="a.key">
+                    {{ $t('httprequestsettings.authType' + a.value) }}
+                </option>
+            </select>
         </div>
-
-        <InputElement
-            v-if="cfg.auth_type != 0"
-            :label="$t('httprequestsettings.username')"
-            v-model="cfg.username"
-            type="text"
-            maxlength="64"
-            wide
-        />
-
-        <InputElement
-            v-if="cfg.auth_type != 0"
-            :label="$t('httprequestsettings.password')"
-            v-model="cfg.password"
-            type="password"
-            maxlength="64"
-            wide
-        />
-
-        <InputElement
-            :label="$t('httprequestsettings.headerKey')"
-            v-model="cfg.header_key"
-            type="text"
-            maxlength="64"
-            :tooltip="$t('httprequestsettings.headerKeyDescription')"
-            wide
-        />
-
-        <InputElement
-            :label="$t('httprequestsettings.headerValue')"
-            v-model="cfg.header_value"
-            type="text"
-            maxlength="256"
-            wide
-        />
-
-        <InputElement
-            :label="$t('httprequestsettings.timeout')"
-            v-model="cfg.timeout"
-            type="number"
-            :postfix="$t('httprequestsettings.milliSeconds')"
-            wide
-        />
     </div>
+
+    <InputElement
+        v-if="cfg.auth_type != 0"
+        :label="$t('httprequestsettings.username')"
+        v-model="cfg.username"
+        type="text"
+        maxlength="64"
+        wide
+    />
+
+    <InputElement
+        v-if="cfg.auth_type != 0"
+        :label="$t('httprequestsettings.password')"
+        v-model="cfg.password"
+        type="password"
+        maxlength="64"
+        wide
+    />
+
+    <InputElement
+        :label="$t('httprequestsettings.headerKey')"
+        v-model="cfg.header_key"
+        type="text"
+        maxlength="64"
+        :tooltip="$t('httprequestsettings.headerKeyDescription')"
+        wide
+    />
+
+    <InputElement
+        :label="$t('httprequestsettings.headerValue')"
+        v-model="cfg.header_value"
+        type="text"
+        maxlength="256"
+        wide
+    />
+
+    <InputElement
+        :label="$t('httprequestsettings.timeout')"
+        v-model="cfg.timeout"
+        type="number"
+        :postfix="$t('httprequestsettings.milliSeconds')"
+        wide
+    />
 </template>
 
 <script lang="ts">
diff --git a/webapp/src/components/HuaweiView.vue b/webapp/src/components/HuaweiView.vue
index 32b7c2b6..79a3ca91 100644
--- a/webapp/src/components/HuaweiView.vue
+++ b/webapp/src/components/HuaweiView.vue
@@ -43,14 +43,14 @@
                     <div class="card-body">
                         <div class="row flex-row flex-wrap align-items-start g-3">
                             <div class="col order-0">
-                                <div class="card" :class="{ 'border-info': true }">
+                                <div class="card card-table" :class="{ 'border-info': true }">
                                     <div class="card-header bg-info">{{ $t('huawei.Input') }}</div>
                                     <div class="card-body">
                                         <table class="table table-striped table-hover">
                                             <thead>
                                                 <tr>
                                                     <th scope="col">{{ $t('huawei.Property') }}</th>
-                                                    <th style="text-align: right" scope="col">
+                                                    <th class="value" scope="col">
                                                         {{ $t('huawei.Value') }}
                                                     </th>
                                                     <th scope="col">{{ $t('huawei.Unit') }}</th>
@@ -59,35 +59,35 @@
                                             <tbody>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.input_voltage') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ formatNumber(huaweiData.input_voltage.v) }}
                                                     </td>
                                                     <td>{{ huaweiData.input_voltage.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.input_current') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ formatNumber(huaweiData.input_current.v) }}
                                                     </td>
                                                     <td>{{ huaweiData.input_current.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.input_power') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ formatNumber(huaweiData.input_power.v) }}
                                                     </td>
                                                     <td>{{ huaweiData.input_power.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.input_temp') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ Math.round(huaweiData.input_temp.v) }}
                                                     </td>
                                                     <td>{{ huaweiData.input_temp.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.efficiency') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ huaweiData.efficiency.v.toFixed(1) }}
                                                     </td>
                                                     <td>{{ huaweiData.efficiency.u }}</td>
@@ -98,14 +98,14 @@
                                 </div>
                             </div>
                             <div class="col order-1">
-                                <div class="card" :class="{ 'border-info': false }">
+                                <div class="card card-table" :class="{ 'border-info': false }">
                                     <div class="card-header bg-info">{{ $t('huawei.Output') }}</div>
                                     <div class="card-body">
                                         <table class="table table-striped table-hover">
                                             <thead>
                                                 <tr>
                                                     <th scope="col">{{ $t('huawei.Property') }}</th>
-                                                    <th style="text-align: right" scope="col">
+                                                    <th class="value" scope="col">
                                                         {{ $t('huawei.Value') }}
                                                     </th>
                                                     <th scope="col">{{ $t('huawei.Unit') }}</th>
@@ -114,35 +114,35 @@
                                             <tbody>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.output_voltage') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ huaweiData.output_voltage.v.toFixed(1) }}
                                                     </td>
                                                     <td>{{ huaweiData.output_voltage.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.output_current') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ huaweiData.output_current.v.toFixed(2) }}
                                                     </td>
                                                     <td>{{ huaweiData.output_current.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.max_output_current') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ huaweiData.max_output_current.v.toFixed(1) }}
                                                     </td>
                                                     <td>{{ huaweiData.max_output_current.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.output_power') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ huaweiData.output_power.v.toFixed(1) }}
                                                     </td>
                                                     <td>{{ huaweiData.output_power.u }}</td>
                                                 </tr>
                                                 <tr>
                                                     <th scope="row">{{ $t('huawei.output_temp') }}</th>
-                                                    <td style="text-align: right">
+                                                    <td class="value">
                                                         {{ Math.round(huaweiData.output_temp.v) }}
                                                     </td>
                                                     <td>{{ huaweiData.output_temp.u }}</td>
diff --git a/webapp/src/components/InterfaceApInfo.vue b/webapp/src/components/InterfaceApInfo.vue
index f5e22054..18b8c3f3 100644
--- a/webapp/src/components/InterfaceApInfo.vue
+++ b/webapp/src/components/InterfaceApInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('interfaceapinfo.NetworkInterface')" textVariant="text-bg-primary">
+    <CardElement :text="$t('interfaceapinfo.NetworkInterface')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/InterfaceNetworkInfo.vue b/webapp/src/components/InterfaceNetworkInfo.vue
index ea87dc5e..832030cd 100644
--- a/webapp/src/components/InterfaceNetworkInfo.vue
+++ b/webapp/src/components/InterfaceNetworkInfo.vue
@@ -2,6 +2,7 @@
     <CardElement
         :text="$t('interfacenetworkinfo.NetworkInterface', { iface: networkStatus.network_mode })"
         textVariant="text-bg-primary"
+        table
     >
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
diff --git a/webapp/src/components/InverterChannelInfo.vue b/webapp/src/components/InverterChannelInfo.vue
index 94dbc57a..b7ebc27b 100644
--- a/webapp/src/components/InverterChannelInfo.vue
+++ b/webapp/src/components/InverterChannelInfo.vue
@@ -1,11 +1,10 @@
 <template>
     <div
-        class="card"
+        class="card card-table"
         :class="{
             'border-info': channelType == 'AC',
             'border-secondary': channelType == 'INV',
         }"
-        style="overflow: hidden"
     >
         <div v-if="channelType == 'INV'" class="card-header text-bg-secondary">
             {{ $t('inverterchannelinfo.General') }}
@@ -21,12 +20,12 @@
         </div>
 
         <div class="table-responsive">
-            <table class="table table-striped table-hover" style="margin: 0">
+            <table class="table table-striped table-hover">
                 <tbody>
                     <tr v-for="(property, key) in channelData" :key="`prop-${key}`">
                         <template v-if="key != 'name' && property">
                             <th scope="row">{{ $t('inverterchannelproperty.' + key) }}</th>
-                            <td style="text-align: right; padding-right: 0">
+                            <td class="value">
                                 {{
                                     $n(property.v, 'decimal', {
                                         minimumFractionDigits: property.d,
diff --git a/webapp/src/components/InverterTotalInfo.vue b/webapp/src/components/InverterTotalInfo.vue
index a1f0a315..d811bd03 100644
--- a/webapp/src/components/InverterTotalInfo.vue
+++ b/webapp/src/components/InverterTotalInfo.vue
@@ -99,7 +99,7 @@
                     :text="$t('invertertotalinfo.BatteryCharge')"
                 >
                     <div class="flex-fill" v-if="totalBattData.soc">
-                        <h2>
+                        <h2 class="mb-0">
                             {{
                                 $n(totalBattData.soc.v, 'decimal', {
                                     minimumFractionDigits: totalBattData.soc.d,
@@ -111,7 +111,7 @@
                     </div>
 
                     <div class="flex-fill" v-if="totalBattData.voltage">
-                        <h2>
+                        <h2 class="mb-0">
                             {{
                                 $n(totalBattData.voltage.v, 'decimal', {
                                     minimumFractionDigits: totalBattData.voltage.d,
@@ -131,7 +131,7 @@
                     :text="$t('invertertotalinfo.BatteryPower')"
                 >
                     <div class="flex-fill" v-if="totalBattData.power">
-                        <h2>
+                        <h2 class="mb-0">
                             {{
                                 $n(totalBattData.power.v, 'decimal', {
                                     minimumFractionDigits: totalBattData.power.d,
@@ -143,7 +143,7 @@
                     </div>
 
                     <div class="flex-fill" v-if="totalBattData.current">
-                        <h2>
+                        <h2 class="mb-0">
                             {{
                                 $n(totalBattData.current.v, 'decimal', {
                                     minimumFractionDigits: totalBattData.current.d,
diff --git a/webapp/src/components/LocaleSwitcher.vue b/webapp/src/components/LocaleSwitcher.vue
index 4dc7545e..be65b760 100644
--- a/webapp/src/components/LocaleSwitcher.vue
+++ b/webapp/src/components/LocaleSwitcher.vue
@@ -1,31 +1,24 @@
 <template>
-    <select class="form-select" @change="updateLanguage()" v-model="$i18n.locale">
-        <option v-for="locale in $i18n.availableLocales" :key="`locale-${locale}`" :value="locale">
-            {{ getLocaleName(locale) }}
+    <select class="form-select" @change="setLocale(($event.target as HTMLSelectElement).value)" :value="$i18n.locale">
+        <option v-for="locale in allLocales" :key="`locale-${locale.code}`" :value="locale.code">
+            {{ locale.name }}
         </option>
     </select>
 </template>
 
 <script lang="ts">
 import { defineComponent } from 'vue';
-import { LOCALES } from '@/locales';
+import { allLocales, setLocale } from '@/i18n';
 
 export default defineComponent({
     name: 'LocaleSwitcher',
-    methods: {
-        updateLanguage() {
-            localStorage.setItem('locale', this.$i18n.locale);
-        },
-        getLocaleName(locale: string): string {
-            return LOCALES.find((i) => i.value === locale)?.caption || '';
-        },
+    data() {
+        return {
+            allLocales,
+        };
     },
-    mounted() {
-        if (localStorage.getItem('locale')) {
-            this.$i18n.locale = localStorage.getItem('locale') || 'en';
-        } else {
-            localStorage.setItem('locale', this.$i18n.locale);
-        }
+    methods: {
+        setLocale,
     },
 });
 </script>
diff --git a/webapp/src/components/MemoryInfo.vue b/webapp/src/components/MemoryInfo.vue
index 7fffbd81..321b9030 100644
--- a/webapp/src/components/MemoryInfo.vue
+++ b/webapp/src/components/MemoryInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('memoryinfo.MemoryInformation')" textVariant="text-bg-primary">
+    <CardElement :text="$t('memoryinfo.MemoryInformation')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <thead>
diff --git a/webapp/src/components/PinInfo.vue b/webapp/src/components/PinInfo.vue
index a2410325..03dcfbbb 100644
--- a/webapp/src/components/PinInfo.vue
+++ b/webapp/src/components/PinInfo.vue
@@ -1,40 +1,36 @@
 <template>
-    <CardElement :text="$t('pininfo.PinOverview')" textVariant="text-bg-primary">
-        <div class="table-responsive">
-            <table class="table table-hover table-condensed">
-                <thead>
-                    <tr>
-                        <th>{{ $t('pininfo.Category') }}</th>
-                        <th>{{ $t('pininfo.Name') }}</th>
-                        <th>{{ $t('pininfo.ValueSelected') }}</th>
-                        <th>{{ $t('pininfo.ValueActive') }}</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <template v-for="category in categories" :key="category">
-                        <tr v-for="(prop, prop_idx) in properties(category)" :key="prop">
-                            <td v-if="prop_idx == 0" :rowspan="properties(category).length">
-                                {{ capitalizeFirstLetter(category) }}
-                            </td>
-                            <td :class="{ 'table-danger': !isEqual(category, prop) }">
-                                {{ prop }}
-                            </td>
-                            <td>
-                                <template v-if="selectedPinAssignment && category in selectedPinAssignment">
-                                    {{ (selectedPinAssignment as any)[category][prop] }}</template
-                                >
-                            </td>
-                            <td>
-                                <template v-if="currentPinAssignment && category in currentPinAssignment">
-                                    {{ (currentPinAssignment as any)[category][prop] }}</template
-                                >
-                            </td>
-                        </tr>
-                    </template>
-                </tbody>
-            </table>
+    <div class="row flex-row flex-wrap g-3">
+        <div class="col" v-for="category in categories" :key="category">
+            <CardElement :text="capitalizeFirstLetter(category)" textVariant="text-bg-primary" table>
+                <div class="table-responsive">
+                    <table class="table table-hover table-condensed">
+                        <tbody>
+                            <tr>
+                                <th>{{ $t('pininfo.Name') }}</th>
+                                <th class="text-center">{{ $t('pininfo.ValueSelected') }}</th>
+                                <th class="text-center">{{ $t('pininfo.ValueActive') }}</th>
+                            </tr>
+                            <tr v-for="(prop, prop_idx) in properties(category)" :key="prop_idx">
+                                <td :class="{ 'table-danger': !isEqual(category, prop) }">
+                                    {{ prop }}
+                                </td>
+                                <td class="text-center">
+                                    <template v-if="selectedPinAssignment && category in selectedPinAssignment">
+                                        {{ (selectedPinAssignment as any)[category][prop] }}</template
+                                    >
+                                </td>
+                                <td class="text-center">
+                                    <template v-if="currentPinAssignment && category in currentPinAssignment">
+                                        {{ (currentPinAssignment as any)[category][prop] }}</template
+                                    >
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+            </CardElement>
         </div>
-    </CardElement>
+    </div>
 </template>
 
 <script lang="ts">
diff --git a/webapp/src/components/RadioInfo.vue b/webapp/src/components/RadioInfo.vue
index ed84e0fb..758a710c 100644
--- a/webapp/src/components/RadioInfo.vue
+++ b/webapp/src/components/RadioInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('radioinfo.RadioInformation')" textVariant="text-bg-primary">
+    <CardElement :text="$t('radioinfo.RadioInformation')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/TaskDetails.vue b/webapp/src/components/TaskDetails.vue
index a9ab86ac..badc5b81 100644
--- a/webapp/src/components/TaskDetails.vue
+++ b/webapp/src/components/TaskDetails.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('taskdetails.TaskDetails')" textVariant="text-bg-primary">
+    <CardElement :text="$t('taskdetails.TaskDetails')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/VedirectView.vue b/webapp/src/components/VedirectView.vue
index 95cb245b..e385bf8e 100644
--- a/webapp/src/components/VedirectView.vue
+++ b/webapp/src/components/VedirectView.vue
@@ -64,7 +64,7 @@
                     <div class="card-body">
                         <div class="row flex-row flex-wrap align-items-start g-3">
                             <div v-for="(values, section) in item.values" v-bind:key="section" class="col order-0">
-                                <div class="card" :class="{ 'border-info': section === 'device' }">
+                                <div class="card card-table" :class="{ 'border-info': section === 'device' }">
                                     <div :class="section === 'device' ? 'card-header text-bg-info' : 'card-header'">
                                         {{ $t('vedirecthome.section_' + section) }}
                                     </div>
@@ -74,7 +74,7 @@
                                                 <thead>
                                                     <tr>
                                                         <th scope="col">{{ $t('vedirecthome.Property') }}</th>
-                                                        <th style="text-align: right" scope="col">
+                                                        <th class="value" scope="col">
                                                             {{ $t('vedirecthome.Value') }}
                                                         </th>
                                                         <th scope="col">{{ $t('vedirecthome.Unit') }}</th>
@@ -85,7 +85,7 @@
                                                         <th scope="row">
                                                             {{ $t('vedirecthome.' + section + '.' + key) }}
                                                         </th>
-                                                        <td style="text-align: right">
+                                                        <td class="value">
                                                             <template v-if="typeof prop === 'string'">
                                                                 {{ prop }}
                                                             </template>
diff --git a/webapp/src/components/WifiApInfo.vue b/webapp/src/components/WifiApInfo.vue
index 024ac7a6..0a897891 100644
--- a/webapp/src/components/WifiApInfo.vue
+++ b/webapp/src/components/WifiApInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('wifiapinfo.WifiApInfo')" textVariant="text-bg-primary">
+    <CardElement :text="$t('wifiapinfo.WifiApInfo')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/components/WifiStationInfo.vue b/webapp/src/components/WifiStationInfo.vue
index db13594c..5143e4b4 100644
--- a/webapp/src/components/WifiStationInfo.vue
+++ b/webapp/src/components/WifiStationInfo.vue
@@ -1,5 +1,5 @@
 <template>
-    <CardElement :text="$t('wifistationinfo.WifiStationInfo')" textVariant="text-bg-primary">
+    <CardElement :text="$t('wifistationinfo.WifiStationInfo')" textVariant="text-bg-primary" table>
         <div class="table-responsive">
             <table class="table table-hover table-condensed">
                 <tbody>
diff --git a/webapp/src/i18n.ts b/webapp/src/i18n.ts
new file mode 100644
index 00000000..454e891a
--- /dev/null
+++ b/webapp/src/i18n.ts
@@ -0,0 +1,145 @@
+import { createI18n } from 'vue-i18n';
+import messages from '@intlify/unplugin-vue-i18n/messages';
+import type { I18nOptions, IntlDateTimeFormat, IntlNumberFormat } from 'vue-i18n';
+
+export const allLocales = [
+    { code: 'en', name: 'English' },
+    { code: 'de', name: 'Deutsch' },
+    { code: 'fr', name: 'Français' },
+];
+
+const dateTimeFormatsTemplate: IntlDateTimeFormat = {
+    datetime: {
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour12: false,
+    },
+};
+
+const numberFormatTemplate: IntlNumberFormat = {
+    decimal: {
+        style: 'decimal',
+    },
+    decimalNoDigits: {
+        style: 'decimal',
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 0,
+    },
+    decimalOneDigit: {
+        style: 'decimal',
+        minimumFractionDigits: 1,
+        maximumFractionDigits: 1,
+    },
+    decimalTwoDigits: {
+        style: 'decimal',
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    },
+    percent: {
+        style: 'percent',
+    },
+    percentOneDigit: {
+        style: 'percent',
+        minimumFractionDigits: 1,
+        maximumFractionDigits: 1,
+    },
+    byte: {
+        style: 'unit',
+        unit: 'byte',
+    },
+    kilobyte: {
+        style: 'unit',
+        unit: 'kilobyte',
+    },
+    megabyte: {
+        style: 'unit',
+        unit: 'megabyte',
+    },
+    celsius: {
+        style: 'unit',
+        unit: 'celsius',
+        maximumFractionDigits: 1,
+    },
+};
+
+export const dateTimeFormats: I18nOptions['datetimeFormats'] = {};
+export const numberFormats: I18nOptions['numberFormats'] = {};
+
+allLocales.forEach((locale) => {
+    dateTimeFormats[locale.code] = dateTimeFormatsTemplate;
+    numberFormats[locale.code] = numberFormatTemplate;
+});
+
+export const i18n = createI18n({
+    legacy: false,
+    globalInjection: true,
+    locale: navigator.language.split('-')[0],
+    fallbackLocale: allLocales[0].code,
+    messages,
+    datetimeFormats: dateTimeFormats,
+    numberFormats: numberFormats,
+});
+
+const dynamicLocales = await loadAvailLocales();
+allLocales.push(...dynamicLocales);
+
+if (localStorage.getItem('locale')) {
+    setLocale(localStorage.getItem('locale') || 'en');
+} else {
+    localStorage.setItem('locale', i18n.global.locale.value);
+}
+
+// Set new locale.
+export async function setLocale(locale: string) {
+    // Load locale if not available yet.
+    if (!i18n.global.availableLocales.includes(locale)) {
+        const messages = await loadLocale(locale);
+
+        // fetch() error occurred.
+        if (messages === undefined) {
+            i18n.global.locale.value = allLocales[0].code;
+            return;
+        }
+
+        // Add locale.
+        i18n.global.setLocaleMessage(locale, messages.webapp);
+        i18n.global.setNumberFormat(locale, numberFormatTemplate);
+        i18n.global.setDateTimeFormat(locale, dateTimeFormatsTemplate);
+    }
+
+    // Set locale.
+    i18n.global.locale.value = locale;
+    localStorage.setItem('locale', i18n.global.locale.value);
+}
+
+// Fetch locale.
+async function loadLocale(locale: string) {
+    return fetch(`/api/i18n/language?code=${locale}`)
+        .then((response) => {
+            if (response.ok) {
+                return response.json();
+            }
+            throw new Error('Something went wrong!');
+        })
+        .catch((error) => {
+            console.error(error);
+        });
+}
+
+// Fetch available locales
+async function loadAvailLocales() {
+    return fetch('/api/i18n/languages')
+        .then((response) => {
+            if (response.ok) {
+                return response.json();
+            }
+            throw new Error('Something went wrong!');
+        })
+        .catch((error) => {
+            console.error(error);
+        });
+}
diff --git a/webapp/src/locales/de.json b/webapp/src/locales/de.json
index 1a16673b..432a9fbe 100644
--- a/webapp/src/locales/de.json
+++ b/webapp/src/locales/de.json
@@ -41,6 +41,10 @@
         "Release": "Loslassen zum Aktualisieren",
         "Close": "Schließen"
     },
+    "wait": {
+        "NotReady": "OpenDTU ist noch nicht bereit",
+        "PleaseWait": "Bitte warten. Sie werden automatisch auf die Startseite weitergeleitet."
+    },
     "Error": {
         "Oops": "Oops!"
     },
@@ -63,6 +67,7 @@
         "2005": "Ungültige Landesauswahl!",
         "3001": "Nichts gelöscht!",
         "3002": "Konfiguration zurückgesetzt. Starte jetzt neu...",
+        "3003": "Datei erfolgreich gelöscht. Neustarten um Änderungen anzuwenden!",
         "4001": "@:apiresponse.2001",
         "4002": "Der Name muss zwischen 1 und {max} Zeichen lang sein!",
         "4003": "Es werden nur {max} Wechselrichter unterstützt!",
@@ -175,9 +180,12 @@
         "section_device": "Geräteinformation",
         "device": {
             "LOAD": "Status Lastausgang",
+            "VIRTLOAD": "Status virtueller Lastausgang",
+            "IL": "Laststrom",
             "CS": "Betriebszustand",
             "MPPT": "Betriebszustand des Trackers",
             "OR": "Grund für das Ausschalten",
+            "RELAY": "Status Fehlerrelais",
             "ERR": "Fehlerbeschreibung",
             "HSDS": "Anzahl der Tage (0..364)",
             "MpptTemperature": "Ladereglertemperatur"
@@ -188,6 +196,8 @@
             "V": "Spannung",
             "I": "Strom",
             "E": "Effizienz (berechnet)",
+            "AbsorptionVoltage": "Absorptionsspannung",
+            "FloatVoltage": "Erhaltungsspannung",
             "SBSTemperature": "SBS Temperatur"
         },
         "section_input": "Eingang (Solarpanele)",
@@ -450,28 +460,28 @@
         "PerformReboot": "Neustart durchführen",
         "Reboot": "Neustarten!",
         "Cancel": "@:base.Cancel",
-        "RebootOpenDTU": "OpenDTU neu starten",
+        "RebootOpenDTU": "OpenDTU-OnBattery neu starten",
         "RebootQuestion": "Möchten Sie das Gerät wirklich neu starten?",
-        "RebootHint": "<b>Hinweis:</b> Ein manueller Neustart muss normalerweise nicht durchgeführt werden. OpenDTU führt jeden erforderlichen Neustart (z. B. nach einem Firmware-Update) automatisch durch. Einstellungen werden auch ohne Neustart übernommen. Wenn Sie aufgrund eines Fehlers einen Neustart durchführen müssen, denken Sie bitte daran, diesen unter <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/issues\" class=\"alert-link\" target=\"_blank\">Github</a> zu melden."
+        "RebootHint": "<b>Hinweis:</b> Ein manueller Neustart muss normalerweise nicht durchgeführt werden. OpenDTU-OnBattery führt jeden erforderlichen Neustart (z. B. nach einem Firmware-Update) automatisch durch. Einstellungen werden auch ohne Neustart übernommen. Wenn Sie aufgrund eines Fehlers einen Neustart durchführen müssen, denken Sie bitte daran, diesen unter <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/issues\" class=\"alert-link\" target=\"_blank\">Github</a> zu melden."
     },
     "dtuadmin": {
         "DtuSettings": "DTU-Einstellungen",
         "DtuConfiguration": "DTU-Konfiguration",
-        "Serial": "Seriennummer:",
+        "Serial": "Seriennummer",
         "SerialHint": "Sowohl der Wechselrichter als auch die DTU haben eine Seriennummer. Die DTU-Seriennummer wird beim ersten Start zufällig generiert und muss normalerweise nicht geändert werden.",
-        "PollInterval": "Abfrageintervall:",
+        "PollInterval": "Abfrageintervall",
         "VerboseLogging": "@:base.VerboseLogging",
         "Seconds": "Sekunden",
-        "NrfPaLevel": "NRF24 Sendeleistung:",
-        "CmtPaLevel": "CMT2300A Sendeleistung:",
+        "NrfPaLevel": "NRF24 Sendeleistung",
+        "CmtPaLevel": "CMT2300A Sendeleistung",
         "NrfPaLevelHint": "Verwendet für HM-Wechselrichter. Stellen Sie sicher, dass Ihre Stromversorgung stabil genug ist, bevor Sie die Sendeleistung erhöhen.",
         "CmtPaLevelHint": "Verwendet für HMS/HMT-Wechselrichter. Stellen Sie sicher, dass Ihre Stromversorgung stabil genug ist, bevor Sie die Sendeleistung erhöhen.",
-        "CmtCountry": "CMT2300A Region/Land:",
+        "CmtCountry": "CMT2300A Region/Land",
         "CmtCountryHint": "Jedes Land hat unterschiedliche Frequenzzuteilungen.",
         "country_0": "Europa ({min}MHz - {max}MHz)",
         "country_1": "Nordamerika ({min}MHz - {max}MHz)",
         "country_2": "Brasilien ({min}MHz - {max}MHz)",
-        "CmtFrequency": "CMT2300A Frequenz:",
+        "CmtFrequency": "CMT2300A Frequenz",
         "CmtFrequencyHint": "Stelle sicher, dass nur Frequenzen verwendet werden, welche im entsprechenden Land erlaubt sind! Nach einer Frequenzänderung kann es bis zu 15min dauern bis eine Verbindung hergestellt wird.",
         "CmtFrequencyWarning": "Die gewählte Frequenz liegt außerhalb des zulässigen Bereichs in der gewählten Region/dem Land. Vergewissere dich, dass mit dieser Auswahl keine lokalen Regularien verletzt werden.",
         "MHz": "{mhz} MHz",
@@ -484,8 +494,8 @@
     "securityadmin": {
         "SecuritySettings": "Sicherheitseinstellungen",
         "AdminPassword": "Administrator-Passwort",
-        "Password": "Passwort:",
-        "RepeatPassword": "Passwort wiederholen:",
+        "Password": "Passwort",
+        "RepeatPassword": "Passwort wiederholen",
         "PasswordHint": "<b>Hinweis:</b> Das Administrator-Passwort wird für den Zugriff auf die Webschnittstelle (Benutzer 'admin'), aber auch für die Verbindung mit dem Gerät im AP-Modus verwendet. Es muss zwischen 8 und 64 Zeichen lang sein.",
         "Permissions": "Berechtigungen",
         "ReadOnly": "Nur-Lese-Zugriff auf die Weboberfläche ohne Passwort zulassen"
@@ -493,40 +503,40 @@
     "ntpadmin": {
         "NtpSettings": "NTP-Einstellungen",
         "NtpConfiguration": "NTP-Konfiguration",
-        "TimeServer": "Zeitserver:",
-        "TimeServerHint": "Der Standardwert ist in Ordnung, solange OpenDTU direkten Zugang zum Internet hat.",
-        "Timezone": "Zeitzone:",
-        "TimezoneConfig": "Zeitzonenkonfiguration:",
+        "TimeServer": "Zeitserver",
+        "TimeServerHint": "Der Standardwert ist in Ordnung, solange OpenDTU-OnBattery direkten Zugang zum Internet hat.",
+        "Timezone": "Zeitzone",
+        "TimezoneConfig": "Zeitzonenkonfiguration",
         "LocationConfiguration": "Standortkonfiguration",
-        "Longitude": "Längengrad:",
-        "Latitude": "Breitengrad:",
-        "SunSetType": "Dämmerungstyp:",
+        "Longitude": "Längengrad",
+        "Latitude": "Breitengrad",
+        "SunSetType": "Dämmerungstyp",
         "SunSetTypeHint": "Beeinflusst die Tag/Nacht Berechnung. Es kann bis zu einer Minute dauern bis der neue Typ angewendet wurde.",
         "OFFICIAL": "Standard Dämmerung (90.8°)",
         "NAUTICAL": "Nautische Dämmerung (102°)",
         "CIVIL": "Bürgerliche Dämmerung (96°)",
         "ASTONOMICAL": "Astronomische Dämmerung (108°)",
         "ManualTimeSynchronization": "Manuelle Zeitsynchronisation",
-        "CurrentOpenDtuTime": "Aktuelle OpenDTU-Zeit:",
-        "CurrentLocalTime": "Aktuelle lokale Zeit:",
+        "CurrentOpenDtuTime": "Aktuelle OpenDTU-Zeit",
+        "CurrentLocalTime": "Aktuelle lokale Zeit",
         "SynchronizeTime": "Zeit synchronisieren",
-        "SynchronizeTimeHint": "<b>Hinweis:</b> Sie können die manuelle Zeitsynchronisation verwenden, um die aktuelle Zeit von OpenDTU einzustellen, wenn kein NTP-Server verfügbar ist. Beachten Sie aber, dass im Falle eines Stromausfalls die Zeit verloren geht. Beachten Sie auch, dass die Zeitgenauigkeit stark verzerrt wird, da sie nicht regelmäßig neu synchronisiert werden kann und der ESP32-Mikrocontroller nicht über eine Echtzeituhr verfügt."
+        "SynchronizeTimeHint": "<b>Hinweis:</b> Sie können die manuelle Zeitsynchronisation verwenden, um die aktuelle Zeit von OpenDTU-OnBattery einzustellen, wenn kein NTP-Server verfügbar ist. Beachten Sie aber, dass im Falle eines Stromausfalls die Zeit verloren geht. Beachten Sie auch, dass die Zeitgenauigkeit stark verzerrt wird, da sie nicht regelmäßig neu synchronisiert werden kann und der ESP32-Mikrocontroller nicht über eine Echtzeituhr verfügt."
     },
     "networkadmin": {
         "NetworkSettings": "Netzwerkeinstellungen",
         "WifiConfiguration": "WLAN-Konfiguration",
-        "WifiSsid": "WLAN-SSID:",
-        "WifiPassword": "WLAN-Passwort:",
-        "Hostname": "Hostname:",
+        "WifiSsid": "WLAN-SSID",
+        "WifiPassword": "WLAN-Passwort",
+        "Hostname": "Hostname",
         "HostnameHint": "<b>Hinweis:</b> Der Text <span class=\"font-monospace\">%06X</span> wird durch die letzten 6 Ziffern der ESP-ChipID im Hex-Format ersetzt.",
         "EnableDhcp": "DHCP aktivieren",
         "StaticIpConfiguration": "Statische IP-Konfiguration",
-        "IpAddress": "IP-Adresse:",
-        "Netmask": "Netzmaske:",
-        "DefaultGateway": "Standardgateway:",
-        "Dns": "DNS-Server {num}:",
+        "IpAddress": "IP-Adresse",
+        "Netmask": "Netzmaske",
+        "DefaultGateway": "Standardgateway",
+        "Dns": "DNS-Server {num}",
         "AdminAp": "WLAN-Konfiguration (Admin AccessPoint)",
-        "ApTimeout": "AccessPoint Zeitlimit:",
+        "ApTimeout": "AccessPoint Zeitlimit",
         "ApTimeoutHint": "Zeit die der AccessPoint offen gehalten wird. Ein Wert von 0 bedeutet unendlich.",
         "Minutes": "Minuten",
         "EnableMdns": "mDNS aktivieren",
@@ -543,38 +553,38 @@
         "VerboseLogging": "@:base.VerboseLogging",
         "EnableHass": "Home Assistant MQTT-Auto-Discovery aktivieren",
         "MqttBrokerParameter": "MQTT-Broker-Parameter",
-        "Hostname": "Hostname:",
+        "Hostname": "Hostname",
         "HostnameHint": "Hostname oder IP-Adresse",
-        "Port": "Port:",
-        "ClientId": "Client ID:",
-        "Username": "Benutzername:",
+        "Port": "Port",
+        "ClientId": "Client ID",
+        "Username": "Benutzername",
         "UsernameHint": "Benutzername, leer lassen für anonyme Verbindung",
-        "Password": "Passwort:",
+        "Password": "Passwort",
         "PasswordHint": "Passwort, leer lassen für anonyme Verbindung",
-        "BaseTopic": "Basis-Topic:",
+        "BaseTopic": "Basis-Topic",
         "BaseTopicHint": "Basis-Topic, wird allen veröffentlichten Themen vorangestellt (z.B. inverter/)",
-        "PublishInterval": "Veröffentlichungsintervall:",
+        "PublishInterval": "Veröffentlichungsintervall",
         "Seconds": "Sekunden",
         "CleanSession": "CleanSession Flag aktivieren",
         "EnableRetain": "Retain Flag aktivieren",
         "EnableTls": "TLS aktivieren",
-        "RootCa": "CA-Root-Zertifikat (Standard Letsencrypt):",
+        "RootCa": "CA-Root-Zertifikat (Standard Letsencrypt)",
         "TlsCertLoginEnable": "TLS Zertifikat Login",
-        "ClientCert": "TLS Client-Zertifikat:",
-        "ClientKey": "TLS Client-Key:",
+        "ClientCert": "TLS Client-Zertifikat",
+        "ClientKey": "TLS Client-Key",
         "LwtParameters": "LWT-Parameter",
-        "LwtTopic": "LWT-Topic:",
+        "LwtTopic": "LWT-Topic",
         "LwtTopicHint": "LWT-Topic, wird der Basis-Topic angehängt",
-        "LwtOnline": "LWT-Online-Nachricht:",
-        "LwtOnlineHint": "Nachricht, die im LWT-Topic veröffentlicht wird, wenn OpenDTU online ist",
-        "LwtOffline": "LWT-Offline-Nachricht:",
-        "LwtOfflineHint": "Nachricht, die im LWT-Topic veröffentlicht wird, wenn OpenDTU offline ist",
-        "LwtQos": "QoS (Quality of Service):",
+        "LwtOnline": "LWT-Online-Nachricht",
+        "LwtOnlineHint": "Nachricht, die im LWT-Topic veröffentlicht wird, wenn OpenDTU-OnBattery online ist",
+        "LwtOffline": "LWT-Offline-Nachricht",
+        "LwtOfflineHint": "Nachricht, die im LWT-Topic veröffentlicht wird, wenn OpenDTU-OnBattery offline ist",
+        "LwtQos": "QoS (Quality of Service)",
         "QOS0": "0 (Höchstens einmal)",
         "QOS1": "1 (Mindestens einmal)",
         "QOS2": "2 (Exakt einmal)",
         "HassParameters": "Home Assistant MQTT-Auto-Discovery-Parameter",
-        "HassPrefixTopic": "Präfix Topic:",
+        "HassPrefixTopic": "Präfix Topic",
         "HassPrefixTopicHint": "The prefix for the discovery topic",
         "HassRetain": "Retain Flag aktivieren",
         "HassExpire": "Ablauffunktion aktivieren",
@@ -650,11 +660,12 @@
         "ConfigHintsIntro": "Folgende Hinweise zur Konfiguration des Dynamic Power Limiter (DPL) sollen beachtet werden:",
         "ConfigHintPowerMeterDisabled": "Der DPL stellt ohne Stromzählerschnittstelle lediglich die konfigurierte Grundlast als Limit am Wechselrichter ein (Ausnahme: (Full) Solar-Passthrough).",
         "ConfigHintNoInverter": "Vor dem Festlegen von Einstellungen des DPL muss mindestens ein Inverter konfiguriert sein.",
-        "ConfigHintInverterCommunication": "Das Abrufen von Daten und Senden von Kommandos muss für den zu regelnden Wechselrichter aktiviert sein.",
+        "ConfigHintInverterCommunication": "Das Abrufen von Daten und Senden von Kommandos muss für jeden zu regelnden Wechselrichter aktiviert sein.",
         "ConfigHintNoChargeController": "Die Solar-Passthrough Funktion kann nur mit aktivierter VE.Direct Schnittstelle genutzt werden.",
         "ConfigHintNoBatteryInterface": "SoC-basierte Schwellwerte können nur mit konfigurierter Batteriekommunikationsschnittstelle genutzt werden.",
         "General": "Allgemein",
         "Enable": "Aktiviert",
+        "GovernInverter": "Steuere Wechselrichter \"{name}\"",
         "VerboseLogging": "@:base.VerboseLogging",
         "SolarPassthrough": "Solar-Passthrough",
         "EnableSolarPassthrough": "Aktiviere Solar-Passthrough",
@@ -662,34 +673,51 @@
         "SolarPassthroughLossesInfo": "<b>Hinweis:</b> Bei der Übertragung von Energie vom Solarladeregler zum Inverter sind Leitungsverluste zu erwarten. Um eine schleichende Entladung der Batterie im (Full) Solar-Passthrough Modus zu unterbinden, können diese Verluste berücksichtigt werden. Das am Inverter einzustellende Power Limit wird nach Berücksichtigung von dessen Effizienz zusätzlich um diesen Faktor verringert.",
         "BatteryDischargeAtNight": "Batterie nachts sogar teilweise geladen nutzen",
         "SolarpassthroughInfo": "Diese Funktion ermöglicht den unmittelbaren Verbauch der verfügbaren Solarleistung. Dazu wird die aktuell vom Laderegler gemeldete Solarleistung am Wechselrichter als Limit eingestellt, selbst wenn sich die Batterie in einem Ladezyklus befindet. Somit wird eine unnötige Speicherung vermieden, die verlustbehaftet wäre.",
-        "InverterSettings": "Wechselrichter",
-        "Inverter": "Zu regelnder Wechselrichter",
+        "InverterSettings": "Wechselrichtereinstellungen",
         "SelectInverter": "Inverter auswählen...",
+        "InverterForDcVoltage": "Wechselrichter für Spannungsmessungen",
         "InverterChannelId": "Eingang für Spannungsmessungen",
         "TargetPowerConsumption": "Angestrebter Netzbezug",
-        "TargetPowerConsumptionHint": "Angestrebter erlaubter Stromverbrauch aus dem Netz. Wert darf negativ sein.",
+        "TargetPowerConsumptionHint": "Angestrebter Stromverbrauch aus dem Netz. Wert darf negativ sein.",
         "TargetPowerConsumptionHysteresis": "Hysterese",
-        "TargetPowerConsumptionHysteresisHint": "Neu berechnetes Limit nur dann an den Inverter senden, wenn es vom zurückgemeldeten Limit um mindestens diesen Betrag abweicht.",
+        "TargetPowerConsumptionHysteresisHint": "Neu berechnetes Limit nur dann an den jeweiligen Inverter senden, wenn es vom zurückgemeldeten Limit um mindestens diesen Betrag abweicht.",
         "LowerPowerLimit": "Minimales Leistungslimit",
         "LowerPowerLimitHint": "Dieser Wert muss so gewählt werden, dass ein stabiler Betrieb mit diesem Limit möglich ist. Falls der Wechselrichter nur mit einem kleineren Limit betrieben werden könnte, wird er stattdessen in Standby versetzt.",
         "BaseLoadLimit": "Grundlast",
-        "BaseLoadLimitHint": "Relevant beim Betrieb ohne oder beim Ausfall des Stromzählers. Solange es die sonstigen Bedinungen zulassen (insb. Batterieladung) wird dieses Limit am Wechselrichter eingestellt.",
+        "BaseLoadLimitHint": "Relevant beim Betrieb ohne oder beim Ausfall des Stromzählers. Solange es die sonstigen Bedinungen zulassen (insb. Batterieladung), wird diese Leistung auf die Wechselrichter verteilt.",
+        "TotalUpperPowerLimit": "Maximale Gesamtausgangsleistung",
+        "TotalUpperPowerLimitHint": "Die Wechselrichter werden so eingestellt, dass sie in Summe höchstens diese Leistung erbringen.",
+        "ManagedInverters": "Verwaltete Wechselrichter",
+        "AddInverter": "Wechselrichter Hinzufügen",
+        "NoManagedInverters": "Der Dynamic Power Limiter verwaltet zur Zeit keine Wechselrichter. Um Fortzufahren, wähle einen Wechselrichter aus der Auswahlliste oben und füge ihn hinzu.",
+        "InverterLabel": "Name (Typ)",
+        "PowerSource": "Energiequelle",
+        "PowerSourceBattery": "Batterie",
+        "PowerSourceSolarPanels": "Solarmodul(e)",
+        "EditInverter": "Wechselrichter Bearbeiten",
+        "EditInverterLabel": "Betrifft Wechselrichter",
+        "Apply": "Übernehmen",
+        "Cancel": "@:base.Cancel",
+        "Delete": "Entfernen",
+        "DeleteInverter": "Entfernen Bestätigen",
+        "DeleteInverterMsg": "Soll Wechselrichter {label} mit Seriennummer {serial} von der Liste vom Dynamic Power Limiter verwalteter Wechselrichter entfernt werden?",
         "UpperPowerLimit": "Maximales Leistungslimit",
         "UpperPowerLimitHint": "Der Wechselrichter wird stets so eingestellt, dass höchstens diese Ausgangsleistung erreicht wird. Dieser Wert muss so gewählt werden, dass die Strombelastbarkeit der AC-Anschlussleitungen eingehalten wird.",
         "SocThresholds": "Batterie State of Charge (SoC) Schwellwerte",
-        "IgnoreSoc": "Batterie SoC ignorieren",
+        "IgnoreSoc": "Nur Spannungs-Schwellwerte nutzen",
+        "IgnoreSocHint": "Falls aktiviert werden nur die Spannungs-Schwellwerte berücksichtigt. Deaktiviere diesen Schalter, um Batterie State of Charge (SoC) Schwellwerte zu konfigurieren (nicht empfohlen, da der SoC-Wert häufig ungenau ist).",
         "StartThreshold": "Batterienutzung Start-Schwellwert",
         "StopThreshold": "Batterienutzung Stop-Schwellwert",
         "FullSolarPassthroughStartThreshold": "Full-Solar-Passthrough Start-Schwellwert",
         "FullSolarPassthroughStartThresholdHint": "Oberhalb dieses Schwellwertes wird die Inverterleistung der Victron-MPPT-Leistung gleichgesetzt (abzüglich Effizienzkorrekturfaktor). Kann verwendet werden um überschüssige Solarleistung an das Netz zu liefern wenn die Batterie voll ist.",
         "VoltageSolarPassthroughStopThreshold": "Full-Solar-Passthrough Stop-Schwellwert",
         "VoltageLoadCorrectionFactor": "Lastkorrekturfaktor",
-        "BatterySocInfo": "<b>Hinweis:</b> Die Akku SoC (State of Charge) Werte werden nur benutzt, wenn die Batterie-Kommunikationsschnittstelle innerhalb der letzten Minute gültige Werte geschickt hat. Andernfalls werden als Fallback-Option die Spannungseinstellungen verwendet.",
+        "BatterySocInfo": "<b>Hinweis:</b> Die Batterie State of Charge (SoC) Schwellwerte werden bevorzugt herangezogen. Sie werden allerdings nur benutzt, wenn die Batterie-Kommunikationsschnittstelle innerhalb der letzten Minute gültige Werte verarbeitet hat. Andernfalls werden ersatzweise die Spannungs-Schwellwerte verwendet.",
         "InverterIsBehindPowerMeter": "Stromzählermessung beinhaltet Wechselrichter",
         "InverterIsBehindPowerMeterHint": "Aktivieren falls sich der Stromzähler-Messwert um die Ausgangsleistung des Wechselrichters verringert, wenn dieser Strom produziert. Normalerweise ist das zutreffend.",
         "InverterIsSolarPowered": "Wechselrichter wird von Solarmodulen gespeist",
         "UseOverscalingToCompensateShading": "Verschattung durch Überskalierung ausgleichen",
-        "UseOverscalingToCompensateShadingHint": "Erlaubt das Überskalieren des Wechselrichter-Limits, um Verschattung eines oder mehrerer Eingänge auszugleichen",
+        "UseOverscalingToCompensateShadingHint": "Erlaubt das Überskalieren des Wechselrichter-Limits, um Verschattung eines oder mehrerer Eingänge auszugleichen.",
         "VoltageThresholds": "Batterie Spannungs-Schwellwerte ",
         "VoltageLoadCorrectionInfo": "<b>Hinweis:</b> Wenn Leistung von der Batterie abgegeben wird, bricht ihre Spannung etwas ein. Der Spannungseinbruch skaliert mit dem Entladestrom. Damit nicht vorzeitig der Wechselrichter ausgeschaltet wird sobald der Stop-Schwellenwert unterschritten wurde, wird der hier angegebene Korrekturfaktor mit einberechnet um die Spannung zu errechnen die der Akku in Ruhe hätte. Korrigierte Spannung = DC Spannung + (Aktuelle Leistung (W) * Korrekturfaktor).",
         "InverterRestartHour": "Uhrzeit für geplanten Neustart",
@@ -705,6 +733,7 @@
         "ProviderPylontechCan": "Pylontech per CAN-Bus",
         "ProviderSBSCan": "SBS Unipower per CAN-Bus",
         "ProviderJkBmsSerial": "Jikong (JK) BMS per serieller Verbindung",
+        "ProviderJbdBmsSerial": "Jiabaida (JBD) BMS per serieller Verbindung",
         "ProviderMqtt": "Batteriewerte aus MQTT Broker",
         "ProviderVictron": "Victron SmartShunt per VE.Direct Schnittstelle",
         "ProviderPytesCan": "Pytes per CAN-Bus",
@@ -715,15 +744,20 @@
         "MqttVoltageUnit": "Einheit",
         "MqttSocTopic": "Topic für SoC",
         "MqttVoltageTopic": "Topic für Spannung",
-        "JkBmsConfiguration": "JK BMS Einstellungen",
-        "JkBmsInterface": "Schnittstellentyp",
-        "JkBmsInterfaceUart": "TTL-UART an der MCU",
-        "JkBmsInterfaceTransceiver": "RS-485 Transceiver an der MCU",
+        "SerialSettings": "Einstellungen Serielle Schnittstelle",
+        "SerialInterfaceType": "Schnittstellentyp",
+        "SerialInterfaceTypeUart": "TTL-UART an der MCU",
+        "SerialInterfaceTypeTransceiver": "RS-485 Transceiver an der MCU",
+        "JbdBmsConfiguration": "JBD BMS Einstellungen",
         "PollingInterval": "Abfrageintervall",
         "Seconds": "@:base.Seconds",
         "DischargeCurrentLimitConfiguration": "Einstellungen Entladestromlimit",
         "LimitDischargeCurrent": "Entladestrom limitieren",
         "DischargeCurrentLimit": "max. Entladestrom",
+        "DischargeCurrentLimitBelowSoc": "Limitieren unter SoC",
+        "DischargeCurrentLimitBelowSocInfo": "Das Entladestromlimit wird nur unter dieser SoC-Schwelle angewendet (wird nicht verwendet, falls 'Batterie SoC ignorieren' in den DPL-Einstellungen aktiviert ist).",
+        "DischargeCurrentLimitBelowVoltage": "Limitieren unter Spannung",
+        "DischargeCurrentLimitBelowVoltageInfo": "Das Entladestromlimit wird nur unter dieser Spannungs-Schwelle angewendet (wenn 'Batterie SoC ignorieren' in den DPL-Einstellungen aktiviert ist oder SoC nicht verfügbar ist).",
         "UseBatteryReportedDischargeCurrentLimit": "Von der Batterie übermitteltes Limit verwenden",
         "BatteryReportedDischargeCurrentLimitInfo": "<b>Hinweis:</b> Das niedrigste Limit wird angewendet, wobei das von der Batterie übermittelte Entladestromlimit nur verwendet wird, wenn in der letzten Minute ein Update eingegangen ist; andernfalls dient das zuvor festgelegte Limit als Fallback.",
         "MqttDischargeCurrentTopic": "Topic für Entladestromlimit",
@@ -764,7 +798,7 @@
         "StringYtOffset": "Ertragsversatz String {num}:",
         "StringYtOffsetHint": "Dieser Offset wird beim Auslesen des Gesamtertragswertes des Wechselrichters angewendet. Damit kann der Gesamtertrag des Wechselrichters auf Null gesetzt werden, wenn ein gebrauchter Wechselrichter verwendet wird.",
         "InverterHint": "*) Geben Sie die W<sub>p</sub> des Ports ein, um die Einstrahlung zu errechnen.",
-        "ReachableThreshold": "Erreichbarkeit Schwellenwert:",
+        "ReachableThreshold": "Erreichbarkeit Schwellenwert",
         "ReachableThresholdHint": "Legt fest, wie viele Anfragen fehlschlagen dürfen, bis der Wechselrichter als unerreichbar eingestuft wird.",
         "ZeroRuntime": "Nulle Laufzeit Daten",
         "ZeroRuntimeHint": "Nulle Laufzeit Daten (keine Ertragsdaten), wenn der Wechselrichter nicht erreichbar ist.",
@@ -778,24 +812,30 @@
         "YieldDayCorrection": "Tagesertragskorrektur",
         "YieldDayCorrectionHint": "Summiert den Tagesertrag, auch wenn der Wechselrichter neu gestartet wird. Der Wert wird um Mitternacht zurückgesetzt"
     },
-    "configadmin": {
+    "fileadmin": {
         "ConfigManagement": "Konfigurationsverwaltung",
         "BackupHeader": "Sicherung: Sicherung der Konfigurationsdatei",
-        "BackupConfig": "Sicherung der Konfigurationsdatei",
-        "Backup": "Sichern",
         "Restore": "Wiederherstellen",
         "NoFileSelected": "Keine Datei ausgewählt",
         "RestoreHeader": "Wiederherstellen: Wiederherstellen der Konfigurationsdatei",
         "Back": "Zurück",
         "UploadSuccess": "Erfolgreich hochgeladen",
-        "RestoreHint": "<b>Hinweis:</b> Bei diesem Vorgang wird die Konfigurationsdatei durch die wiederhergestellte Konfiguration ersetzt und OpenDTU neu gestartet, um alle Einstellungen zu übernehmen.",
+        "RestoreHint": "<b>Hinweis:</b> Bei diesem Vorgang wird die Konfigurationsdatei durch die wiederhergestellte Konfiguration ersetzt und OpenDTU-OnBattery neu gestartet, um alle Einstellungen zu übernehmen.",
         "ResetHeader": "Initialisieren: Werksreset durchführen",
         "FactoryResetButton": "Werkseinstellungen wiederherstellen",
         "ResetHint": "<b>Hinweis:</b> Klicken Sie auf Werkseinstellungen wiederherstellen, um die Werkseinstellungen wiederherzustellen und neu zu starten.",
         "FactoryReset": "Werksreset",
         "ResetMsg": "Sind Sie sicher, dass Sie die aktuelle Konfiguration löschen und alle Einstellungen auf die Werkseinstellungen zurücksetzen möchten?",
         "ResetConfirm": "Werksreset!",
-        "Cancel": "@:base.Cancel"
+        "Download": "Herunterladen",
+        "Delete": "Löschen",
+        "DeleteMsg": "Sind Sie sicher, dass Sie die Datei löschen wollen: '{name}'? Es muss manuell neu gestartet werden um die Konfigurationsänderungen zu übernehmen!",
+        "Name": "Name",
+        "Size": "Größe",
+        "Action": "Aktion",
+        "Cancel": "@:base.Cancel",
+        "InvalidJson": "JSON-Datei ist falsch formatiert.",
+        "InvalidJsonContent": "JSON-Datei hat den falschen Inhalt."
     },
     "login": {
         "Login": "Anmeldung",
@@ -826,7 +866,7 @@
         "ProjectOriginBody1": "OpenDTU-OnBattery ist eine Erweiterung von OpenDTU. Das Basis-Projekt OpenDTU wurde aus <a href=\"https://www.mikrocontroller.net/topic/525778\" target=\"_blank\">dieser Diskussion (mikrocontroller.net)</a> heraus gestartet.",
         "ProjectOriginBody2": "Das Hoymiles-Protokoll wurde durch die freiwilligen Bemühungen vieler Teilnehmer entschlüsselt. OpenDTU wurde unter anderem auf der Grundlage dieser Arbeit entwickelt. Das Projekt ist unter einer Open-Source-Lizenz lizenziert (<a href=\"https://www.gnu.de/documents/gpl-2.0.de.html\" target=\"_blank\">GNU General Public License version 2</a>).",
         "ProjectOriginBody3": "Die Software wurde nach bestem Wissen und Gewissen entwickelt. Dennoch kann keine Haftung für eine Fehlfunktion oder einen Garantieverlust des Wechselrichters übernommen werden.",
-        "ProjectOriginBody4": "OpenDTU ist frei verfügbar. Wenn Sie Geld für die Software bezahlt haben, wurden Sie wahrscheinlich abgezockt.",
+        "ProjectOriginBody4": "OpenDTU und OpenDTU-OnBattery sind frei verfügbar. Wenn Sie Geld für die Software bezahlt haben, wurden Sie wahrscheinlich abgezockt.",
         "NewsUpdates": "Neuigkeiten und Updates",
         "NewsUpdatesBody": "Neue Updates sind auf <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/releases\" target=\"_blank\">Github</a> zu finden.",
         "ErrorReporting": "Fehlerberichte",
@@ -845,37 +885,36 @@
         "DeviceManager": "Hardware-Einstellungen",
         "ParseError": "Syntaxfehler in 'pin_mapping.json': {error}",
         "PinAssignment": "Anschlusseinstellungen",
-        "SelectedProfile": "Ausgewähltes Profil:",
+        "SelectedProfile": "Ausgewähltes Profil",
         "DefaultProfile": "(Standardeinstellungen)",
         "ProfileHint": "Ihr Gerät reagiert möglicherweise nicht mehr, wenn Sie ein inkompatibles Profil wählen. In diesem Fall müssen Sie eine Löschung über das serielle Interface durchführen.",
         "Display": "Display",
-        "PowerSafe": "Ausschalten wenn kein Inverter erreichbar:",
+        "PowerSafe": "Ausschalten wenn kein Inverter erreichbar",
         "PowerSafeHint": "Schaltet das Display aus, wenn kein Wechselrichter Strom erzeugt",
-        "Screensaver": "OLED-Schutz gegen Einbrennen:",
+        "Screensaver": "OLED-Schutz gegen Einbrennen",
         "ScreensaverHint": "Bewegt die Ausgabe bei jeder Aktualisierung um ein Einbrennen zu verhindern (v. a. für OLED-Displays nützlich)",
-        "DiagramMode": "Diagramm Modus:",
+        "DiagramMode": "Diagramm Modus",
         "off": "Deaktiviert",
         "small": "Klein",
         "fullscreen": "Vollbild",
-        "DiagramDuration": "Diagramm Periode:",
+        "DiagramDuration": "Diagramm Periode",
         "DiagramDurationHint": "Die Zeitperiode welche im Diagramm dargestellt wird.",
         "Seconds": "Sekunden",
-        "Contrast": "Kontrast ({contrast}):",
-        "Rotation": "Rotation:",
+        "Contrast": "Kontrast ({contrast})",
+        "Rotation": "Rotation",
         "rot0": "Keine Rotation",
         "rot90": "90 Grad Drehung",
         "rot180": "180 Grad Drehung",
         "rot270": "270 Grad Drehung",
-        "DisplayLanguage": "Displaysprache:",
+        "DisplayLanguage": "Displaysprache",
         "en": "Englisch",
         "de": "Deutsch",
         "fr": "Französisch",
         "Leds": "LEDs",
-        "EqualBrightness": "Gleiche Helligkeit:",
-        "LedBrightness": "LED {led} Helligkeit ({brightness}):"
+        "EqualBrightness": "Gleiche Helligkeit",
+        "LedBrightness": "LED {led} Helligkeit ({brightness})"
     },
     "pininfo": {
-        "PinOverview": "Anschlussübersicht",
         "Category": "Kategorie",
         "Name": "Name",
         "ValueSelected": "Ausgewählt",
@@ -912,9 +951,9 @@
         "SetOnline": "Limit setzen, CAN Bus verbunden",
         "LimitHint": "<b>Hinweis:</b> Spannungsbereich wenn CAN Bus nicht verbunden ist 48V-58.5V ",
         "Close": "Schließen",
-        "SetVoltageLimit": "Spannungslimit:",
-        "SetCurrentLimit": "Stromlimit:",
-        "CurrentLimit": "Aktuelles Limit: "
+        "SetVoltageLimit": "Spannungslimit",
+        "SetCurrentLimit": "Stromlimit",
+        "CurrentLimit": "Aktuelles Limit "
     },
     "acchargeradmin": {
         "ChargerSettings": "AC Ladegerät Einstellungen",
@@ -936,7 +975,8 @@
         "StopBatterySoCThreshold": "Laden bei SoC beenden",
         "StopBatterySoCThresholdHint": "Zur Verlängerung der Akku-Lebensdauer kann der Ladevorgang bei einem bestimmten SoC gestoppt werden.\nHinweis: Manche LiFePO-Akkus müssen gelegentlich voll geladen werden, um die SoC-Anzeige akkurat zu halten.",
         "Seconds": "@:base.Seconds",
-        "EnableEmergencyCharge": "Notfallladen: Batterie wird mit maximaler Leistung geladen wenn durch das Batterie BMS angefordert",
+        "EnableEmergencyCharge": "Notfallladen",
+        "EnableEmergencyChargeHint": "Batterie wird mit maximaler Leistung geladen wenn durch das Batterie BMS angefordert",
         "targetPowerConsumption": "Angestrebter Netzbezug",
         "targetPowerConsumptionHint": "Bei postiven Werten wird die eingestellte Leistung aus dem Stromnetz bezogen. Bei negativen Werten wird das Netzteil vorzeitig abgeschaltet."
     },
@@ -993,32 +1033,56 @@
         "issueType": "Art",
         "alarm": "Alarm",
         "warning": "Warnung",
+        "CommonIssueCellOverVoltage": "Überspannung (einzelne Zelle)",
+        "CommonIssueCellUnderVoltage": "Unterspannung (einzelne Zelle)",
+        "CommonIssuePackOverVoltage": "Überspannung (Akkupack)",
+        "CommonIssuePackUnderVoltage": "Unterspannung (Akkupack)",
+        "CommonIssueChargingOverCurrent": "Überstrom (Laden)",
+        "CommonIssueDischargeOverCurrent": "Überstrom (Entladen)",
+        "CommonIssueChargingOverTemperature": "Übertemperatur (Laden)",
+        "CommonIssueChargingLowTemperature": "Untertemperatur (Laden)",
         "JkBmsIssueLowCapacity": "Niedrige Kapazität",
         "JkBmsIssueBmsOvertemperature": "BMS Übertemperatur",
-        "JkBmsIssueChargingOvervoltage": "Überspannung (Akkupack)",
-        "JkBmsIssueDischargeUndervoltage": "Unterspannung (Akkupack)",
+        "JkBmsIssueChargingOvervoltage": "@:battery.CommonIssuePackOverVoltage",
+        "JkBmsIssueDischargeUndervoltage": "@:battery.CommonIssuePackUnderVoltage",
         "JkBmsIssueBatteryOvertemperature": "Batterie Übertemperatur",
-        "JkBmsIssueChargingOvercurrent": "Überstrom (Laden)",
-        "JkBmsIssueDischargeOvercurrent": "Überstrom (Entladen)",
+        "JkBmsIssueChargingOvercurrent": "@:battery.CommonIssueChargingOverCurrent",
+        "JkBmsIssueDischargeOvercurrent": "@:battery.CommonIssueDischargeOverCurrent",
         "JkBmsIssueCellVoltageDifference": "Zellspannungsdifferenz zu hoch",
         "JkBmsIssueBatteryBoxOvertemperature": "Batterie (Box?) Übertemperatur",
         "JkBmsIssueBatteryUndertemperature": "Batterie Untertemperatur",
-        "JkBmsIssueCellOvervoltage": "Überspannung (einzelne Zelle)",
-        "JkBmsIssueCellUndervoltage": "Unterspannung (einzelne Zelle)",
+        "JkBmsIssueCellOvervoltage": "@:battery.CommonIssueCellOverVoltage",
+        "JkBmsIssueCellUndervoltage": "@:battery.CommonIssueCellUnderVoltage",
         "JkBmsIssueAProtect": "AProtect (Bedeutung?)",
         "JkBmsIssueBProtect": "BProtect (Bedeutung?)",
+        "JbdBmsIssueCellOverVoltage": "@:battery.CommonIssueCellOverVoltage",
+        "JbdBmsIssueCellUnderVoltage": "@:battery.CommonIssueCellUnderVoltage",
+        "JbdBmsIssuePackOverVoltage": "@:battery.CommonIssuePackOverVoltage",
+        "JbdBmsIssuePackUnderVoltage": "@:battery.CommonIssuePackUnderVoltage",
+        "JbdBmsIssueChargingOverTemperature": "@:battery.CommonIssueChargingOverTemperature",
+        "JbdBmsIssueChargingLowTemperature": "@:battery.CommonIssueChargingLowTemperature",
+        "JbdBmsIssueDischargingOverTemperature": "Übertemperatur (Entladen)",
+        "JbdBmsIssueDischargingLowTemperature": "Untertemperatur (Entladen)",
+        "JbdBmsIssueChargingOverCurrent": "@:battery.CommonIssueChargingOverCurrent",
+        "JbdBmsIssueDischargeOverCurrent": "@:battery.CommonIssueDischargeOverCurrent",
+        "JbdBmsIssueShortCircuit": "Kurzschluss",
+        "JbdBmsIssueIcFrontEndError": "IC Frontend Fehler",
+        "JbdBmsIssueMosSotwareLock": "Laden/Entladen unterbunden",
+        "JbdBmsIssueReserved1": "Reserviert 1",
+        "JbdBmsIssueReserved2": "Reserviert 2",
+        "JbdBmsIssueReserved3": "Reserviert 3",
         "highCurrentDischarge": "Hoher Entladestrom",
-        "overCurrentDischarge": "Überstrom (Entladen)",
+        "overCurrentDischarge": "@:battery.CommonIssueDischargeOverCurrent",
         "highCurrentCharge": "Hoher Ladestrom",
-        "overCurrentCharge": "Überstrom (Laden)",
+        "overCurrentCharge": "@:battery.CommonIssueChargingOverCurrent",
         "lowTemperature": "Geringe Temperatur",
         "underTemperature": "Untertemperatur",
         "lowTemperatureCharge": "Geringe Temperatur (Laden)",
-        "underTemperatureCharge": "Untertemperatur (Laden)",
+        "underTemperatureCharge": "@:battery.CommonIssueChargingLowTemperature",
         "highTemperature": "Hohe Temperatur",
         "overTemperature": "Übertemperatur",
         "highTemperatureCharge": "Hohe Temperatur (Laden)",
-        "overTemperatureCharge": "Übertemperatur (Laden)",
+        "overTemperatureCharge": "@:battery.CommonIssueChargingOverTemperature",
         "lowSOC": "Geringer Ladezustand",
         "lowVoltage": "Niedrige Spannung",
         "underVoltage": "Unterspannung",
diff --git a/webapp/src/locales/en.json b/webapp/src/locales/en.json
index 69a28877..010238f4 100644
--- a/webapp/src/locales/en.json
+++ b/webapp/src/locales/en.json
@@ -41,6 +41,10 @@
         "Release": "Release to refresh",
         "Close": "Close"
     },
+    "wait": {
+        "NotReady": "OpenDTU is not yet ready",
+        "PleaseWait": "Please wait. You will be automatically redirected to the home page."
+    },
     "Error": {
         "Oops": "Oops!"
     },
@@ -63,6 +67,7 @@
         "2005": "Invalid country selection!",
         "3001": "Not deleted anything!",
         "3002": "Configuration resettet. Rebooting now...",
+        "3003": "File successful deleted. Restart to apply changes!",
         "4001": "@:apiresponse.2001",
         "4002": "Name must between 1 and {max} characters long!",
         "4003": "Only {max} inverters are supported!",
@@ -175,9 +180,12 @@
         "section_device": "Device Info",
         "device": {
             "LOAD": "Load output state",
+            "VIRTLOAD": "Virtual load output state",
+            "IL": "Load current",
             "CS": "State of operation",
             "MPPT": "Tracker operation mode",
             "OR": "Off reason",
+            "RELAY": "Error relay state",
             "ERR": "Error code",
             "HSDS": "Day sequence number (0..364)",
             "MpptTemperature": "Charge controller temperature"
@@ -188,6 +196,8 @@
             "V": "Voltage",
             "I": "Current",
             "E": "Efficiency (calculated)",
+            "AbsorptionVoltage": "Absorption voltage",
+            "FloatVoltage": "Float voltage",
             "SBSTemperature": "SBS temperature"
         },
         "section_input": "Input (Solar Panels)",
@@ -452,28 +462,28 @@
         "PerformReboot": "Perform Reboot",
         "Reboot": "Reboot!",
         "Cancel": "@:base.Cancel",
-        "RebootOpenDTU": "Reboot OpenDTU",
+        "RebootOpenDTU": "Reboot OpenDTU-OnBattery",
         "RebootQuestion": "Do you really want to reboot the device?",
-        "RebootHint": "<b>Note:</b> A manual reboot does not normally have to be performed. OpenDTU performs any required reboot (e.g. after a firmware update) automatically. Settings are also adopted without rebooting. If you need to reboot due to an error, please consider reporting it at <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/issues\" class=\"alert-link\" target=\"_blank\">Github</a>."
+        "RebootHint": "<b>Note:</b> A manual reboot does not normally have to be performed. OpenDTU-OnBattery performs any required reboot (e.g. after a firmware update) automatically. Settings are also adopted without rebooting. If you need to reboot due to an error, please consider reporting it at <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/issues\" class=\"alert-link\" target=\"_blank\">Github</a>."
     },
     "dtuadmin": {
         "DtuSettings": "DTU Settings",
         "DtuConfiguration": "DTU Configuration",
-        "Serial": "Serial:",
+        "Serial": "Serial",
         "SerialHint": "Both the inverter and the DTU have a serial number. The DTU serial number is randomly generated at the first start and does not normally need to be changed.",
-        "PollInterval": "Poll Interval:",
+        "PollInterval": "Poll Interval",
         "VerboseLogging": "@:base.VerboseLogging",
         "Seconds": "Seconds",
-        "NrfPaLevel": "NRF24 Transmitting power:",
-        "CmtPaLevel": "CMT2300A Transmitting power:",
+        "NrfPaLevel": "NRF24 Transmitting power",
+        "CmtPaLevel": "CMT2300A Transmitting power",
         "NrfPaLevelHint": "Used for HM-Inverters. Make sure your power supply is stable enough before increasing the transmit power.",
         "CmtPaLevelHint": "Used for HMS/HMT-Inverters. Make sure your power supply is stable enough before increasing the transmit power.",
-        "CmtCountry": "CMT2300A Region/Country:",
+        "CmtCountry": "CMT2300A Region/Country",
         "CmtCountryHint": "Each country has different frequency allocations.",
         "country_0": "Europe ({min}MHz - {max}MHz)",
         "country_1": "North America ({min}MHz - {max}MHz)",
         "country_2": "Brazil ({min}MHz - {max}MHz)",
-        "CmtFrequency": "CMT2300A Frequency:",
+        "CmtFrequency": "CMT2300A Frequency",
         "CmtFrequencyHint": "Make sure to only use frequencies that are allowed in the respective country! After a frequency change, it can take up to 15min until a connection is established.",
         "CmtFrequencyWarning": "The selected frequency is outside the allowed range in your selected region/country. Make sure that this selection does not violate any local regulations.",
         "MHz": "{mhz} MHz",
@@ -486,8 +496,8 @@
     "securityadmin": {
         "SecuritySettings": "Security Settings",
         "AdminPassword": "Admin password",
-        "Password": "Password:",
-        "RepeatPassword": "Repeat Password:",
+        "Password": "Password",
+        "RepeatPassword": "Repeat Password",
         "PasswordHint": "<b>Hint:</b> The administrator password is used to access this web interface (user 'admin'), but also to connect to the device when in AP mode. It must be 8..64 characters.",
         "Permissions": "Permissions",
         "ReadOnly": "Allow readonly access to web interface without password"
@@ -495,10 +505,10 @@
     "ntpadmin": {
         "NtpSettings": "NTP Settings",
         "NtpConfiguration": "NTP Configuration",
-        "TimeServer": "Time Server:",
-        "TimeServerHint": "The default value is fine as long as OpenDTU has direct access to the internet.",
-        "Timezone": "Timezone:",
-        "TimezoneConfig": "Timezone Config:",
+        "TimeServer": "Time Server",
+        "TimeServerHint": "The default value is fine as long as OpenDTU-OnBattery has direct access to the internet.",
+        "Timezone": "Timezone",
+        "TimezoneConfig": "Timezone Config",
         "LocationConfiguration": "Location Configuration",
         "Longitude": "Longitude",
         "Latitude": "Latitude",
@@ -509,26 +519,26 @@
         "CIVIL": "Civil dawn (96°)",
         "ASTONOMICAL": "Astronomical dawn (108°)",
         "ManualTimeSynchronization": "Manual Time Synchronization",
-        "CurrentOpenDtuTime": "Current OpenDTU Time:",
-        "CurrentLocalTime": "Current Local Time:",
+        "CurrentOpenDtuTime": "Current OpenDTU-OnBattery Time",
+        "CurrentLocalTime": "Current Local Time",
         "SynchronizeTime": "Synchronize Time",
-        "SynchronizeTimeHint": "<b>Hint:</b> You can use the manual time synchronization to set the current time of OpenDTU if no NTP server is available. But be aware, that in case of power cycle the time gets lost. Also note that time accuracy will be skewed badly, as it can not be resynchronised regularly and the ESP32 microcontroller does not have a real time clock."
+        "SynchronizeTimeHint": "<b>Hint:</b> You can use the manual time synchronization to set the current time of OpenDTU-OnBattery if no NTP server is available. But be aware, that in case of power cycle the time gets lost. Also note that time accuracy will be skewed badly, as it can not be resynchronised regularly and the ESP32 microcontroller does not have a real time clock."
     },
     "networkadmin": {
         "NetworkSettings": "Network Settings",
         "WifiConfiguration": "WiFi Configuration",
-        "WifiSsid": "WiFi SSID:",
-        "WifiPassword": "WiFi Password:",
-        "Hostname": "Hostname:",
+        "WifiSsid": "WiFi SSID",
+        "WifiPassword": "WiFi Password",
+        "Hostname": "Hostname",
         "HostnameHint": "<b>Hint:</b> The text <span class=\"font-monospace\">%06X</span> will be replaced with the last 6 digits of the ESP ChipID in hex format.",
         "EnableDhcp": "Enable DHCP",
         "StaticIpConfiguration": "Static IP Configuration",
-        "IpAddress": "IP Address:",
-        "Netmask": "Netmask:",
-        "DefaultGateway": "Default Gateway:",
-        "Dns": "DNS Server {num}:",
+        "IpAddress": "IP Address",
+        "Netmask": "Netmask",
+        "DefaultGateway": "Default Gateway",
+        "Dns": "DNS Server {num}",
         "AdminAp": "WiFi Configuration (Admin AccessPoint)",
-        "ApTimeout": "AccessPoint Timeout:",
+        "ApTimeout": "AccessPoint Timeout",
         "ApTimeoutHint": "Time which the AccessPoint is kept open. A value of 0 means infinite.",
         "Minutes": "minutes",
         "EnableMdns": "Enable mDNS",
@@ -545,38 +555,38 @@
         "VerboseLogging": "@:base.VerboseLogging",
         "EnableHass": "Enable Home Assistant MQTT Auto Discovery",
         "MqttBrokerParameter": "MQTT Broker Parameter",
-        "Hostname": "Hostname:",
+        "Hostname": "Hostname",
         "HostnameHint": "Hostname or IP address",
-        "Port": "Port:",
-        "ClientId": "Client ID:",
-        "Username": "Username:",
+        "Port": "Port",
+        "ClientId": "Client ID",
+        "Username": "Username",
         "UsernameHint": "Username, leave empty for anonymous connection",
-        "Password": "Password:",
+        "Password": "Password",
         "PasswordHint": "Password, leave empty for anonymous connection",
-        "BaseTopic": "Base Topic:",
+        "BaseTopic": "Base Topic",
         "BaseTopicHint": "Base topic, will be prepend to all published topics (e.g. inverter/)",
-        "PublishInterval": "Publish Interval:",
+        "PublishInterval": "Publish Interval",
         "Seconds": "seconds",
         "CleanSession": "Enable CleanSession flag",
         "EnableRetain": "Enable Retain Flag",
         "EnableTls": "Enable TLS",
-        "RootCa": "CA-Root-Certificate (default Letsencrypt):",
+        "RootCa": "CA-Root-Certificate (default Letsencrypt)",
         "TlsCertLoginEnable": "Enable TLS Certificate Login",
-        "ClientCert": "TLS Client-Certificate:",
-        "ClientKey": "TLS Client-Key:",
+        "ClientCert": "TLS Client-Certificate",
+        "ClientKey": "TLS Client-Key",
         "LwtParameters": "LWT Parameters",
-        "LwtTopic": "LWT Topic:",
+        "LwtTopic": "LWT Topic",
         "LwtTopicHint": "LWT topic, will be append base topic",
-        "LwtOnline": "LWT Online message:",
+        "LwtOnline": "LWT Online message",
         "LwtOnlineHint": "Message that will be published to LWT topic when online",
-        "LwtOffline": "LWT Offline message:",
+        "LwtOffline": "LWT Offline message",
         "LwtOfflineHint": "Message that will be published to LWT topic when offline",
-        "LwtQos": "QoS (Quality of Service):",
+        "LwtQos": "QoS (Quality of Service)",
         "QOS0": "0 (At most once)",
         "QOS1": "1 (At least once)",
         "QOS2": "2 (Exactly once)",
         "HassParameters": "Home Assistant MQTT Auto Discovery Parameters",
-        "HassPrefixTopic": "Prefix Topic:",
+        "HassPrefixTopic": "Prefix Topic",
         "HassPrefixTopicHint": "The prefix for the discovery topic",
         "HassRetain": "Enable Retain Flag",
         "HassExpire": "Enable Expiration",
@@ -652,11 +662,12 @@
         "ConfigHintsIntro": "The following notes regarding the Dynamic Power Limiter (DPL) configuration shall be considered:",
         "ConfigHintPowerMeterDisabled": "Without a power meter interface, the inverter limit the DPL will configure equals the configured base load (exception: (full) solar-passthrough).",
         "ConfigHintNoInverter": "At least one inverter must be configured prior to setting up the DPL.",
-        "ConfigHintInverterCommunication": "Polling data from and sending commands to the target inverter must be enabled.",
+        "ConfigHintInverterCommunication": "Polling data from and sending commands to all managed inverters must be enabled.",
         "ConfigHintNoChargeController": "The solar-passthrough feature can only be used if the VE.Direct interface is configured.",
         "ConfigHintNoBatteryInterface": "SoC-based thresholds can only be used if a battery communication interface is configured.",
         "General": "General",
         "Enable": "Enable",
+        "GovernInverter": "Govern Inverter \"{name}\"",
         "VerboseLogging": "@:base.VerboseLogging",
         "SolarPassthrough": "Solar-Passthrough",
         "EnableSolarPassthrough": "Enable Solar-Passthrough",
@@ -664,34 +675,51 @@
         "SolarPassthroughLossesInfo": "<b>Hint:</b> Line losses are to be expected when transferring energy from the solar charge controller to the inverter. These losses can be taken into account to prevent the battery from gradually discharging in (full) solar-passthrough mode. The power limit to be set on the inverter is additionally reduced by this factor after taking its efficiency into account.",
         "BatteryDischargeAtNight": "Use battery at night even if only partially charged",
         "SolarpassthroughInfo": "This feature allows to use the available current solar power directly. The solar power, as reported by the MPPT charge controller, is set as the inverter's limit, even if the battery is currently charging. This avoids storing energy unnecessarily, which would be lossy.",
-        "InverterSettings": "Inverter",
-        "Inverter": "Target Inverter",
+        "InverterSettings": "Inverter Settings",
         "SelectInverter": "Select an inverter...",
+        "InverterForDcVoltage": "Inverter used for voltage measurements",
         "InverterChannelId": "Input used for voltage measurements",
         "TargetPowerConsumption": "Target Grid Consumption",
-        "TargetPowerConsumptionHint": "Grid power consumption the limiter tries to achieve. Value may be negative.",
+        "TargetPowerConsumptionHint": "Grid power consumption the dynamic power limiter tries to achieve. Value may be negative.",
         "TargetPowerConsumptionHysteresis": "Hysteresis",
-        "TargetPowerConsumptionHysteresisHint": "Only send a newly calculated power limit to the inverter if the absolute difference to the last reported power limit exceeds this amount.",
+        "TargetPowerConsumptionHysteresisHint": "Only send a newly calculated power limit to the respective inverter if the absolute difference to the last reported power limit exceeds this amount.",
         "LowerPowerLimit": "Minimum Power Limit",
         "LowerPowerLimitHint": "This value must be selected so that stable operation is possible at this limit. If the inverter could only be operated with a lower limit, it is put into standby instead.",
         "BaseLoadLimit": "Base Load",
-        "BaseLoadLimitHint": "Relevant for operation without power meter or when the power meter fails. As long as the other conditions allow (in particular battery charge), this limit is set on the inverter.",
+        "BaseLoadLimitHint": "Relevant for operation without power meter or when the power meter fails. As long as the other conditions allow (battery charge in particular), the inverters are configured to output this amount of power in total.",
+        "TotalUpperPowerLimit": "Maximum Total Output",
+        "TotalUpperPowerLimitHint": "The inverters are configured to output this maximum amount of power in total.",
+        "ManagedInverters": "Managed Inverters",
+        "AddInverter": "Add Inverter",
+        "NoManagedInverters": "The Dynamic Power Limiter is currently not managing any inverters. To continue, select an inverter in the dropdown list above and add it.",
+        "InverterLabel": "Name (Type)",
+        "PowerSource": "Power Source",
+        "PowerSourceBattery": "Battery",
+        "PowerSourceSolarPanels": "Solar Panel(s)",
+        "EditInverter": "Edit Inverter",
+        "EditInverterLabel": "Concerns Inverter",
+        "Apply": "Apply",
+        "Cancel": "@:base.Cancel",
+        "Delete": "Delete",
+        "DeleteInverter": "Confirm Removal",
+        "DeleteInverterMsg": "Should inverter {label} with serial number {serial} be removed from the list of inverters managed by the Dynamic Power Limiter?",
         "UpperPowerLimit": "Maximum Power Limit",
         "UpperPowerLimitHint": "The inverter is always set such that no more than this output power is achieved. This value must be selected to comply with the current carrying capacity of the AC connection cables.",
         "SocThresholds": "Battery State of Charge (SoC) Thresholds",
-        "IgnoreSoc": "Ignore Battery SoC",
+        "IgnoreSoc": "Use Voltage Threshols Only",
+        "IgnoreSocHint": "When enabled, only voltage thresholds are considered. Disable this switch to configure and use battery State of Charge (SoC) thresholds (not recommended as the SoC value is often inaccurate).",
         "StartThreshold": "Start Threshold for Battery Discharging",
         "StopThreshold": "Stop Threshold for Battery Discharging",
         "FullSolarPassthroughStartThreshold": "Full Solar-Passthrough Start Threshold",
         "FullSolarPassthroughStartThresholdHint": "Inverter power is set equal to Victron MPPT power (minus efficiency factors) while above this threshold. Use this if you want to supply excess power to the grid when the battery is full.",
         "VoltageSolarPassthroughStopThreshold": "Full Solar-Passthrough Stop Threshold",
         "VoltageLoadCorrectionFactor": "Load correction factor",
-        "BatterySocInfo": "<b>Hint:</b> The battery SoC (State of Charge) values are only used if the battery communication interface reported SoC updates in the last minute. Otherwise the voltage thresholds will be used as fallback.",
+        "BatterySocInfo": "<b>Hint:</b> The use of battery State of Charge (SoC) thresholds is prioritized. However, SoC thresholds are only used if the battery communication interface has processed valid SoC values in the last minute. Otherwise, the voltage thresholds will be used as fallback.",
         "InverterIsBehindPowerMeter": "PowerMeter reading includes inverter output",
         "InverterIsBehindPowerMeterHint": "Enable this option if the power meter reading is reduced by the inverter's output when it produces power. This is typically true.",
         "InverterIsSolarPowered": "Inverter is powered by solar modules",
         "UseOverscalingToCompensateShading": "Compensate for shading",
-        "UseOverscalingToCompensateShadingHint": "Allow to overscale the inverter limit to compensate for shading of one or multiple inputs",
+        "UseOverscalingToCompensateShadingHint": "Allow to overscale the inverter limit to compensate for shading of one or multiple inputs.",
         "VoltageThresholds": "Battery Voltage Thresholds",
         "VoltageLoadCorrectionInfo": "<b>Hint:</b> When the battery is discharged, its voltage drops. The voltage drop scales with the discharge current. In order to not stop the inverter too early (stop threshold), this load correction factor can be specified to calculate the battery voltage if it was idle. Corrected voltage = DC Voltage + (Current power * correction factor).",
         "InverterRestartHour": "Automatic Restart Time",
@@ -707,6 +735,7 @@
         "ProviderPylontechCan": "Pylontech using CAN bus",
         "ProviderSBSCan": "SBS Unipower using CAN bus",
         "ProviderJkBmsSerial": "Jikong (JK) BMS using serial connection",
+        "ProviderJbdBmsSerial": "Jiabaida (JBD) BMS using serial connection",
         "ProviderMqtt": "Battery data from MQTT broker",
         "ProviderVictron": "Victron SmartShunt using VE.Direct interface",
         "ProviderPytesCan": "Pytes using CAN bus",
@@ -718,15 +747,20 @@
         "MqttVoltageUnit": "Unit",
         "MqttSocTopic": "SoC Value Topic",
         "MqttVoltageTopic": "Voltage Value Topic",
-        "JkBmsConfiguration": "JK BMS Settings",
-        "JkBmsInterface": "Interface Type",
-        "JkBmsInterfaceUart": "TTL-UART on MCU",
-        "JkBmsInterfaceTransceiver": "RS-485 Transceiver on MCU",
+        "SerialSettings": "Serial Settings",
+        "SerialInterfaceType": "Interface Type",
+        "SerialInterfaceTypeUart": "TTL-UART on MCU",
+        "SerialInterfaceTypeTransceiver": "RS-485 Transceiver on MCU",
+        "JbdBmsConfiguration": "JBD BMS Settings",
         "PollingInterval": "Polling Interval",
         "Seconds": "@:base.Seconds",
         "DischargeCurrentLimitConfiguration": "Discharge Current Limit Settings",
         "LimitDischargeCurrent": "Limit Discharge Current",
         "DischargeCurrentLimit": "max. Discharge Current",
+        "DischargeCurrentLimitBelowSoc": "Apply limit below SoC",
+        "DischargeCurrentLimitBelowSocInfo": "The discharge current limit is only applied below this SoC (not used if 'Ignore Battery SoC' is enabled in the DPL settings).",
+        "DischargeCurrentLimitBelowVoltage": "Apply limit below voltage",
+        "DischargeCurrentLimitBelowVoltageInfo": "The discharge current limit is only applied below this voltage (used if 'Ignore Battery SoC' is enabled in the DPL settings or when SoC is unavailable).",
         "UseBatteryReportedDischargeCurrentLimit": "Use Battery-Reported limit",
         "BatteryReportedDischargeCurrentLimitInfo": "<b>Hint:</b> The lowest limit will be applied, with the battery-reported discharge current limit used only if an update was received in the last minute; otherwise, the previously specified limit will act as a fallback.",
         "MqttDischargeCurrentTopic": "Discharge Current Limit Value Topic",
@@ -767,7 +801,7 @@
         "StringYtOffset": "Yield total offset string {num}:",
         "StringYtOffsetHint": "This offset is applied the read yield total value from the inverter. This can be used to set the yield total of the inverter to zero if a used inverter is used. But you can still try polling data.",
         "InverterHint": "*) Enter the W<sub>p</sub> of the channel to calculate irradiation.",
-        "ReachableThreshold": "Reachable Threshold:",
+        "ReachableThreshold": "Reachable Threshold",
         "ReachableThresholdHint": "Defines how many requests are allowed to fail until the inverter is treated is not reachable.",
         "ZeroRuntime": "Zero runtime data",
         "ZeroRuntimeHint": "Zero runtime data (no yield data) if inverter becomes unreachable.",
@@ -781,24 +815,30 @@
         "YieldDayCorrection": "Yield Day Correction",
         "YieldDayCorrectionHint": "Sum up daily yield even if the inverter is restarted. Value will be reset at midnight"
     },
-    "configadmin": {
+    "fileadmin": {
         "ConfigManagement": "Config Management",
         "BackupHeader": "Backup: Configuration File Backup",
-        "BackupConfig": "Backup the configuration file",
-        "Backup": "Backup",
         "Restore": "Restore",
         "NoFileSelected": "No file selected",
         "RestoreHeader": "Restore: Restore the Configuration File",
         "Back": "Back",
         "UploadSuccess": "Upload Success",
-        "RestoreHint": "<b>Note:</b> This operation replaces the configuration file with the restored configuration and restarts OpenDTU to apply all settings.",
+        "RestoreHint": "<b>Note:</b> This operation replaces the configuration file with the restored configuration and restarts OpenDTU-OnBattery to apply all settings.",
         "ResetHeader": "Initialize: Perform Factory Reset",
         "FactoryResetButton": "Restore Factory-Default Settings",
         "ResetHint": "<b>Note:</b> Click Restore Factory-Default Settings to restore and initialize the factory-default settings and reboot.",
         "FactoryReset": "Factory Reset",
         "ResetMsg": "Are you sure you want to delete the current configuration and reset all settings to their factory defaults?",
         "ResetConfirm": "Factory Reset!",
-        "Cancel": "@:base.Cancel"
+        "Download": "Download",
+        "Delete": "Delete",
+        "DeleteMsg": "Are you sure you want to delete file: '{name}'? You have to manually reboot the device to apply config changes!",
+        "Name": "Name",
+        "Size": "Size",
+        "Action": "Action",
+        "Cancel": "@:base.Cancel",
+        "InvalidJson": "JSON file is formatted incorrectly.",
+        "InvalidJsonContent": "JSON file has the wrong content."
     },
     "login": {
         "Login": "Login",
@@ -829,7 +869,7 @@
         "ProjectOriginBody1": "OpenDTU-OnBattery is a fork of OpenDTU. The upstream project OpenDTU was started from <a href=\"https://www.mikrocontroller.net/topic/525778\" target=\"_blank\">this discussion. (Mikrocontroller.net)</a>",
         "ProjectOriginBody2": "The Hoymiles protocol was decrypted through the voluntary efforts of many participants. OpenDTU, among others, was developed based on this work. The project is licensed under an Open Source License (<a href=\"https://www.gnu.de/documents/gpl-2.0.de.html\" target=\"_blank\">GNU General Public License version 2</a>).",
         "ProjectOriginBody3": "The software was developed to the best of our knowledge and belief. Nevertheless, no liability can be accepted for a malfunction or guarantee loss of the inverter.",
-        "ProjectOriginBody4": "OpenDTU is freely available. If you paid money for the software, you probably got ripped off.",
+        "ProjectOriginBody4": "OpenDTU and OpenDTU-OnBattery are freely available. If you paid money for the software, you probably got ripped off.",
         "NewsUpdates": "News & Updates",
         "NewsUpdatesBody": "New updates can be found on <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/releases\" target=\"_blank\">Github</a>.",
         "ErrorReporting": "Error Reporting",
@@ -848,37 +888,36 @@
         "DeviceManager": "Device-Manager",
         "ParseError": "Parse error in 'pin_mapping.json': {error}",
         "PinAssignment": "Connection settings",
-        "SelectedProfile": "Selected profile:",
+        "SelectedProfile": "Selected profile",
         "DefaultProfile": "(Default settings)",
         "ProfileHint": "Your device may stop responding if you select an incompatible profile. In this case, you must perform a deletion via the serial interface.",
         "Display": "Display",
-        "PowerSafe": "Switch off if no solar:",
+        "PowerSafe": "Switch off if no solar",
         "PowerSafeHint": "Turn off the display if no inverter is producing.",
-        "Screensaver": "OLED Anti burn-in:",
+        "Screensaver": "OLED Anti burn-in",
         "ScreensaverHint": "Move the display a little bit on each update to prevent burn-in. (Useful especially for OLED displays)",
-        "DiagramMode": "Diagram mode:",
+        "DiagramMode": "Diagram mode",
         "off": "Off",
         "small": "Small",
         "fullscreen": "Fullscreen",
-        "DiagramDuration": "Diagram duration:",
+        "DiagramDuration": "Diagram duration",
         "DiagramDurationHint": "The time period which is shown in the diagram.",
         "Seconds": "Seconds",
-        "Contrast": "Contrast ({contrast}):",
-        "Rotation": "Rotation:",
+        "Contrast": "Contrast ({contrast})",
+        "Rotation": "Rotation",
         "rot0": "No rotation",
         "rot90": "90 degree rotation",
         "rot180": "180 degree rotation",
         "rot270": "270 degree rotation",
-        "DisplayLanguage": "Display language:",
+        "DisplayLanguage": "Display language",
         "en": "English",
         "de": "German",
         "fr": "French",
         "Leds": "LEDs",
-        "EqualBrightness": "Equal brightness:",
-        "LedBrightness": "LED {led} brightness ({brightness}):"
+        "EqualBrightness": "Equal brightness",
+        "LedBrightness": "LED {led} brightness ({brightness})"
     },
     "pininfo": {
-        "PinOverview": "Connection overview",
         "Category": "Category",
         "Name": "Name",
         "Number": "Number",
@@ -916,9 +955,9 @@
         "SetOnline": "Set limit, CAN bus connected",
         "LimitHint": "<b>Hint:</b> CAN bus not connected voltage limit is 48V-58.5V.",
         "Close": "close",
-        "SetVoltageLimit": "Voltage limit:",
-        "SetCurrentLimit": "Current limit:",
-        "CurrentLimit": "Current limit:"
+        "SetVoltageLimit": "Voltage limit",
+        "SetCurrentLimit": "Current limit",
+        "CurrentLimit": "Current limit"
     },
     "acchargeradmin": {
         "ChargerSettings": "AC Charger Settings",
@@ -940,7 +979,8 @@
         "StopBatterySoCThreshold": "Stop charging at SoC",
         "StopBatterySoCThresholdHint": "To prolong the battery's lifespan, charging can be stopped at a certain SoC level.\nHint: In order to keep the SoC reading accurate, some LiFePO cells must be charged to full capacity regularly.",
         "Seconds": "@:base.Seconds",
-        "EnableEmergencyCharge": "Emergency charge. Battery charged with maximum power if requested by Battery BMS",
+        "EnableEmergencyCharge": "Emergency charge",
+        "EnableEmergencyChargeHint": "Battery charged with maximum power if requested by Battery BMS",
         "targetPowerConsumption": "Target power consumption",
         "targetPowerConsumptionHint": "Postitive values use grid power to charge the battery. Negative values result in early shutdown"
     },
@@ -997,32 +1037,56 @@
         "issueType": "Type",
         "alarm": "Alarm",
         "warning": "Warning",
+        "CommonIssueCellOverVoltage": "Overvoltage (single cell)",
+        "CommonIssueCellUnderVoltage": "Undervoltage (single cell)",
+        "CommonIssuePackOverVoltage": "Overvoltage (sum of all cells)",
+        "CommonIssuePackUnderVoltage": "Undervoltage (sum of all cells)",
+        "CommonIssueChargingOverCurrent": "Overcurrent (Charging)",
+        "CommonIssueDischargeOverCurrent": "Overcurrent (Discharging)",
+        "CommonIssueChargingOverTemperature": "Overtemperature (Charging)",
+        "CommonIssueChargingLowTemperature": "Undertemperature (Charging)",
         "JkBmsIssueLowCapacity": "Low Capacity",
         "JkBmsIssueBmsOvertemperature": "BMS overtemperature",
-        "JkBmsIssueChargingOvervoltage": "Overvoltage (sum of all cells)",
-        "JkBmsIssueDischargeUndervoltage": "Undervoltage (sum of all cells)",
+        "JkBmsIssueChargingOvervoltage": "@:battery.CommonIssuePackOverVoltage",
+        "JkBmsIssueDischargeUndervoltage": "@:battery.CommonIssuePackUnderVoltage",
         "JkBmsIssueBatteryOvertemperature": "Battery overtemperature",
-        "JkBmsIssueChargingOvercurrent": "Overcurrent (Charging)",
-        "JkBmsIssueDischargeOvercurrent": "Overcurrent (Discharging)",
+        "JkBmsIssueChargingOvercurrent": "@:battery.CommonIssueChargingOverCurrent",
+        "JkBmsIssueDischargeOvercurrent": "@:battery.CommonIssueDischargeOverCurrent",
         "JkBmsIssueCellVoltageDifference": "Cell voltage difference too high",
         "JkBmsIssueBatteryBoxOvertemperature": "Battery (box?) overtemperature",
         "JkBmsIssueBatteryUndertemperature": "Battery undertemperature",
-        "JkBmsIssueCellOvervoltage": "Overvoltage (single cell)",
-        "JkBmsIssueCellUndervoltage": "Undervoltage (single cell)",
+        "JkBmsIssueCellOvervoltage": "@:battery.CommonIssueCellOverVoltage",
+        "JkBmsIssueCellUndervoltage": "@:battery.CommonIssueCellUnderVoltage",
         "JkBmsIssueAProtect": "AProtect (meaning?)",
         "JkBmsIssueBProtect": "BProtect (meaning?)",
+        "JbdBmsIssueCellOverVoltage": "@:battery.CommonIssueCellOverVoltage",
+        "JbdBmsIssueCellUnderVoltage": "@:battery.CommonIssueCellUnderVoltage",
+        "JbdBmsIssuePackOverVoltage": "@:battery.CommonIssuePackOverVoltage",
+        "JbdBmsIssuePackUnderVoltage": "@:battery.CommonIssuePackUnderVoltage",
+        "JbdBmsIssueChargingOverTemperature": "@:battery.CommonIssueChargingOverTemperature",
+        "JbdBmsIssueChargingLowTemperature": "@:battery.CommonIssueChargingLowTemperature",
+        "JbdBmsIssueDischargingOverTemperature": "Overtemperature (Discharging)",
+        "JbdBmsIssueDischargingLowTemperature": "Undertemperature (Discharging)",
+        "JbdBmsIssueChargingOverCurrent": "@:battery.CommonIssueChargingOverCurrent",
+        "JbdBmsIssueDischargeOverCurrent": "@:battery.CommonIssueDischargeOverCurrent",
+        "JbdBmsIssueShortCircuit": "Short Circuit",
+        "JbdBmsIssueIcFrontEndError": "IC Frontend Error",
+        "JbdBmsIssueMosSotwareLock": "Charging/Discharging Prevented",
+        "JbdBmsIssueReserved1": "Reserved 1",
+        "JbdBmsIssueReserved2": "Reserved 2",
+        "JbdBmsIssueReserved3": "Reserved 3",
         "highCurrentDischarge": "High current (discharge)",
-        "overCurrentDischarge": "Overcurrent (discharge)",
+        "overCurrentDischarge": "@:battery.CommonIssueDischargeOverCurrent",
         "highCurrentCharge": "High current (charge)",
-        "overCurrentCharge": "Overcurrent (charge)",
+        "overCurrentCharge": "@:battery.CommonIssueChargingOverCurrent",
         "lowTemperature": "Low temperature",
         "underTemperature": "Undertemperature",
         "lowTemperatureCharge": "Low temperature (charge)",
-        "underTemperatureCharge": "Undertemperature (charge)",
+        "underTemperatureCharge": "@:battery.CommonIssueChargingLowTemperature",
         "highTemperature": "High temperature",
         "overTemperature": "Overtemperature",
         "highTemperatureCharge": "High temperature (charge)",
-        "overTemperatureCharge": "Overtemperature (charge)",
+        "overTemperatureCharge": "@:battery.CommonIssueChargingOverTemperature",
         "lowVoltage": "Low voltage",
         "lowSOC": "Low state of charge",
         "underVoltage": "Undervoltage",
diff --git a/webapp/src/locales/fr.json b/webapp/src/locales/fr.json
index 58e15796..8f235cd1 100644
--- a/webapp/src/locales/fr.json
+++ b/webapp/src/locales/fr.json
@@ -41,6 +41,10 @@
         "Release": "Release to refresh",
         "Close": "Fermer"
     },
+    "wait": {
+        "NotReady": "OpenDTU is not yet ready",
+        "PleaseWait": "Please wait. You will be automatically redirected to the home page."
+    },
     "Error": {
         "Oops": "Oops!"
     },
@@ -63,6 +67,7 @@
         "2005": "Invalid country selection !",
         "3001": "Rien n'a été supprimé !",
         "3002": "Configuration réinitialisée. Redémarrage maintenant...",
+        "3003": "File successful deleted. Restart to apply changes!",
         "4001": "@:apiresponse.2001",
         "4002": "Le nom doit comporter entre 1 et {max} caractères !",
         "4003": "Seulement {max} onduleurs sont supportés !",
@@ -175,9 +180,12 @@
         "section_device": "Device Info",
         "device": {
             "LOAD": "Load output state",
+            "VIRTLOAD": "Virtual load output state",
+            "IL": "Load current",
             "CS": "State of operation",
             "MPPT": "Tracker operation mode",
             "OR": "Off reason",
+            "RELAY": "Error relay state",
             "ERR": "Error code",
             "HSDS": "Day sequence number (0..364)",
             "MpptTemperature": "Charge controller temperature"
@@ -188,6 +196,8 @@
             "V": "Voltage",
             "I": "Current",
             "E": "Efficiency (calculated)",
+            "AbsorptionVoltage": "Absorption voltage",
+            "FloatVoltage": "Float voltage",
             "SBSTemperature": "SBS temperature"
         },
         "section_input": "Input (Solar Panels)",
@@ -467,9 +477,9 @@
         "PerformReboot": "Effectuer un redémarrage",
         "Reboot": "Redémarrer !",
         "Cancel": "@:base.Cancel",
-        "RebootOpenDTU": "Redémarrer OpenDTU",
+        "RebootOpenDTU": "Redémarrer OpenDTU-OnBattery",
         "RebootQuestion": "Voulez-vous vraiment redémarrer l'appareil ?",
-        "RebootHint": "<b>Astuce :</b> Normalement, il n'est pas nécessaire de procéder à un redémarrage manuel. OpenDTU effectue automatiquement tout redémarrage nécessaire (par exemple, après une mise à jour du firmware). Les paramètres sont également adoptés sans redémarrage. Si vous devez redémarrer en raison d'une erreur, veuillez envisager de la signaler à l'adresse suivante <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/issues\" class=\"alert-link\" target=\"_blank\">Github</a>."
+        "RebootHint": "<b>Astuce :</b> Normalement, il n'est pas nécessaire de procéder à un redémarrage manuel. OpenDTU-OnBattery effectue automatiquement tout redémarrage nécessaire (par exemple, après une mise à jour du firmware). Les paramètres sont également adoptés sans redémarrage. Si vous devez redémarrer en raison d'une erreur, veuillez envisager de la signaler à l'adresse suivante <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/issues\" class=\"alert-link\" target=\"_blank\">Github</a>."
     },
     "dtuadmin": {
         "DtuSettings": "Paramètres du DTU",
@@ -483,12 +493,12 @@
         "CmtPaLevel": "CMT2300A Niveau de puissance d'émission",
         "NrfPaLevelHint": "Used for HM-Inverters. Assurez-vous que votre alimentation est suffisamment stable avant d'augmenter la puissance d'émission.",
         "CmtPaLevelHint": "Used for HMS/HMT-Inverters. Assurez-vous que votre alimentation est suffisamment stable avant d'augmenter la puissance d'émission.",
-        "CmtCountry": "CMT2300A Region/Country:",
+        "CmtCountry": "CMT2300A Region/Country",
         "CmtCountryHint": "Each country has different frequency allocations.",
         "country_0": "Europe ({min}MHz - {max}MHz)",
         "country_1": "North America ({min}MHz - {max}MHz)",
         "country_2": "Brazil ({min}MHz - {max}MHz)",
-        "CmtFrequency": "CMT2300A Frequency:",
+        "CmtFrequency": "CMT2300A Frequency",
         "CmtFrequencyHint": "Make sure to only use frequencies that are allowed in the respective country! After a frequency change, it can take up to 15min until a connection is established.",
         "CmtFrequencyWarning": "The selected frequency is outside the allowed range in your selected region/country. Make sure that this selection does not violate any local regulations.",
         "MHz": "{mhz} MHz",
@@ -511,7 +521,7 @@
         "NtpSettings": "Paramètres NTP",
         "NtpConfiguration": "Configuration du protocole NTP",
         "TimeServer": "Serveur horaire",
-        "TimeServerHint": "La valeur par défaut convient tant que OpenDTU a un accès direct à Internet.",
+        "TimeServerHint": "La valeur par défaut convient tant que OpenDTU-OnBattery a un accès direct à Internet.",
         "Timezone": "Fuseau horaire",
         "TimezoneConfig": "Configuration du fuseau horaire",
         "LocationConfiguration": "Géolocalisation",
@@ -524,10 +534,10 @@
         "CIVIL": "Civil dawn (96°)",
         "ASTONOMICAL": "Astronomical dawn (108°)",
         "ManualTimeSynchronization": "Synchronisation manuelle de l'heure",
-        "CurrentOpenDtuTime": "Heure actuelle de l'OpenDTU",
+        "CurrentOpenDtuTime": "Heure actuelle de l'OpenDTU-OnBattery",
         "CurrentLocalTime": "Heure locale actuelle",
         "SynchronizeTime": "Synchroniser l'heure",
-        "SynchronizeTimeHint": "<b>Astuce :</b> Vous pouvez utiliser la synchronisation horaire manuelle pour définir l'heure actuelle d'OpenDTU si aucun serveur NTP n'est disponible. Mais attention, en cas de mise sous tension, l'heure est perdue. Notez également que la précision de l'heure sera faussée, car elle ne peut pas être resynchronisée régulièrement et le microcontrôleur ESP32 ne dispose pas d'une horloge temps réel."
+        "SynchronizeTimeHint": "<b>Astuce :</b> Vous pouvez utiliser la synchronisation horaire manuelle pour définir l'heure actuelle d'OpenDTU-OnBattery si aucun serveur NTP n'est disponible. Mais attention, en cas de mise sous tension, l'heure est perdue. Notez également que la précision de l'heure sera faussée, car elle ne peut pas être resynchronisée régulièrement et le microcontrôleur ESP32 ne dispose pas d'une horloge temps réel."
     },
     "networkadmin": {
         "NetworkSettings": "Paramètres réseau",
@@ -559,10 +569,10 @@
         "Hostname": "Nom d'hôte",
         "HostnameHint": "Nom d'hôte ou adresse IP",
         "Port": "Port",
-        "ClientId": "Client ID:",
+        "ClientId": "Client ID",
         "Username": "Nom d'utilisateur",
         "UsernameHint": "Nom d'utilisateur, laisser vide pour une connexion anonyme",
-        "Password": "Mot de passe:",
+        "Password": "Mot de passe",
         "PasswordHint": "Mot de passe, laissez vide pour une connexion anonyme",
         "BaseTopic": "Sujet de base",
         "BaseTopicHint": "Sujet de base, qui sera ajouté en préambule à tous les sujets publiés (par exemple, inverter/).",
@@ -573,8 +583,8 @@
         "EnableTls": "Activer le TLS",
         "RootCa": "Certificat CA-Root (par défaut Letsencrypt)",
         "TlsCertLoginEnable": "Activer la connexion par certificat TLS",
-        "ClientCert": "Certificat client TLS:",
-        "ClientKey": "Clé client TLS:",
+        "ClientCert": "Certificat client TLS",
+        "ClientKey": "Clé client TLS",
         "LwtParameters": "Paramètres LWT",
         "LwtTopic": "Sujet LWT",
         "LwtTopicHint": "Sujet LWT, sera ajouté comme sujet de base",
@@ -582,7 +592,7 @@
         "LwtOnlineHint": "Message qui sera publié sur le sujet LWT lorsqu'il sera en ligne",
         "LwtOffline": "Message hors ligne de LWT",
         "LwtOfflineHint": "Message qui sera publié sur le sujet LWT lorsqu'il sera hors ligne",
-        "LwtQos": "QoS (Quality of Service):",
+        "LwtQos": "QoS (Quality of Service)",
         "QOS0": "0 (Au maximum une fois)",
         "QOS1": "1 (Au moins une fois)",
         "QOS2": "2 (Exactement une fois)",
@@ -610,6 +620,7 @@
         "ProviderPylontechCan": "Pylontech using CAN bus",
         "ProviderSBSCan": "SBS Unipower using CAN bus",
         "ProviderJkBmsSerial": "Jikong (JK) BMS using serial connection",
+        "ProviderJbdBmsSerial": "Jiabaida (JBD) BMS using serial connection",
         "ProviderMqtt": "Battery data from MQTT broker",
         "ProviderVictron": "Victron SmartShunt using VE.Direct interface",
         "MqttSocConfiguration": "SoC Settings",
@@ -619,10 +630,11 @@
         "MqttVoltageUnit": "Unit",
         "MqttSocTopic": "SoC Value Topic",
         "MqttVoltageTopic": "Voltage Value Topic",
-        "JkBmsConfiguration": "JK BMS Settings",
-        "JkBmsInterface": "Interface Type",
-        "JkBmsInterfaceUart": "TTL-UART on MCU",
-        "JkBmsInterfaceTransceiver": "RS-485 Transceiver on MCU",
+        "SerialSettings": "Serial Settings",
+        "SerialInterfaceType": "Interface Type",
+        "SerialInterfaceTypeUart": "TTL-UART on MCU",
+        "SerialInterfaceTypeTransceiver": "RS-485 Transceiver on MCU",
+        "JbdBmsConfiguration": "JBD BMS Settings",
         "PollingInterval": "Polling Interval",
         "Seconds": "@:base.Seconds",
         "DischargeCurrentLimitConfiguration": "Discharge Current Limit Settings",
@@ -682,24 +694,30 @@
         "YieldDayCorrection": "Yield Day Correction",
         "YieldDayCorrectionHint": "Sum up daily yield even if the inverter is restarted. Value will be reset at midnight"
     },
-    "configadmin": {
+    "fileadmin": {
         "ConfigManagement": "Gestion de la configuration",
         "BackupHeader": "Sauvegarder le fichier de configuration",
-        "BackupConfig": "Fichier de configuration",
-        "Backup": "Sauvegarder",
         "Restore": "Restaurer",
         "NoFileSelected": "Aucun fichier sélectionné",
         "RestoreHeader": "Restaurer le fichier de configuration",
         "Back": "Retour",
         "UploadSuccess": "Succès du téléversement",
-        "RestoreHint": "<b>Note :</b> Cette opération remplace le fichier de configuration par la configuration restaurée et redémarre OpenDTU pour appliquer tous les paramètres.",
+        "RestoreHint": "<b>Note :</b> Cette opération remplace le fichier de configuration par la configuration restaurée et redémarre OpenDTU-OnBattery pour appliquer tous les paramètres.",
         "ResetHeader": "Effectuer une réinitialisation d'usine",
         "FactoryResetButton": "Restaurer les paramètres d'usine",
         "ResetHint": "<b>Note :</b> Cliquez sur \"Restaurer les paramètres d'usine\" pour restaurer et initialiser les paramètres d'usine par défaut et redémarrer.",
         "FactoryReset": "Remise à zéro",
         "ResetMsg": "Êtes-vous sûr de vouloir supprimer la configuration actuelle et réinitialiser tous les paramètres à leurs valeurs par défaut ?",
         "ResetConfirm": "Remise à zéro !",
-        "Cancel": "@:base.Cancel"
+        "Download": "Download",
+        "Delete": "Supprimer",
+        "DeleteMsg": "Are you sure you want to delete file: '{name}'? You have to manually reboot the device to apply config changes!",
+        "Name": "Name",
+        "Size": "Size",
+        "Action": "Action",
+        "Cancel": "@:base.Cancel",
+        "InvalidJson": "JSON file is formatted incorrectly.",
+        "InvalidJsonContent": "JSON file has the wrong content."
     },
     "powerlimiteradmin": {
         "PowerLimiterSettings": "Dynamic Power Limiter Settings",
@@ -710,11 +728,12 @@
         "ConfigHintsIntro": "The following notes regarding the Dynamic Power Limiter (DPL) configuration shall be considered:",
         "ConfigHintPowerMeterDisabled": "Without a power meter interface, the inverter limit the DPL will configure equals the configured base load (exception: (full) solar-passthrough).",
         "ConfigHintNoInverter": "At least one inverter must be configured prior to setting up the DPL.",
-        "ConfigHintInverterCommunication": "Polling data from and sending commands to the target inverter must be enabled.",
+        "ConfigHintInverterCommunication": "Polling data from and sending commands to all managed inverters must be enabled.",
         "ConfigHintNoChargeController": "The solar-passthrough feature can only be used if the VE.Direct interface is configured.",
         "ConfigHintNoBatteryInterface": "SoC-based thresholds can only be used if a battery communication interface is configured.",
         "General": "General",
         "Enable": "Enable",
+        "GovernInverter": "Govern Inverter \"{name}\"",
         "VerboseLogging": "@:base.VerboseLogging",
         "SolarPassthrough": "Solar-Passthrough",
         "EnableSolarPassthrough": "Enable Solar-Passthrough",
@@ -723,8 +742,8 @@
         "BatteryDischargeAtNight": "Use battery at night even if only partially charged",
         "SolarpassthroughInfo": "This feature allows to use the available current solar power directly. The solar power, as reported by the MPPT charge controller, is set as the inverter's limit, even if the battery is currently charging. This avoids storing energy unnecessarily, which would be lossy.",
         "InverterSettings": "Inverter",
-        "Inverter": "Target Inverter",
         "SelectInverter": "Select an inverter...",
+        "InverterForDcVoltage": "Inverter used for voltage measurements",
         "InverterChannelId": "Input used for voltage measurements",
         "TargetPowerConsumption": "Target Grid Consumption",
         "TargetPowerConsumptionHint": "Grid power consumption the limiter tries to achieve. Value may be negative.",
@@ -734,22 +753,44 @@
         "LowerPowerLimitHint": "This value must be selected so that stable operation is possible at this limit. If the inverter could only be operated with a lower limit, it is put into standby instead.",
         "BaseLoadLimit": "Base Load",
         "BaseLoadLimitHint": "Relevant for operation without power meter or when the power meter fails. As long as the other conditions allow (in particular battery charge), this limit is set on the inverter.",
+        "TotalUpperPowerLimit": "Maximum Total Output",
+        "TotalUpperPowerLimitHint": "The inverters are configured to output this maximum amount of power in total.",
+        "ManagedInverters": "Managed Inverters",
+        "AddInverter": "Add Inverter",
+        "NoManagedInverters": "The Dynamic Power Limiter is currently not managing any inverters. To continue, select an inverter in the dropdown list above and add it.",
+        "InverterLabel": "Name (Type)",
+        "PowerSource": "Power Source",
+        "PowerSourceBattery": "Battery",
+        "PowerSourceSolarPanels": "Solar Panel(s)",
+        "EditInverter": "Edit Inverter",
+        "EditInverterLabel": "Concerns Inverter",
+        "Apply": "Apply",
+        "Cancel": "@:base.Cancel",
+        "Delete": "Delete",
+        "DeleteInverter": "Confirm Removal",
+        "DeleteInverterMsg": "Should inverter {label} with serial number {serial} be removed from the list of inverters managed by the Dynamic Power Limiter?",
         "UpperPowerLimit": "Maximum Power Limit",
         "UpperPowerLimitHint": "The inverter is always set such that no more than this output power is achieved. This value must be selected to comply with the current carrying capacity of the AC connection cables.",
         "SocThresholds": "Battery State of Charge (SoC) Thresholds",
-        "IgnoreSoc": "Ignore Battery SoC",
+        "IgnoreSoc": "Use Voltage Threshols Only",
+        "IgnoreSocHint": "When enabled, only voltage thresholds are considered. Disable this switch to configure and use battery State of Charge (SoC) thresholds (not recommended as the SoC value is often inaccurate).",
         "StartThreshold": "Start Threshold for Battery Discharging",
         "StopThreshold": "Stop Threshold for Battery Discharging",
         "FullSolarPassthroughStartThreshold": "Full Solar-Passthrough Start Threshold",
         "FullSolarPassthroughStartThresholdHint": "Inverter power is set equal to Victron MPPT power (minus efficiency factors) while above this threshold. Use this if you want to supply excess power to the grid when the battery is full.",
         "VoltageSolarPassthroughStopThreshold": "Full Solar-Passthrough Stop Threshold",
         "VoltageLoadCorrectionFactor": "Load correction factor",
-        "BatterySocInfo": "<b>Hint:</b> The battery SoC (State of Charge) values are only used if the battery communication interface reported SoC updates in the last minute. Otherwise the voltage thresholds will be used as fallback.",
+        "BatterySocInfo": "<b>Hint:</b> The use of battery State of Charge (SoC) thresholds is prioritized. However, SoC thresholds are only used if the battery communication interface has processed valid SoC values in the last minute. Otherwise, the voltage thresholds will be used as fallback.",
         "InverterIsBehindPowerMeter": "PowerMeter reading includes inverter output",
         "InverterIsBehindPowerMeterHint": "Enable this option if the power meter reading is reduced by the inverter's output when it produces power. This is typically true.",
         "InverterIsSolarPowered": "Inverter is powered by solar modules",
+        "UseOverscalingToCompensateShading": "Compensate for shading",
+        "UseOverscalingToCompensateShadingHint": "Allow to overscale the inverter limit to compensate for shading of one or multiple inputs.",
         "VoltageThresholds": "Battery Voltage Thresholds",
-        "VoltageLoadCorrectionInfo": "<b>Hint:</b> When the battery is discharged, its voltage drops. The voltage drop scales with the discharge current. In order to not stop the inverter too early (stop threshold), this load correction factor can be specified to calculate the battery voltage if it was idle. Corrected voltage = DC Voltage + (Current power * correction factor)."
+        "VoltageLoadCorrectionInfo": "<b>Hint:</b> When the battery is discharged, its voltage drops. The voltage drop scales with the discharge current. In order to not stop the inverter too early (stop threshold), this load correction factor can be specified to calculate the battery voltage if it was idle. Corrected voltage = DC Voltage + (Current power * correction factor).",
+        "InverterRestartHour": "Automatic Restart Time",
+        "InverterRestartDisabled": "Do not execute automatic restart",
+        "InverterRestartHint": "The daily yield of the inverter is usually reset at night when the inverter turns off due to lack of light. To reset the daily yield even though the inverter is continuously powered by the battery, the inverter can be automatically restarted daily at the desired time."
     },
     "login": {
         "Login": "Connexion",
@@ -780,7 +821,7 @@
         "ProjectOriginBody1": "Ce projet a été démarré suite à cette discussion <a href=\"https://www.mikrocontroller.net/topic/525778\" target=\"_blank\">(Mikrocontroller.net)</a>.",
         "ProjectOriginBody2": "Le protocole Hoymiles a été décrypté grâce aux efforts volontaires de nombreux participants. OpenDTU, entre autres, a été développé sur la base de ce travail. Le projet est sous licence Open Source (<a href=\"https://www.gnu.de/documents/gpl-2.0.de.html\" target=\"_blank\">GNU General Public License version 2</a>).",
         "ProjectOriginBody3": "Le logiciel a été développé au mieux de nos connaissances et de nos convictions. Néanmoins, aucune responsabilité ne peut être acceptée en cas de dysfonctionnement ou de perte de garantie de l'onduleur.",
-        "ProjectOriginBody4": "OpenDTU est disponible gratuitement. Si vous avez payé pour le logiciel, vous avez probablement été arnaqué.",
+        "ProjectOriginBody4": "OpenDTU et OpenDTU-OnBattery sont disponible gratuitement. Si vous avez payé pour le logiciel, vous avez probablement été arnaqué.",
         "NewsUpdates": "Actualités et mises à jour",
         "NewsUpdatesBody": "Les nouvelles mises à jour peuvent être trouvées sur <a href=\"https://github.com/hoylabs/OpenDTU-OnBattery/releases\" target=\"_blank\">Github</a>.",
         "ErrorReporting": "Rapport d'erreurs",
@@ -807,15 +848,15 @@
         "PowerSafeHint": "Eteindre l'écran si aucun onduleur n'est en production.",
         "Screensaver": "OLED Anti burn-in",
         "ScreensaverHint": "Déplacez un peu l'écran à chaque mise à jour pour éviter le phénomène de brûlure. (Utile surtout pour les écrans OLED)",
-        "DiagramMode": "Diagram mode:",
+        "DiagramMode": "Diagram mode",
         "off": "Off",
         "small": "Small",
         "fullscreen": "Fullscreen",
-        "DiagramDuration": "Diagram duration:",
+        "DiagramDuration": "Diagram duration",
         "DiagramDurationHint": "The time period which is shown in the diagram.",
         "Seconds": "Seconds",
-        "Contrast": "Contraste ({contrast}):",
-        "Rotation": "Rotation:",
+        "Contrast": "Contraste ({contrast})",
+        "Rotation": "Rotation",
         "rot0": "Pas de rotation",
         "rot90": "Rotation de 90 degrés",
         "rot180": "Rotation de 180 degrés",
@@ -825,11 +866,10 @@
         "de": "Allemand",
         "fr": "Français",
         "Leds": "LEDs",
-        "EqualBrightness": "Même luminosité:",
-        "LedBrightness": "LED {led} luminosité ({brightness}):"
+        "EqualBrightness": "Même luminosité",
+        "LedBrightness": "LED {led} luminosité ({brightness})"
     },
     "pininfo": {
-        "PinOverview": "Vue d'ensemble des connexions",
         "Category": "Catégorie",
         "Name": "Nom",
         "ValueSelected": "Sélectionné",
@@ -866,9 +906,9 @@
         "SetOnline": "Set limit, CAN bus connected",
         "LimitHint": "<b>Hint:</b> CAN bus not connected voltage limit is 48V-58.5V.",
         "Close": "close",
-        "SetVoltageLimit": "Voltage limit:",
-        "SetCurrentLimit": "Current limit:",
-        "CurrentLimit": "Current limit:"
+        "SetVoltageLimit": "Voltage limit",
+        "SetCurrentLimit": "Current limit",
+        "CurrentLimit": "Current limit"
     },
     "acchargeradmin": {
         "ChargerSettings": "AC Charger Settings",
@@ -890,7 +930,8 @@
         "StopBatterySoCThreshold": "Stop charging at SoC",
         "StopBatterySoCThresholdHint": "To prolong the battery's lifespan, charging can be stopped at a certain SoC level.\nHint: In order to keep the SoC reading accurate, some LiFePO cells must be charged to full capacity regularly.",
         "Seconds": "@:base.Seconds",
-        "EnableEmergencyCharge": "Emergency charge. Battery charged with maximum power if requested by Battery BMS",
+        "EnableEmergencyCharge": "Emergency charge",
+        "EnableEmergencyChargeHint": "Battery charged with maximum power if requested by Battery BMS",
         "targetPowerConsumption": "Target power consumption",
         "targetPowerConsumptionHint": "Postitive values use grid power to charge the battery. Negative values result in early shutdown"
     },
@@ -933,28 +974,56 @@
         "issueType": "Type",
         "alarm": "Alarm",
         "warning": "Warning",
+        "CommonIssueCellOverVoltage": "Overvoltage (single cell)",
+        "CommonIssueCellUnderVoltage": "Undervoltage (single cell)",
+        "CommonIssuePackOverVoltage": "Overvoltage (sum of all cells)",
+        "CommonIssuePackUnderVoltage": "Undervoltage (sum of all cells)",
+        "CommonIssueChargingOverCurrent": "Overcurrent (Charging)",
+        "CommonIssueDischargeOverCurrent": "Overcurrent (Discharging)",
+        "CommonIssueChargingOverTemperature": "Overtemperature (Charging)",
+        "CommonIssueChargingLowTemperature": "Undertemperature (Charging)",
         "JkBmsIssueLowCapacity": "Low Capacity",
         "JkBmsIssueBmsOvertemperature": "BMS overtemperature",
-        "JkBmsIssueChargingOvervoltage": "Overvoltage (sum of all cells)",
-        "JkBmsIssueDischargeUndervoltage": "Undervoltage (sum of all cells)",
+        "JkBmsIssueChargingOvervoltage": "@:battery.CommonIssuePackOverVoltage",
+        "JkBmsIssueDischargeUndervoltage": "@:battery.CommonIssuePackUnderVoltage",
         "JkBmsIssueBatteryOvertemperature": "Battery overtemperature",
-        "JkBmsIssueChargingOvercurrent": "Overcurrent (Charging)",
-        "JkBmsIssueDischargeOvercurrent": "Overcurrent (Discharging)",
+        "JkBmsIssueChargingOvercurrent": "@:battery.CommonIssueChargingOverCurrent",
+        "JkBmsIssueDischargeOvercurrent": "@:battery.CommonIssueDischargeOverCurrent",
         "JkBmsIssueCellVoltageDifference": "Cell voltage difference too high",
         "JkBmsIssueBatteryBoxOvertemperature": "Battery (box?) overtemperature",
         "JkBmsIssueBatteryUndertemperature": "Battery undertemperature",
-        "JkBmsIssueCellOvervoltage": "Overvoltage (single cell)",
-        "JkBmsIssueCellUndervoltage": "Undervoltage (single cell)",
+        "JkBmsIssueCellOvervoltage": "@:battery.CommonIssueCellOverVoltage",
+        "JkBmsIssueCellUndervoltage": "@:battery.CommonIssueCellUnderVoltage",
         "JkBmsIssueAProtect": "AProtect (meaning?)",
         "JkBmsIssueBProtect": "BProtect (meaning?)",
+        "JbdBmsIssueCellOverVoltage": "@:battery.CommonIssueCellOverVoltage",
+        "JbdBmsIssueCellUnderVoltage": "@:battery.CommonIssueCellUnderVoltage",
+        "JbdBmsIssuePackOverVoltage": "@:battery.CommonIssuePackOverVoltage",
+        "JbdBmsIssuePackUnderVoltage": "@:battery.CommonIssuePackUnderVoltage",
+        "JbdBmsIssueChargingOverTemperature": "@:battery.CommonIssueChargingOverTemperature",
+        "JbdBmsIssueChargingLowTemperature": "@:battery.CommonIssueChargingLowTemperature",
+        "JbdBmsIssueDischargingOverTemperature": "Overtemperature (Discharging)",
+        "JbdBmsIssueDischargingLowTemperature": "Undertemperature (Discharging)",
+        "JbdBmsIssueChargingOverCurrent": "@:battery.CommonIssueChargingOverCurrent",
+        "JbdBmsIssueDischargeOverCurrent": "@:battery.CommonIssueDischargeOverCurrent",
+        "JbdBmsIssueShortCircuit": "Short Circuit",
+        "JbdBmsIssueIcFrontEndError": "IC Frontend Error",
+        "JbdBmsIssueMosSotwareLock": "Charging/Discharging Prevented",
+        "JbdBmsIssueReserved1": "Reserved 1",
+        "JbdBmsIssueReserved2": "Reserved 2",
+        "JbdBmsIssueReserved3": "Reserved 3",
         "highCurrentDischarge": "High current (discharge)",
-        "overCurrentDischarge": "Overcurrent (discharge)",
+        "overCurrentDischarge": "@:battery.CommonIssueDischargeOverCurrent",
         "highCurrentCharge": "High current (charge)",
-        "overCurrentCharge": "Overcurrent (charge)",
+        "overCurrentCharge": "@:battery.CommonIssueChargingOverCurrent",
         "lowTemperature": "Low temperature",
         "underTemperature": "Undertemperature",
+        "lowTemperatureCharge": "Low temperature (charge)",
+        "underTemperatureCharge": "@:battery.CommonIssueChargingLowTemperature",
         "highTemperature": "High temperature",
         "overTemperature": "Overtemperature",
+        "highTemperatureCharge": "High temperature (charge)",
+        "overTemperatureCharge": "@:battery.CommonIssueChargingOverTemperature",
         "lowVoltage": "Low voltage",
         "lowSOC": "Low state of charge",
         "underVoltage": "Undervoltage",
diff --git a/webapp/src/locales/index.ts b/webapp/src/locales/index.ts
deleted file mode 100644
index 596a4199..00000000
--- a/webapp/src/locales/index.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import type { I18nOptions } from 'vue-i18n';
-
-export enum Locales {
-    EN = 'en',
-    DE = 'de',
-    FR = 'fr',
-}
-
-export const LOCALES = [
-    { value: Locales.EN, caption: 'English' },
-    { value: Locales.DE, caption: 'Deutsch' },
-    { value: Locales.FR, caption: 'Français' },
-];
-
-export const dateTimeFormats: I18nOptions['datetimeFormats'] = {};
-export const numberFormats: I18nOptions['numberFormats'] = {};
-
-LOCALES.forEach((locale) => {
-    dateTimeFormats[locale.value] = {
-        datetime: {
-            hour: 'numeric',
-            minute: 'numeric',
-            second: 'numeric',
-            year: 'numeric',
-            month: 'numeric',
-            day: 'numeric',
-            hour12: false,
-        },
-    };
-
-    numberFormats[locale.value] = {
-        decimal: {
-            style: 'decimal',
-        },
-        decimalNoDigits: {
-            style: 'decimal',
-            minimumFractionDigits: 0,
-            maximumFractionDigits: 0,
-        },
-        decimalOneDigit: {
-            style: 'decimal',
-            minimumFractionDigits: 1,
-            maximumFractionDigits: 1,
-        },
-        decimalTwoDigits: {
-            style: 'decimal',
-            minimumFractionDigits: 2,
-            maximumFractionDigits: 2,
-        },
-        percent: {
-            style: 'percent',
-        },
-        percentOneDigit: {
-            style: 'percent',
-            minimumFractionDigits: 1,
-            maximumFractionDigits: 1,
-        },
-        byte: {
-            style: 'unit',
-            unit: 'byte',
-        },
-        kilobyte: {
-            style: 'unit',
-            unit: 'kilobyte',
-        },
-        megabyte: {
-            style: 'unit',
-            unit: 'megabyte',
-        },
-        celsius: {
-            style: 'unit',
-            unit: 'celsius',
-            maximumFractionDigits: 1,
-        },
-    };
-});
-
-export const defaultLocale = Locales.EN;
diff --git a/webapp/src/main.ts b/webapp/src/main.ts
index 129da4c8..ef2243ec 100644
--- a/webapp/src/main.ts
+++ b/webapp/src/main.ts
@@ -1,11 +1,9 @@
-import messages from '@intlify/unplugin-vue-i18n/messages';
 import mitt from 'mitt';
 import { createApp } from 'vue';
-import { createI18n } from 'vue-i18n';
 import App from './App.vue';
-import { dateTimeFormats, defaultLocale, numberFormats } from './locales';
 import { tooltip } from './plugins/bootstrap';
 import router from './router';
+import { i18n } from './i18n';
 
 import 'bootstrap';
 import './scss/styles.scss';
@@ -17,16 +15,6 @@ app.config.globalProperties.$emitter = emitter;
 
 app.directive('tooltip', tooltip);
 
-const i18n = createI18n({
-    legacy: false,
-    globalInjection: true,
-    locale: navigator.language.split('-')[0],
-    fallbackLocale: defaultLocale,
-    messages,
-    datetimeFormats: dateTimeFormats,
-    numberFormats: numberFormats,
-});
-
 app.use(router);
 app.use(i18n);
 
diff --git a/webapp/src/router/index.ts b/webapp/src/router/index.ts
index c96ca25f..52d29de3 100644
--- a/webapp/src/router/index.ts
+++ b/webapp/src/router/index.ts
@@ -23,11 +23,19 @@ import NtpAdminView from '@/views/NtpAdminView.vue';
 import NtpInfoView from '@/views/NtpInfoView.vue';
 import SecurityAdminView from '@/views/SecurityAdminView.vue';
 import SystemInfoView from '@/views/SystemInfoView.vue';
+import WaitRestartView from '@/views/WaitRestartView.vue';
 import { createRouter, createWebHistory } from 'vue-router';
 
 const router = createRouter({
     history: createWebHistory(import.meta.env.BASE_URL),
     linkActiveClass: 'active',
+    scrollBehavior() {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({ top: 0 });
+            }, 100);
+        });
+    },
     routes: [
         {
             path: '/',
@@ -154,6 +162,11 @@ const router = createRouter({
             name: 'Device Reboot',
             component: MaintenanceRebootView,
         },
+        {
+            path: '/wait',
+            name: 'Wait Restart',
+            component: WaitRestartView,
+        },
     ],
 });
 
diff --git a/webapp/src/scss/styles.scss b/webapp/src/scss/styles.scss
index f97d3389..d654b41a 100644
--- a/webapp/src/scss/styles.scss
+++ b/webapp/src/scss/styles.scss
@@ -4,3 +4,63 @@
 .container-fluid .row {
     font-feature-settings: 'tnum';
 }
+
+@include media-breakpoint-up(sm) {
+    label.col-form-label,
+    label.form-check-label {
+        text-align: end;
+    }
+}
+
+table.table tr:last-child th,
+table.table tr:last-child td {
+    border-bottom: 0;
+}
+
+table.table {
+    margin-bottom: 0;
+}
+
+div.card.card-table {
+    // prevent tables in cards from
+    // messing up the bottom corner radii
+    overflow: hidden;
+}
+
+div.card.card-table tr > :first-child {
+    padding-left: var(--bs-card-cap-padding-x);
+}
+
+div.card.card-table tr > :last-child {
+    padding-right: var(--bs-card-cap-padding-x);
+}
+
+div.accordion-item.accordion-table tr > :first-child {
+    padding-left: var(--bs-accordion-btn-padding-x);
+}
+
+div.accordion-item.accordion-table div.accordion-body {
+    padding-top: 0;
+    padding-left: 0;
+    padding-right: 0;
+}
+
+div.card.card-table div.card-body {
+    padding: 0;
+}
+
+div.card div.card-body > :last-child {
+    margin-bottom: auto !important;
+}
+
+div.card.card-table table .value {
+    text-align: right;
+    padding-right: 0;
+}
+
+// blend cards into tabbed navigation (device admin view)
+div.card-tabbed {
+    border-top: 0;
+    border-top-left-radius: 0;
+    border-top-right-radius: 0;
+}
diff --git a/webapp/src/types/AlertResponse.ts b/webapp/src/types/AlertResponse.ts
new file mode 100644
index 00000000..f32f133e
--- /dev/null
+++ b/webapp/src/types/AlertResponse.ts
@@ -0,0 +1,6 @@
+export interface AlertResponse {
+    message: string;
+    type: string;
+    code: number;
+    show: boolean;
+}
diff --git a/webapp/src/types/BatteryConfig.ts b/webapp/src/types/BatteryConfig.ts
index a781b74a..67792a71 100644
--- a/webapp/src/types/BatteryConfig.ts
+++ b/webapp/src/types/BatteryConfig.ts
@@ -11,6 +11,8 @@ export interface BatteryConfig {
     mqtt_voltage_unit: number;
     enable_discharge_current_limit: boolean;
     discharge_current_limit: number;
+    discharge_current_limit_below_soc: number;
+    discharge_current_limit_below_voltage: number;
     use_battery_reported_discharge_current_limit: boolean;
     mqtt_discharge_current_topic: string;
     mqtt_discharge_current_json_path: string;
diff --git a/webapp/src/types/Config.ts b/webapp/src/types/Config.ts
deleted file mode 100644
index a86512c5..00000000
--- a/webapp/src/types/Config.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export interface ConfigFileInfo {
-    name: string;
-}
-
-export interface ConfigFileList {
-    configs: Array<ConfigFileInfo>;
-}
diff --git a/webapp/src/types/DeviceConfig.ts b/webapp/src/types/DeviceConfig.ts
index e47fca71..eec9e0ba 100644
--- a/webapp/src/types/DeviceConfig.ts
+++ b/webapp/src/types/DeviceConfig.ts
@@ -5,7 +5,7 @@ export interface Display {
     power_safe: boolean;
     screensaver: boolean;
     contrast: number;
-    language: number;
+    locale: string;
     diagramduration: number;
     diagrammode: number;
 }
diff --git a/webapp/src/types/File.ts b/webapp/src/types/File.ts
new file mode 100644
index 00000000..0850bd9d
--- /dev/null
+++ b/webapp/src/types/File.ts
@@ -0,0 +1,4 @@
+export interface FileInfo {
+    name: string;
+    size: number;
+}
diff --git a/webapp/src/types/PowerLimiterConfig.ts b/webapp/src/types/PowerLimiterConfig.ts
index f8220a7d..67f50ef3 100644
--- a/webapp/src/types/PowerLimiterConfig.ts
+++ b/webapp/src/types/PowerLimiterConfig.ts
@@ -1,10 +1,13 @@
 export interface PowerLimiterInverterInfo {
+    serial: string;
     pos: number;
+    order: number;
     name: string;
     poll_enable: boolean;
     poll_enable_night: boolean;
     command_enable: boolean;
     command_enable_night: boolean;
+    max_power: number;
     type: string;
     channels: number;
 }
@@ -15,7 +18,17 @@ export interface PowerLimiterMetaData {
     power_meter_enabled: boolean;
     battery_enabled: boolean;
     charge_controller_enabled: boolean;
-    inverters: { [key: string]: PowerLimiterInverterInfo };
+    inverters: PowerLimiterInverterInfo[];
+}
+
+export interface PowerLimiterInverterConfig {
+    serial: string;
+    is_governed: boolean;
+    is_behind_power_meter: boolean;
+    is_solar_powered: boolean;
+    use_overscaling_to_compensate_shading: boolean;
+    lower_power_limit: number;
+    upper_power_limit: number;
 }
 
 export interface PowerLimiterConfig {
@@ -24,16 +37,9 @@ export interface PowerLimiterConfig {
     solar_passthrough_enabled: boolean;
     solar_passthrough_losses: number;
     battery_always_use_at_night: boolean;
-    is_inverter_behind_powermeter: boolean;
-    is_inverter_solar_powered: boolean;
-    use_overscaling_to_compensate_shading: boolean;
-    inverter_serial: string;
-    inverter_channel_id: number;
     target_power_consumption: number;
     target_power_consumption_hysteresis: number;
-    lower_power_limit: number;
     base_load_limit: number;
-    upper_power_limit: number;
     ignore_soc: boolean;
     battery_soc_start_threshold: number;
     battery_soc_stop_threshold: number;
@@ -44,4 +50,9 @@ export interface PowerLimiterConfig {
     full_solar_passthrough_soc: number;
     full_solar_passthrough_start_voltage: number;
     full_solar_passthrough_stop_voltage: number;
+    inverter_serial_for_dc_voltage: string;
+    inverter_channel_id_for_dc_voltage: number;
+    restart_hour: number;
+    total_upper_power_limit: number;
+    inverters: PowerLimiterInverterConfig[];
 }
diff --git a/webapp/src/utils/structure.ts b/webapp/src/utils/structure.ts
new file mode 100644
index 00000000..d7e29142
--- /dev/null
+++ b/webapp/src/utils/structure.ts
@@ -0,0 +1,25 @@
+export type Schema = {
+    [key: string]: 'string' | 'number' | 'boolean' | 'object' | 'array' | Schema;
+};
+
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+export function hasStructure(obj: any, schema: Schema): boolean {
+    if (typeof obj !== 'object' || obj === null) return false;
+
+    for (const key in schema) {
+        const expectedType = schema[key];
+
+        if (['string', 'number', 'boolean'].includes(expectedType as string)) {
+            if (typeof obj[key] !== expectedType) return false;
+        } else if (expectedType === 'object') {
+            if (typeof obj[key] !== 'object' || obj[key] === null) return false;
+        } else if (expectedType === 'array') {
+            if (!Array.isArray(obj[key])) return false;
+        } else if (typeof expectedType === 'object') {
+            // Recursively check nested objects
+            if (!hasStructure(obj[key], expectedType as Schema)) return false;
+        }
+    }
+
+    return true;
+}
diff --git a/webapp/src/utils/waitRestart.ts b/webapp/src/utils/waitRestart.ts
new file mode 100644
index 00000000..5ff44b52
--- /dev/null
+++ b/webapp/src/utils/waitRestart.ts
@@ -0,0 +1,7 @@
+import type { Router } from 'vue-router';
+
+export function waitRestart(router: Router) {
+    setTimeout(() => {
+        router.push('/wait');
+    }, 1000);
+}
diff --git a/webapp/src/views/AcChargerAdminView.vue b/webapp/src/views/AcChargerAdminView.vue
index d8ae820e..44193bcf 100644
--- a/webapp/src/views/AcChargerAdminView.vue
+++ b/webapp/src/views/AcChargerAdminView.vue
@@ -13,195 +13,140 @@
                     wide
                 />
 
-                <div class="row mb-3" v-show="acChargerConfigList.enabled">
-                    <label class="col-sm-4 col-form-label">
-                        {{ $t('acchargeradmin.CanControllerFrequency') }}
-                    </label>
-                    <div class="col-sm-8">
-                        <select class="form-select" v-model="acChargerConfigList.can_controller_frequency">
-                            <option
-                                v-for="frequency in frequencyTypeList"
-                                :key="frequency.key"
-                                :value="frequency.value"
-                            >
-                                {{ frequency.key }} MHz
-                            </option>
-                        </select>
-                    </div>
-                </div>
-
-                <InputElement
-                    v-show="acChargerConfigList.enabled"
-                    :label="$t('acchargeradmin.VerboseLogging')"
-                    v-model="acChargerConfigList.verbose_logging"
-                    type="checkbox"
-                    wide
-                />
-
-                <InputElement
-                    v-show="acChargerConfigList.enabled"
-                    :label="$t('acchargeradmin.EnableAutoPower')"
-                    v-model="acChargerConfigList.auto_power_enabled"
-                    type="checkbox"
-                    wide
-                />
-
-                <InputElement
-                    v-show="acChargerConfigList.enabled && acChargerConfigList.auto_power_enabled"
-                    :label="$t('acchargeradmin.EnableBatterySoCLimits')"
-                    v-model="acChargerConfigList.auto_power_batterysoc_limits_enabled"
-                    type="checkbox"
-                    wide
-                />
-
-                <InputElement
-                    v-show="acChargerConfigList.enabled"
-                    :label="$t('acchargeradmin.EnableEmergencyCharge')"
-                    v-model="acChargerConfigList.emergency_charge_enabled"
-                    type="checkbox"
-                    wide
-                />
-
-                <CardElement
-                    :text="$t('acchargeradmin.Limits')"
-                    textVariant="text-bg-primary"
-                    add-space
-                    v-show="acChargerConfigList.auto_power_enabled || acChargerConfigList.emergency_charge_enabled"
-                >
+                <template v-if="acChargerConfigList.enabled">
                     <div class="row mb-3">
-                        <label for="voltageLimit" class="col-sm-2 col-form-label"
-                            >{{ $t('acchargeradmin.VoltageLimit') }}:
-                            <BIconInfoCircle v-tooltip :title="$t('acchargeradmin.stopVoltageLimitHint')" />
+                        <label class="col-sm-4 col-form-label">
+                            {{ $t('acchargeradmin.CanControllerFrequency') }}
                         </label>
-                        <div class="col-sm-10">
-                            <div class="input-group">
-                                <input
-                                    type="number"
-                                    step="0.01"
-                                    class="form-control"
-                                    id="voltageLimit"
-                                    placeholder="42"
-                                    v-model="acChargerConfigList.voltage_limit"
-                                    aria-describedby="voltageLimitDescription"
-                                    min="42"
-                                    max="58.5"
-                                    required
-                                />
-                                <span class="input-group-text" id="voltageLimitDescription">V</span>
-                            </div>
-                        </div>
-                        <label for="enableVoltageLimit" class="col-sm-2 col-form-label"
-                            >{{ $t('acchargeradmin.enableVoltageLimit') }}:
-                            <BIconInfoCircle v-tooltip :title="$t('acchargeradmin.enableVoltageLimitHint')" />
-                        </label>
-                        <div class="col-sm-10">
-                            <div class="input-group">
-                                <input
-                                    type="number"
-                                    step="0.01"
-                                    class="form-control"
-                                    id="enableVoltageLimit"
-                                    placeholder="42"
-                                    v-model="acChargerConfigList.enable_voltage_limit"
-                                    aria-describedby="enableVoltageLimitDescription"
-                                    min="42"
-                                    max="58.5"
-                                    required
-                                />
-                                <span class="input-group-text" id="enableVoltageLimitDescription">V</span>
-                            </div>
-                        </div>
-                        <label for="lowerPowerLimit" class="col-sm-2 col-form-label"
-                            >{{ $t('acchargeradmin.lowerPowerLimit') }}:</label
-                        >
-                        <div class="col-sm-10">
-                            <div class="input-group">
-                                <input
-                                    type="number"
-                                    class="form-control"
-                                    id="lowerPowerLimit"
-                                    placeholder="150"
-                                    v-model="acChargerConfigList.lower_power_limit"
-                                    aria-describedby="lowerPowerLimitDescription"
-                                    min="50"
-                                    max="3000"
-                                    required
-                                />
-                                <span class="input-group-text" id="lowerPowerLimitDescription">W</span>
-                            </div>
-                        </div>
-                        <label for="upperPowerLimit" class="col-sm-2 col-form-label"
-                            >{{ $t('acchargeradmin.upperPowerLimit') }}:
-                            <BIconInfoCircle v-tooltip :title="$t('acchargeradmin.upperPowerLimitHint')" />
-                        </label>
-                        <div class="col-sm-10">
-                            <div class="input-group">
-                                <input
-                                    type="number"
-                                    class="form-control"
-                                    id="upperPowerLimit"
-                                    placeholder="2000"
-                                    v-model="acChargerConfigList.upper_power_limit"
-                                    aria-describedby="upperPowerLimitDescription"
-                                    min="100"
-                                    max="3000"
-                                    required
-                                />
-                                <span class="input-group-text" id="upperPowerLimitDescription">W</span>
-                            </div>
-                        </div>
-                        <label for="targetPowerConsumption" class="col-sm-2 col-form-label"
-                            >{{ $t('acchargeradmin.targetPowerConsumption') }}:
-                            <BIconInfoCircle v-tooltip :title="$t('acchargeradmin.targetPowerConsumptionHint')" />
-                        </label>
-                        <div class="col-sm-10">
-                            <div class="input-group">
-                                <input
-                                    type="number"
-                                    class="form-control"
-                                    id="targetPowerConsumption"
-                                    placeholder="0"
-                                    v-model="acChargerConfigList.target_power_consumption"
-                                    aria-describedby="targetPowerConsumptionDescription"
-                                    required
-                                />
-                                <span class="input-group-text" id="targetPowerConsumptionDescription">W</span>
-                            </div>
+                        <div class="col-sm-8">
+                            <select class="form-select" v-model="acChargerConfigList.can_controller_frequency">
+                                <option
+                                    v-for="frequency in frequencyTypeList"
+                                    :key="frequency.key"
+                                    :value="frequency.value"
+                                >
+                                    {{ frequency.key }} MHz
+                                </option>
+                            </select>
                         </div>
                     </div>
-                </CardElement>
-                <CardElement
-                    :text="$t('acchargeradmin.BatterySoCLimits')"
-                    textVariant="text-bg-primary"
-                    add-space
-                    v-show="
-                        acChargerConfigList.auto_power_enabled &&
-                        acChargerConfigList.auto_power_batterysoc_limits_enabled
-                    "
-                >
-                    <div class="row mb-3">
-                        <label for="stopBatterySoCThreshold" class="col-sm-2 col-form-label"
-                            >{{ $t('acchargeradmin.StopBatterySoCThreshold') }}:
-                            <BIconInfoCircle v-tooltip :title="$t('acchargeradmin.StopBatterySoCThresholdHint')" />
-                        </label>
-                        <div class="col-sm-10">
-                            <div class="input-group">
-                                <input
-                                    type="number"
-                                    class="form-control"
-                                    id="stopBatterySoCThreshold"
-                                    placeholder="95"
-                                    v-model="acChargerConfigList.stop_batterysoc_threshold"
-                                    aria-describedby="stopBatterySoCThresholdDescription"
-                                    min="2"
-                                    max="99"
-                                    required
-                                />
-                                <span class="input-group-text" id="stopBatterySoCThresholdDescription">%</span>
-                            </div>
-                        </div>
-                    </div>
-                </CardElement>
+
+                    <InputElement
+                        :label="$t('acchargeradmin.VerboseLogging')"
+                        v-model="acChargerConfigList.verbose_logging"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <InputElement
+                        :label="$t('acchargeradmin.EnableAutoPower')"
+                        v-model="acChargerConfigList.auto_power_enabled"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <InputElement
+                        v-if="acChargerConfigList.auto_power_enabled"
+                        :label="$t('acchargeradmin.EnableBatterySoCLimits')"
+                        v-model="acChargerConfigList.auto_power_batterysoc_limits_enabled"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <InputElement
+                        :label="$t('acchargeradmin.EnableEmergencyCharge')"
+                        :tooltip="$t('acchargeradmin.EnableEmergencyChargeHint')"
+                        v-model="acChargerConfigList.emergency_charge_enabled"
+                        type="checkbox"
+                        wide
+                    />
+                </template>
+            </CardElement>
+
+            <CardElement
+                :text="$t('acchargeradmin.Limits')"
+                textVariant="text-bg-primary"
+                add-space
+                v-if="acChargerConfigList.auto_power_enabled || acChargerConfigList.emergency_charge_enabled"
+            >
+                <InputElement
+                    :label="$t('acchargeradmin.VoltageLimit')"
+                    :tooltip="$t('acchargeradmin.stopVoltageLimitHint')"
+                    v-model="acChargerConfigList.voltage_limit"
+                    postfix="V"
+                    type="number"
+                    wide
+                    required
+                    step="0.01"
+                    min="42"
+                    max="58.5"
+                />
+
+                <InputElement
+                    :label="$t('acchargeradmin.enableVoltageLimit')"
+                    :tooltip="$t('acchargeradmin.enableVoltageLimitHint')"
+                    v-model="acChargerConfigList.enable_voltage_limit"
+                    postfix="V"
+                    type="number"
+                    wide
+                    required
+                    step="0.01"
+                    min="42"
+                    max="58.5"
+                />
+
+                <InputElement
+                    :label="$t('acchargeradmin.lowerPowerLimit')"
+                    v-model="acChargerConfigList.lower_power_limit"
+                    postfix="W"
+                    type="number"
+                    wide
+                    required
+                    min="50"
+                    max="3000"
+                />
+
+                <InputElement
+                    :label="$t('acchargeradmin.upperPowerLimit')"
+                    :tooltip="$t('acchargeradmin.upperPowerLimitHint')"
+                    v-model="acChargerConfigList.upper_power_limit"
+                    postfix="W"
+                    type="number"
+                    wide
+                    required
+                    min="100"
+                    max="3000"
+                />
+
+                <InputElement
+                    :label="$t('acchargeradmin.targetPowerConsumption')"
+                    :tooltip="$t('acchargeradmin.targetPowerConsumptionHint')"
+                    v-model="acChargerConfigList.target_power_consumption"
+                    postfix="W"
+                    type="number"
+                    wide
+                    required
+                />
+            </CardElement>
+            <CardElement
+                :text="$t('acchargeradmin.BatterySoCLimits')"
+                textVariant="text-bg-primary"
+                add-space
+                v-if="
+                    acChargerConfigList.auto_power_enabled && acChargerConfigList.auto_power_batterysoc_limits_enabled
+                "
+            >
+                <InputElement
+                    :label="$t('acchargeradmin.StopBatterySoCThreshold')"
+                    :tooltip="$t('acchargeradmin.StopBatterySoCThresholdHint')"
+                    v-model="acChargerConfigList.stop_batterysoc_threshold"
+                    postfix="%"
+                    type="number"
+                    wide
+                    required
+                    min="2"
+                    max="99"
+                />
             </CardElement>
 
             <FormFooter @reload="getChargerConfig" />
@@ -215,7 +160,6 @@ import BootstrapAlert from '@/components/BootstrapAlert.vue';
 import CardElement from '@/components/CardElement.vue';
 import FormFooter from '@/components/FormFooter.vue';
 import InputElement from '@/components/InputElement.vue';
-import { BIconInfoCircle } from 'bootstrap-icons-vue';
 import type { AcChargerConfig } from '@/types/AcChargerConfig';
 import { authHeader, handleResponse } from '@/utils/authentication';
 import { defineComponent } from 'vue';
@@ -227,7 +171,6 @@ export default defineComponent({
         CardElement,
         FormFooter,
         InputElement,
-        BIconInfoCircle,
     },
     data() {
         return {
diff --git a/webapp/src/views/BatteryAdminView.vue b/webapp/src/views/BatteryAdminView.vue
index 4a07357c..6652e6fc 100644
--- a/webapp/src/views/BatteryAdminView.vue
+++ b/webapp/src/views/BatteryAdminView.vue
@@ -10,47 +10,50 @@
                     :label="$t('batteryadmin.EnableBattery')"
                     v-model="batteryConfigList.enabled"
                     type="checkbox"
+                    wide
                 />
 
-                <InputElement
-                    v-show="batteryConfigList.enabled"
-                    :label="$t('batteryadmin.VerboseLogging')"
-                    v-model="batteryConfigList.verbose_logging"
-                    type="checkbox"
-                />
+                <template v-if="batteryConfigList.enabled">
+                    <InputElement
+                        :label="$t('batteryadmin.VerboseLogging')"
+                        v-model="batteryConfigList.verbose_logging"
+                        type="checkbox"
+                        wide
+                    />
 
-                <div class="row mb-3" v-show="batteryConfigList.enabled">
-                    <label class="col-sm-2 col-form-label">
-                        {{ $t('batteryadmin.Provider') }}
-                    </label>
-                    <div class="col-sm-10">
-                        <select class="form-select" v-model="batteryConfigList.provider">
-                            <option v-for="provider in providerTypeList" :key="provider.key" :value="provider.key">
-                                {{ $t(`batteryadmin.Provider` + provider.value) }}
-                            </option>
-                        </select>
+                    <div class="row mb-3">
+                        <label class="col-sm-4 col-form-label">
+                            {{ $t('batteryadmin.Provider') }}
+                        </label>
+                        <div class="col-sm-8">
+                            <select class="form-select" v-model="batteryConfigList.provider">
+                                <option v-for="provider in providerTypeList" :key="provider.key" :value="provider.key">
+                                    {{ $t(`batteryadmin.Provider` + provider.value) }}
+                                </option>
+                            </select>
+                        </div>
                     </div>
-                </div>
+                </template>
             </CardElement>
 
             <CardElement
-                v-show="batteryConfigList.enabled && batteryConfigList.provider == 1"
-                :text="$t('batteryadmin.JkBmsConfiguration')"
+                v-if="batteryConfigList.enabled && (batteryConfigList.provider == 1 || batteryConfigList.provider == 6)"
+                :text="$t('batteryadmin.SerialSettings')"
                 textVariant="text-bg-primary"
                 addSpace
             >
                 <div class="row mb-3">
-                    <label class="col-sm-2 col-form-label">
-                        {{ $t('batteryadmin.JkBmsInterface') }}
+                    <label class="col-sm-4 col-form-label">
+                        {{ $t('batteryadmin.SerialInterfaceType') }}
                     </label>
-                    <div class="col-sm-10">
+                    <div class="col-sm-8">
                         <select class="form-select" v-model="batteryConfigList.jkbms_interface">
                             <option
-                                v-for="jkBmsInterface in jkBmsInterfaceTypeList"
-                                :key="jkBmsInterface.key"
-                                :value="jkBmsInterface.key"
+                                v-for="serialInterface in serialBmsInterfaceTypeList"
+                                :key="serialInterface.key"
+                                :value="serialInterface.key"
                             >
-                                {{ $t(`batteryadmin.JkBmsInterface` + jkBmsInterface.value) }}
+                                {{ $t(`batteryadmin.SerialInterfaceType` + serialInterface.value) }}
                             </option>
                         </select>
                     </div>
@@ -64,6 +67,7 @@
                     max="90"
                     step="1"
                     :postfix="$t('batteryadmin.Seconds')"
+                    wide
                 />
             </CardElement>
 
@@ -74,6 +78,7 @@
                         v-model="batteryConfigList.mqtt_soc_topic"
                         type="text"
                         maxlength="256"
+                        wide
                     />
 
                     <InputElement
@@ -82,6 +87,7 @@
                         type="text"
                         maxlength="128"
                         :tooltip="$t('batteryadmin.MqttJsonPathDescription')"
+                        wide
                     />
                 </CardElement>
 
@@ -91,6 +97,7 @@
                         v-model="batteryConfigList.mqtt_voltage_topic"
                         type="text"
                         maxlength="256"
+                        wide
                     />
 
                     <InputElement
@@ -99,13 +106,14 @@
                         type="text"
                         maxlength="128"
                         :tooltip="$t('batteryadmin.MqttJsonPathDescription')"
+                        wide
                     />
 
                     <div class="row mb-3">
-                        <label for="mqtt_voltage_unit" class="col-sm-2 col-form-label">
+                        <label for="mqtt_voltage_unit" class="col-sm-4 col-form-label">
                             {{ $t('batteryadmin.MqttVoltageUnit') }}
                         </label>
-                        <div class="col-sm-10">
+                        <div class="col-sm-8">
                             <select
                                 id="mqtt_voltage_unit"
                                 class="form-select"
@@ -129,6 +137,7 @@
                     :label="$t('batteryadmin.LimitDischargeCurrent')"
                     v-model="batteryConfigList.enable_discharge_current_limit"
                     type="checkbox"
+                    wide
                 />
 
                 <template v-if="batteryConfigList.enable_discharge_current_limit">
@@ -139,60 +148,96 @@
                         min="0"
                         step="0.1"
                         postfix="A"
+                        wide
                     />
 
                     <InputElement
-                        :label="$t('batteryadmin.UseBatteryReportedDischargeCurrentLimit')"
-                        v-model="batteryConfigList.use_battery_reported_discharge_current_limit"
-                        type="checkbox"
+                        :label="$t('batteryadmin.DischargeCurrentLimitBelowSoc')"
+                        v-if="batteryConfigList.enabled"
+                        v-model="batteryConfigList.discharge_current_limit_below_soc"
+                        type="number"
+                        min="0"
+                        max="100"
+                        step="0.1"
+                        postfix="%"
+                        :tooltip="$t('batteryadmin.DischargeCurrentLimitBelowSocInfo')"
+                        wide
                     />
-                </template>
 
-                <template
-                    v-if="
-                        batteryConfigList.enable_discharge_current_limit &&
-                        batteryConfigList.use_battery_reported_discharge_current_limit
-                    "
-                >
-                    <div
-                        class="alert alert-secondary"
-                        role="alert"
-                        v-html="$t('batteryadmin.BatteryReportedDischargeCurrentLimitInfo')"
-                    ></div>
+                    <InputElement
+                        :label="$t('batteryadmin.DischargeCurrentLimitBelowVoltage')"
+                        v-if="batteryConfigList.enabled"
+                        v-model="batteryConfigList.discharge_current_limit_below_voltage"
+                        type="number"
+                        min="0"
+                        max="60"
+                        step="0.01"
+                        postfix="V"
+                        :tooltip="$t('batteryadmin.DischargeCurrentLimitBelowVoltageInfo')"
+                        wide
+                    />
 
-                    <template v-if="batteryConfigList.provider == 2">
+                    <template
+                        v-if="
+                            batteryConfigList.enabled &&
+                            (batteryConfigList.provider == 0 ||
+                                batteryConfigList.provider == 2 ||
+                                batteryConfigList.provider == 4 ||
+                                batteryConfigList.provider == 5)
+                        "
+                    >
                         <InputElement
-                            :label="$t('batteryadmin.MqttDischargeCurrentTopic')"
-                            v-model="batteryConfigList.mqtt_discharge_current_topic"
-                            type="text"
-                            maxlength="256"
+                            :label="$t('batteryadmin.UseBatteryReportedDischargeCurrentLimit')"
+                            v-model="batteryConfigList.use_battery_reported_discharge_current_limit"
+                            type="checkbox"
+                            wide
                         />
 
-                        <InputElement
-                            :label="$t('batteryadmin.MqttJsonPath')"
-                            v-model="batteryConfigList.mqtt_discharge_current_json_path"
-                            type="text"
-                            maxlength="128"
-                            :tooltip="$t('batteryadmin.MqttJsonPathDescription')"
-                        />
+                        <template v-if="batteryConfigList.use_battery_reported_discharge_current_limit">
+                            <div
+                                class="alert alert-secondary"
+                                role="alert"
+                                v-if="batteryConfigList.enabled"
+                                v-html="$t('batteryadmin.BatteryReportedDischargeCurrentLimitInfo')"
+                            ></div>
 
-                        <div class="row mb-3">
-                            <label for="mqtt_amperage_unit" class="col-sm-2 col-form-label">
-                                {{ $t('batteryadmin.MqttAmperageUnit') }}
-                            </label>
+                            <template v-if="batteryConfigList.provider == 2">
+                                <InputElement
+                                    :label="$t('batteryadmin.MqttDischargeCurrentTopic')"
+                                    v-model="batteryConfigList.mqtt_discharge_current_topic"
+                                    wide
+                                    type="text"
+                                    maxlength="256"
+                                />
 
-                            <div class="col-sm-10">
-                                <select
-                                    id="mqtt_amperage_unit"
-                                    class="form-select"
-                                    v-model="batteryConfigList.mqtt_amperage_unit"
-                                >
-                                    <option v-for="u in amperageUnitTypeList" :key="u.key" :value="u.key">
-                                        {{ u.value }}
-                                    </option>
-                                </select>
-                            </div>
-                        </div>
+                                <InputElement
+                                    :label="$t('batteryadmin.MqttJsonPath')"
+                                    v-model="batteryConfigList.mqtt_discharge_current_json_path"
+                                    wide
+                                    type="text"
+                                    maxlength="128"
+                                    :tooltip="$t('batteryadmin.MqttJsonPathDescription')"
+                                />
+
+                                <div class="row mb-3">
+                                    <label for="mqtt_amperage_unit" class="col-sm-4 col-form-label">
+                                        {{ $t('batteryadmin.MqttAmperageUnit') }}
+                                    </label>
+
+                                    <div class="col-sm-8">
+                                        <select
+                                            id="mqtt_amperage_unit"
+                                            class="form-select"
+                                            v-model="batteryConfigList.mqtt_amperage_unit"
+                                        >
+                                            <option v-for="u in amperageUnitTypeList" :key="u.key" :value="u.key">
+                                                {{ u.value }}
+                                            </option>
+                                        </select>
+                                    </div>
+                                </div>
+                            </template>
+                        </template>
                     </template>
                 </template>
             </CardElement>
@@ -234,8 +279,9 @@ export default defineComponent({
                 { key: 3, value: 'Victron' },
                 { key: 4, value: 'PytesCan' },
                 { key: 5, value: 'SBSCan' },
+                { key: 6, value: 'JbdBmsSerial' },
             ],
-            jkBmsInterfaceTypeList: [
+            serialBmsInterfaceTypeList: [
                 { key: 0, value: 'Uart' },
                 { key: 1, value: 'Transceiver' },
             ],
diff --git a/webapp/src/views/ConfigAdminView.vue b/webapp/src/views/ConfigAdminView.vue
index a5bf2f7d..c88fcf59 100644
--- a/webapp/src/views/ConfigAdminView.vue
+++ b/webapp/src/views/ConfigAdminView.vue
@@ -1,30 +1,38 @@
 <template>
-    <BasePage :title="$t('configadmin.ConfigManagement')" :isLoading="loading">
-        <BootstrapAlert v-model="showAlert" dismissible :variant="alertType">
-            {{ alertMessage }}
+    <BasePage :title="$t('fileadmin.ConfigManagement')" :isLoading="loading" :show-reload="true" @reload="getFileList">
+        <BootstrapAlert v-model="alert.show" dismissible :variant="alert.type">
+            {{ alert.message }}
         </BootstrapAlert>
 
-        <CardElement :text="$t('configadmin.BackupHeader')" textVariant="text-bg-primary" center-content>
-            <div class="row g-3 align-items-center">
-                <div class="col-sm">
-                    {{ $t('configadmin.BackupConfig') }}
-                </div>
-                <div class="col-sm">
-                    <select class="form-select" v-model="backupFileSelect">
-                        <option v-for="file in fileList.configs" :key="file.name" :value="file.name">
-                            {{ file.name }}
-                        </option>
-                    </select>
-                </div>
-                <div class="col-sm">
-                    <button class="btn btn-primary" @click="downloadConfig">
-                        {{ $t('configadmin.Backup') }}
-                    </button>
-                </div>
+        <CardElement :text="$t('fileadmin.BackupHeader')" textVariant="text-bg-primary">
+            <div class="table-responsive">
+                <table class="table">
+                    <thead>
+                        <tr>
+                            <th scope="col">{{ $t('fileadmin.Name') }}</th>
+                            <th>{{ $t('fileadmin.Size') }}</th>
+                            <th>{{ $t('fileadmin.Action') }}</th>
+                        </tr>
+                    </thead>
+                    <tbody ref="fileList">
+                        <tr v-for="(file, index) in fileList" :key="index" :value="index">
+                            <td>{{ file.name }}</td>
+                            <td>{{ $n(file.size, 'byte') }}</td>
+                            <td>
+                                <a href="#" class="icon text-danger" :title="$t('fileadmin.Delete')">
+                                    <BIconTrash v-on:click="onOpenModal(modalDelete, file)" /> </a
+                                >&nbsp;
+                                <a href="#" class="icon" :title="$t('fileadmin.Download')">
+                                    <BIconDownload v-on:click="downloadFile(file.name)" />
+                                </a>
+                            </td>
+                        </tr>
+                    </tbody>
+                </table>
             </div>
         </CardElement>
 
-        <CardElement :text="$t('configadmin.RestoreHeader')" textVariant="text-bg-primary" center-content add-space>
+        <CardElement :text="$t('fileadmin.RestoreHeader')" textVariant="text-bg-primary" add-space center-content>
             <div v-if="!uploading && UploadError != ''">
                 <p class="h1 mb-2">
                     <BIconExclamationCircleFill />
@@ -34,33 +42,39 @@
                 </span>
                 <br />
                 <br />
-                <button class="btn btn-light" @click="clear"><BIconArrowLeft /> {{ $t('configadmin.Back') }}</button>
+                <button class="btn btn-light" @click="clearUpload">
+                    <BIconArrowLeft /> {{ $t('fileadmin.Back') }}
+                </button>
             </div>
 
             <div v-else-if="!uploading && UploadSuccess">
                 <span class="h1 mb-2">
                     <BIconCheckCircle />
                 </span>
-                <span> {{ $t('configadmin.UploadSuccess') }} </span>
-                <br />
-                <br />
-                <button class="btn btn-primary" @click="clear"><BIconArrowLeft /> {{ $t('configadmin.Back') }}</button>
+                <span> {{ $t('fileadmin.UploadSuccess') }} </span>
             </div>
 
             <div v-else-if="!uploading">
                 <div class="row g-3 align-items-center form-group pt-2">
                     <div class="col-sm">
-                        <select class="form-select" v-model="restoreFileSelect">
-                            <option selected value="config.json">Main Config (config.json)</option>
-                            <option selected value="pin_mapping.json">Pin Mapping (pin_mapping.json)</option>
+                        <select class="form-select" v-model="restoreFileSelect" @change="onUploadFileChange">
+                            <option v-for="file in restoreList" :key="file.name" :value="file.name">
+                                {{ file.descr }}
+                            </option>
                         </select>
                     </div>
                     <div class="col-sm">
-                        <input class="form-control" type="file" ref="file" accept=".json" />
+                        <input
+                            class="form-control"
+                            type="file"
+                            ref="file"
+                            accept=".json"
+                            @change="onUploadFileChange"
+                        />
                     </div>
                     <div class="col-sm">
-                        <button class="btn btn-primary" @click="uploadConfig">
-                            {{ $t('configadmin.Restore') }}
+                        <button class="btn btn-primary" @click="onUpload" :disabled="!isValidJson">
+                            {{ $t('fileadmin.Restore') }}
                         </button>
                     </div>
                 </div>
@@ -81,28 +95,36 @@
                 </div>
             </div>
 
-            <div class="alert alert-danger mt-3" role="alert" v-html="$t('configadmin.RestoreHint')"></div>
+            <div class="alert alert-danger mt-3" role="alert" v-html="$t('fileadmin.RestoreHint')"></div>
         </CardElement>
 
-        <CardElement :text="$t('configadmin.ResetHeader')" textVariant="text-bg-primary" center-content add-space>
+        <CardElement :text="$t('fileadmin.ResetHeader')" textVariant="text-bg-primary" center-content add-space>
             <button class="btn btn-danger" @click="onFactoryResetModal">
-                {{ $t('configadmin.FactoryResetButton') }}
+                {{ $t('fileadmin.FactoryResetButton') }}
             </button>
 
-            <div class="alert alert-danger mt-3" role="alert" v-html="$t('configadmin.ResetHint')"></div>
+            <div class="alert alert-danger mt-3" role="alert" v-html="$t('fileadmin.ResetHint')"></div>
         </CardElement>
     </BasePage>
 
-    <ModalDialog
-        modalId="factoryReset"
-        small
-        :title="$t('configadmin.FactoryReset')"
-        :closeText="$t('configadmin.Cancel')"
-    >
-        {{ $t('configadmin.ResetMsg') }}
+    <ModalDialog modalId="fileDelete" small :title="$t('fileadmin.Delete')" :closeText="$t('fileadmin.Cancel')">
+        {{
+            $t('fileadmin.DeleteMsg', {
+                name: selectedFile.name,
+            })
+        }}
+        <template #footer>
+            <button type="button" class="btn btn-danger" @click="onDelete">
+                {{ $t('fileadmin.Delete') }}
+            </button>
+        </template>
+    </ModalDialog>
+
+    <ModalDialog modalId="factoryReset" small :title="$t('fileadmin.FactoryReset')" :closeText="$t('fileadmin.Cancel')">
+        {{ $t('fileadmin.ResetMsg') }}
         <template #footer>
             <button type="button" class="btn btn-danger" @click="onFactoryResetPerform">
-                {{ $t('configadmin.ResetConfirm') }}
+                {{ $t('fileadmin.ResetConfirm') }}
             </button>
         </template>
     </ModalDialog>
@@ -113,10 +135,20 @@ import BasePage from '@/components/BasePage.vue';
 import BootstrapAlert from '@/components/BootstrapAlert.vue';
 import CardElement from '@/components/CardElement.vue';
 import ModalDialog from '@/components/ModalDialog.vue';
-import type { ConfigFileList } from '@/types/Config';
+import type { AlertResponse } from '@/types/AlertResponse';
+import type { FileInfo } from '@/types/File';
 import { authHeader, handleResponse } from '@/utils/authentication';
+import type { Schema } from '@/utils/structure';
+import { hasStructure } from '@/utils/structure';
+import { waitRestart } from '@/utils/waitRestart';
 import * as bootstrap from 'bootstrap';
-import { BIconArrowLeft, BIconCheckCircle, BIconExclamationCircleFill } from 'bootstrap-icons-vue';
+import {
+    BIconArrowLeft,
+    BIconCheckCircle,
+    BIconDownload,
+    BIconExclamationCircleFill,
+    BIconTrash,
+} from 'bootstrap-icons-vue';
 import { defineComponent } from 'vue';
 
 export default defineComponent({
@@ -127,88 +159,148 @@ export default defineComponent({
         ModalDialog,
         BIconArrowLeft,
         BIconCheckCircle,
+        BIconDownload,
         BIconExclamationCircleFill,
+        BIconTrash,
     },
     data() {
         return {
-            modalFactoryReset: {} as bootstrap.Modal,
-            alertMessage: '',
-            alertType: 'info',
-            showAlert: false,
             loading: true,
+            fileList: [] as FileInfo[],
+            selectedFile: {} as FileInfo,
+            file: {} as Blob,
+            modalDelete: {} as bootstrap.Modal,
+            modalFactoryReset: {} as bootstrap.Modal,
+            alert: {} as AlertResponse,
             uploading: false,
             progress: 0,
             UploadError: '',
             UploadSuccess: false,
-            file: {} as Blob,
-            fileList: {} as ConfigFileList,
-            backupFileSelect: '',
             restoreFileSelect: 'config.json',
+            restoreList: [
+                {
+                    name: 'config.json',
+                    descr: 'Main Config (config.json)',
+                    template: { cfg: 'object' } as Schema,
+                },
+                {
+                    name: 'pin_mapping.json',
+                    descr: 'Pin Mapping (pin_mapping.json)',
+                    template: { name: 'string' } as Schema,
+                },
+                {
+                    name: 'pack.lang.json',
+                    descr: 'Language Pack (pack.lang.json)',
+                    template: { meta: 'object' } as Schema,
+                },
+            ],
+            isValidJson: false,
         };
     },
     mounted() {
+        this.modalDelete = new bootstrap.Modal('#fileDelete');
         this.modalFactoryReset = new bootstrap.Modal('#factoryReset');
     },
     created() {
         this.getFileList();
     },
     methods: {
-        onFactoryResetModal() {
-            this.modalFactoryReset.show();
-        },
-        onFactoryResetCancel() {
-            this.modalFactoryReset.hide();
-        },
-        onFactoryResetPerform() {
-            const formData = new FormData();
-            formData.append('data', JSON.stringify({ delete: true }));
-
-            fetch('/api/config/delete', {
-                method: 'POST',
-                headers: authHeader(),
-                body: formData,
-            })
-                .then((response) => handleResponse(response, this.$emitter, this.$router))
-                .then((response) => {
-                    this.alertMessage = this.$t('apiresponse.' + response.code, response.param);
-                    this.alertType = response.type;
-                    this.showAlert = true;
-                });
-            this.modalFactoryReset.hide();
-        },
         getFileList() {
             this.loading = true;
-            fetch('/api/config/list', { headers: authHeader() })
+            fetch('/api/file/list', { headers: authHeader() })
                 .then((response) => handleResponse(response, this.$emitter, this.$router))
                 .then((data) => {
                     this.fileList = data;
-                    if (this.fileList.configs) {
-                        this.backupFileSelect = this.fileList.configs[0].name;
-                    }
                     this.loading = false;
                 });
         },
-        downloadConfig() {
-            fetch('/api/config/get?file=' + this.backupFileSelect, { headers: authHeader() })
+        downloadFile(filename: string) {
+            fetch('/api/file/get?file=' + filename, { headers: authHeader() })
                 .then((res) => res.blob())
                 .then((blob) => {
                     const file = window.URL.createObjectURL(blob);
                     const a = document.createElement('a');
                     a.href = file;
-                    a.download = this.backupFileSelect;
+                    a.download = filename;
                     document.body.appendChild(a);
                     a.click();
                     a.remove();
                 });
         },
-        uploadConfig() {
+        callFileApiEndpoint(endpoint: string, jsonData: string) {
+            const formData = new FormData();
+            formData.append('data', jsonData);
+
+            fetch('/api/file/' + endpoint, {
+                method: 'POST',
+                headers: authHeader(),
+                body: formData,
+            })
+                .then((response) => handleResponse(response, this.$emitter, this.$router))
+                .then((data) => {
+                    this.getFileList();
+                    this.alert = data;
+                    this.alert.message = this.$t('apiresponse.' + data.code, data.param);
+                    this.alert.show = true;
+                });
+        },
+        onOpenModal(modal: bootstrap.Modal, file: FileInfo) {
+            // deep copy File object for editing/deleting
+            this.selectedFile = JSON.parse(JSON.stringify(file)) as FileInfo;
+            modal.show();
+        },
+        onCloseModal(modal: bootstrap.Modal) {
+            modal.hide();
+        },
+        onDelete() {
+            this.callFileApiEndpoint('delete', JSON.stringify({ file: this.selectedFile.name }));
+            this.onCloseModal(this.modalDelete);
+        },
+        onUploadFileChange() {
+            const target = this.$refs.file as HTMLInputElement;
+            if (target.files !== null) {
+                this.file = target.files[0];
+            }
+            if (!this.file) return;
+
+            // Read the file content
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                try {
+                    const checkTemplate = this.restoreList.find((i) => i.name == this.restoreFileSelect)?.template;
+                    // Parse the file content as JSON
+                    let checkValue = JSON.parse(e.target?.result as string);
+                    if (Array.isArray(checkValue)) {
+                        checkValue = checkValue[0];
+                    }
+
+                    if (checkValue && checkTemplate && hasStructure(checkValue, checkTemplate)) {
+                        this.isValidJson = true;
+                        this.alert.show = false;
+                    } else {
+                        this.isValidJson = false;
+                        this.alert.message = this.$t('fileadmin.InvalidJsonContent');
+                    }
+                } catch {
+                    this.isValidJson = false;
+                    this.alert.message = this.$t('fileadmin.InvalidJson');
+                }
+
+                if (!this.isValidJson) {
+                    this.alert.type = 'warning';
+                    this.alert.show = true;
+                }
+            };
+            reader.readAsText(this.file);
+        },
+        onUpload() {
             this.uploading = true;
             const formData = new FormData();
             const target = this.$refs.file as HTMLInputElement; //  event.target as HTMLInputElement;
             if (target.files !== null && target.files?.length > 0) {
                 this.file = target.files[0];
             } else {
-                this.UploadError = this.$t('configadmin.NoFileSelected');
+                this.UploadError = this.$t('fileadmin.NoFileSelected');
                 this.uploading = false;
                 this.progress = 0;
                 return;
@@ -218,6 +310,7 @@ export default defineComponent({
                 // request.response will hold the response from the server
                 if (request.status === 200) {
                     this.UploadSuccess = true;
+                    waitRestart(this.$router);
                 } else if (request.status !== 500) {
                     this.UploadError = `[HTTP ERROR] ${request.statusText}`;
                 } else {
@@ -233,17 +326,40 @@ export default defineComponent({
             request.withCredentials = true;
 
             formData.append('config', this.file, 'config');
-            request.open('post', '/api/config/upload?file=' + this.restoreFileSelect);
+            request.open('post', '/api/file/upload?file=' + this.restoreFileSelect);
             authHeader().forEach((value, key) => {
                 request.setRequestHeader(key, value);
             });
             request.send(formData);
         },
-        clear() {
+        clearUpload() {
             this.UploadError = '';
             this.UploadSuccess = false;
             this.getFileList();
         },
+        onFactoryResetModal() {
+            this.modalFactoryReset.show();
+        },
+        onFactoryResetCancel() {
+            this.modalFactoryReset.hide();
+        },
+        onFactoryResetPerform() {
+            const formData = new FormData();
+            formData.append('data', JSON.stringify({ delete: true }));
+
+            fetch('/api/file/delete_all', {
+                method: 'POST',
+                headers: authHeader(),
+                body: formData,
+            })
+                .then((response) => handleResponse(response, this.$emitter, this.$router))
+                .then((response) => {
+                    this.alert.message = this.$t('apiresponse.' + response.code, response.param);
+                    this.alert.type = response.type;
+                    this.alert.show = true;
+                });
+            this.modalFactoryReset.hide();
+        },
     },
 });
 </script>
diff --git a/webapp/src/views/DeviceAdminView.vue b/webapp/src/views/DeviceAdminView.vue
index 258ec5b2..b239c5d5 100644
--- a/webapp/src/views/DeviceAdminView.vue
+++ b/webapp/src/views/DeviceAdminView.vue
@@ -1,5 +1,5 @@
 <template>
-    <BasePage :title="$t('deviceadmin.DeviceManager')" :isLoading="dataLoading || pinMappingLoading">
+    <BasePage :title="$t('deviceadmin.DeviceManager')" :isLoading="dataLoading || pinMappingLoading || languageLoading">
         <BootstrapAlert v-model="showAlert" dismissible :variant="alertType">
             {{ alertMessage }}
         </BootstrapAlert>
@@ -51,7 +51,7 @@
                     aria-labelledby="nav-pin-tab"
                     tabindex="0"
                 >
-                    <div class="card">
+                    <div class="card card-tabbed">
                         <div class="card-body">
                             <div class="row mb-3">
                                 <label for="inputPinProfile" class="col-sm-2 col-form-label">{{
@@ -78,18 +78,17 @@
                                 </div>
                             </div>
 
-                            <div class="row mb-3">
+                            <div class="row mb-3" v-if="docLinks.length">
                                 <div class="col-sm-2"></div>
-                                <div class="col-sm-10">
-                                    <div
-                                        class="btn-group mb-2 me-2"
-                                        v-for="(doc, index) in pinMappingList.find(
-                                            (i) => i.name === deviceConfigList.curPin.name
-                                        )?.links"
+                                <div class="col-sm-10 d-flex gap-3">
+                                    <a
+                                        v-for="(doc, index) in docLinks"
                                         :key="index"
+                                        :href="doc.url"
+                                        class="btn btn-primary"
+                                        target="_blank"
+                                        >{{ doc.name }}</a
                                     >
-                                        <a :href="doc.url" class="btn btn-primary" target="_blank">{{ doc.name }}</a>
-                                    </div>
                                 </div>
                             </div>
 
@@ -116,7 +115,7 @@
                     aria-labelledby="nav-display-tab"
                     tabindex="0"
                 >
-                    <div class="card">
+                    <div class="card card-tabbed">
                         <div class="card-body">
                             <InputElement
                                 :label="$t('deviceadmin.PowerSafe')"
@@ -160,13 +159,13 @@
                                     {{ $t('deviceadmin.DisplayLanguage') }}
                                 </label>
                                 <div class="col-sm-10">
-                                    <select class="form-select" v-model="deviceConfigList.display.language">
+                                    <select class="form-select" v-model="deviceConfigList.display.locale">
                                         <option
-                                            v-for="language in displayLanguageList"
-                                            :key="language.key"
-                                            :value="language.key"
+                                            v-for="(locale, index) in displayLocaleList"
+                                            :key="locale.code"
+                                            :value="locale.code"
                                         >
-                                            {{ $t(`deviceadmin.` + language.value) }}
+                                            {{ $t((index < 3 ? `deviceadmin.` : ``) + locale.name) }}
                                         </option>
                                     </select>
                                 </div>
@@ -217,7 +216,7 @@
                     aria-labelledby="nav-leds-tab"
                     tabindex="0"
                 >
-                    <div class="card">
+                    <div class="card card-tabbed">
                         <div class="card-body">
                             <InputElement
                                 :label="$t('deviceadmin.EqualBrightness')"
@@ -277,6 +276,7 @@ export default defineComponent({
         return {
             dataLoading: true,
             pinMappingLoading: true,
+            languageLoading: true,
             deviceConfigList: {} as DeviceConfig,
             pinMappingList: {} as PinMapping,
             alertMessage: '',
@@ -289,10 +289,10 @@ export default defineComponent({
                 { key: 2, value: 'rot180' },
                 { key: 3, value: 'rot270' },
             ],
-            displayLanguageList: [
-                { key: 0, value: 'en' },
-                { key: 1, value: 'de' },
-                { key: 2, value: 'fr' },
+            displayLocaleList: [
+                { code: 'en', name: 'en' },
+                { code: 'de', name: 'de' },
+                { code: 'fr', name: 'fr' },
             ],
             diagramModeList: [
                 { key: 0, value: 'off' },
@@ -304,6 +304,7 @@ export default defineComponent({
     created() {
         this.getDeviceConfig();
         this.getPinMappingList();
+        this.getLanguageList();
     },
     watch: {
         equalBrightnessCheckVal: function (val) {
@@ -313,10 +314,25 @@ export default defineComponent({
             this.deviceConfigList.led.every((v) => (v.brightness = this.deviceConfigList.led[0].brightness));
         },
     },
+    computed: {
+        docLinks() {
+            const mapping = this.pinMappingList.find((i) => i.name === this.deviceConfigList.curPin.name);
+            return mapping?.links || [];
+        },
+    },
     methods: {
+        getLanguageList() {
+            this.languageLoading = true;
+            fetch('/api/i18n/languages')
+                .then((response) => handleResponse(response, this.$emitter, this.$router))
+                .then((data) => {
+                    this.displayLocaleList.push(...data);
+                    this.languageLoading = false;
+                });
+        },
         getPinMappingList() {
             this.pinMappingLoading = true;
-            fetch('/api/config/get?file=pin_mapping.json', { headers: authHeader() })
+            fetch('/api/file/get?file=pin_mapping.json', { headers: authHeader() })
                 .then((response) => handleResponse(response, this.$emitter, this.$router, true))
                 .then((data) => {
                     this.pinMappingList = data;
diff --git a/webapp/src/views/DtuAdminView.vue b/webapp/src/views/DtuAdminView.vue
index 668c3ede..74f33afb 100644
--- a/webapp/src/views/DtuAdminView.vue
+++ b/webapp/src/views/DtuAdminView.vue
@@ -50,7 +50,7 @@
                         <BIconInfoCircle v-tooltip :title="$t('dtuadmin.CmtPaLevelHint')" />
                     </label>
                     <div class="col-sm-10">
-                        <div class="input-group mb-3">
+                        <div class="input-group">
                             <input
                                 type="range"
                                 class="form-control form-range"
@@ -91,7 +91,7 @@
                         <BIconInfoCircle v-tooltip :title="$t('dtuadmin.CmtFrequencyHint')" />
                     </label>
                     <div class="col-sm-10">
-                        <div class="input-group mb-3">
+                        <div class="input-group">
                             <input
                                 type="range"
                                 class="form-control form-range"
diff --git a/webapp/src/views/FirmwareUpgradeView.vue b/webapp/src/views/FirmwareUpgradeView.vue
index df8e4304..8c3be506 100644
--- a/webapp/src/views/FirmwareUpgradeView.vue
+++ b/webapp/src/views/FirmwareUpgradeView.vue
@@ -17,16 +17,15 @@
             <p class="h1 mb-2">
                 <BIconExclamationCircleFill />
             </p>
-
-            <span style="vertical-align: middle" class="ml-2">
-                {{ OTAError }}
-            </span>
-            <br />
-            <br />
-            <button class="btn btn-light" @click="clear"><BIconArrowLeft /> {{ $t('firmwareupgrade.Back') }}</button>
-            <button class="btn btn-primary" @click="retryOTA">
-                <BIconArrowRepeat /> {{ $t('firmwareupgrade.Retry') }}
-            </button>
+            {{ OTAError }}
+            <div class="mt-3 d-flex gap-3 justify-content-center">
+                <button class="btn btn-light" @click="clear">
+                    <BIconArrowLeft /> {{ $t('firmwareupgrade.Back') }}
+                </button>
+                <button class="btn btn-primary" @click="retryOTA">
+                    <BIconArrowRepeat /> {{ $t('firmwareupgrade.Retry') }}
+                </button>
+            </div>
         </CardElement>
 
         <CardElement
@@ -35,17 +34,7 @@
             center-content
             v-else-if="!loading && !uploading && OTASuccess"
         >
-            <span class="h1 mb-2">
-                <BIconCheckCircle />
-            </span>
-            <span> {{ $t('firmwareupgrade.OtaSuccess') }} </span>
-            <br />
-            <br />
-            <div class="text-center">
-                <div class="spinner-border" role="status">
-                    <span class="visually-hidden"></span>
-                </div>
-            </div>
+            <BIconCheckCircle class="fs-1" />&nbsp;{{ $t('firmwareupgrade.OtaSuccess') }}
         </CardElement>
 
         <CardElement
@@ -62,7 +51,7 @@
             center-content
             v-else-if="!loading && !uploading"
         >
-            <div class="form-group pt-2 mt-3">
+            <div class="form-group">
                 <input class="form-control" type="file" ref="file" accept=".bin,.bin.gz" @change="uploadOTA" />
             </div>
         </CardElement>
@@ -97,6 +86,7 @@ import { authHeader, isLoggedIn, handleResponse } from '@/utils/authentication';
 import { BIconArrowLeft, BIconArrowRepeat, BIconCheckCircle, BIconExclamationCircleFill } from 'bootstrap-icons-vue';
 import SparkMD5 from 'spark-md5';
 import { defineComponent } from 'vue';
+import { waitRestart } from '@/utils/waitRestart';
 
 export default defineComponent({
     components: {
@@ -116,7 +106,6 @@ export default defineComponent({
             OTASuccess: false,
             type: 'firmware',
             file: {} as Blob,
-            hostCheckInterval: 0,
             firmwareStatus: {} as FirmwareStatus,
         };
     },
@@ -164,7 +153,7 @@ export default defineComponent({
                 // request.response will hold the response from the server
                 if (request.status === 200) {
                     this.OTASuccess = true;
-                    this.hostCheckInterval = setInterval(this.checkRemoteHostAndReload, 1000);
+                    waitRestart(this.$router);
                 } else if (request.status !== 500) {
                     this.OTAError = `[HTTP ERROR] ${request.statusText}`;
                 } else {
@@ -203,32 +192,6 @@ export default defineComponent({
             this.OTAError = '';
             this.OTASuccess = false;
         },
-        checkRemoteHostAndReload(): void {
-            // Check if the browser is online
-            if (navigator.onLine) {
-                const remoteHostUrl = '/api/system/status';
-
-                // Use a simple fetch request to check if the remote host is reachable
-                fetch(remoteHostUrl, { method: 'GET' })
-                    .then((response) => {
-                        // Check if the response status is OK (200-299 range)
-                        if (response.ok) {
-                            console.log('Remote host is available. Reloading page...');
-                            clearInterval(this.hostCheckInterval);
-                            this.hostCheckInterval = 0;
-                            // Perform a page reload
-                            window.location.replace('/');
-                        } else {
-                            console.log('Remote host is not reachable. Do something else if needed.');
-                        }
-                    })
-                    .catch((error) => {
-                        console.error('Error checking remote host:', error);
-                    });
-            } else {
-                console.log('Browser is offline. Cannot check remote host.');
-            }
-        },
         getFirmwareStatus() {
             fetch('/api/firmware/status', { headers: authHeader() })
                 .then((response) => handleResponse(response, this.$emitter, this.$router))
@@ -245,10 +208,8 @@ export default defineComponent({
                 query: { returnUrl: this.$router.currentRoute.value.fullPath },
             });
         }
+        this.loading = false;
         this.getFirmwareStatus();
     },
-    unmounted() {
-        clearInterval(this.hostCheckInterval);
-    },
 });
 </script>
diff --git a/webapp/src/views/HomeView.vue b/webapp/src/views/HomeView.vue
index ba4eb050..37e88e3c 100644
--- a/webapp/src/views/HomeView.vue
+++ b/webapp/src/views/HomeView.vue
@@ -17,7 +17,12 @@
         />
         <div class="row gy-3 mt-0">
             <div class="col-sm-3 col-md-2" :style="[inverterData.length == 1 ? { display: 'none' } : {}]">
-                <div class="nav nav-pills row-cols-sm-1" id="v-pills-tab" role="tablist" aria-orientation="vertical">
+                <div
+                    class="nav nav-pills row-cols-sm-1 gap-3"
+                    id="v-pills-tab"
+                    role="tablist"
+                    aria-orientation="vertical"
+                >
                     <button
                         v-for="inverter in inverterData"
                         :key="inverter.serial"
@@ -30,8 +35,8 @@
                         aria-controls="'v-pills-' + inverter.serial"
                         aria-selected="true"
                     >
-                        <div class="row">
-                            <div class="col-auto col-sm-2">
+                        <div class="d-flex align-items-center">
+                            <div class="me-2">
                                 <BIconXCircleFill class="fs-4" v-if="!inverter.reachable" />
                                 <BIconExclamationCircleFill
                                     class="fs-4"
@@ -39,7 +44,7 @@
                                 />
                                 <BIconCheckCircleFill class="fs-4" v-if="inverter.reachable && inverter.producing" />
                             </div>
-                            <div class="col-sm-9">
+                            <div class="ms-auto me-auto">
                                 {{ inverter.name }}
                             </div>
                         </div>
@@ -217,8 +222,8 @@
                                 </div>
                             </BootstrapAlert>
 
-                            <div class="accordion mt-5" id="accordionExample">
-                                <div class="accordion-item">
+                            <div class="accordion mt-5" id="accordionRadioStats">
+                                <div class="accordion-item accordion-table">
                                     <h2 class="accordion-header">
                                         <button
                                             class="accordion-button collapsed"
@@ -234,7 +239,7 @@
                                     <div
                                         id="collapseStats"
                                         class="accordion-collapse collapse"
-                                        data-bs-parent="#accordionExample"
+                                        data-bs-parent="#accordionRadioStats"
                                     >
                                         <div class="accordion-body">
                                             <table class="table table-striped table-hover">
@@ -309,23 +314,25 @@
                                                     </tr>
                                                 </tbody>
                                             </table>
-                                            <button
-                                                :disabled="!isLogged || performRadioStatsReset"
-                                                type="button"
-                                                class="btn btn-danger"
-                                                @click="onResetRadioStats(inverter.serial)"
-                                            >
-                                                <template v-if="!performRadioStatsReset">
-                                                    {{ $t('home.StatsReset') }}
-                                                </template>
-                                                <template v-else>
-                                                    <span
-                                                        class="spinner-border spinner-border-sm"
-                                                        aria-hidden="true"
-                                                    ></span>
-                                                    <span role="status"> {{ $t('home.StatsResetting') }}</span>
-                                                </template>
-                                            </button>
+                                            <div class="d-flex">
+                                                <button
+                                                    :disabled="!isLogged || performRadioStatsReset"
+                                                    type="button"
+                                                    class="btn btn-danger ms-auto me-3 mt-3"
+                                                    @click="onResetRadioStats(inverter.serial)"
+                                                >
+                                                    <template v-if="!performRadioStatsReset">
+                                                        <BIconArrowCounterclockwise />&nbsp;{{ $t('home.StatsReset') }}
+                                                    </template>
+                                                    <template v-else>
+                                                        <span
+                                                            class="spinner-border spinner-border-sm"
+                                                            aria-hidden="true"
+                                                        ></span>
+                                                        <span role="status">&nbsp;{{ $t('home.StatsResetting') }}</span>
+                                                    </template>
+                                                </button>
+                                            </div>
                                         </div>
                                     </div>
                                 </div>
diff --git a/webapp/src/views/InverterAdminView.vue b/webapp/src/views/InverterAdminView.vue
index 548c8ff5..82391c77 100644
--- a/webapp/src/views/InverterAdminView.vue
+++ b/webapp/src/views/InverterAdminView.vue
@@ -20,13 +20,13 @@
                         required
                     />
                 </div>
-                <div class="ml-auto text-right">
-                    <button type="submit" class="btn btn-primary my-2">
+                <div class="d-flex my-3">
+                    <button type="submit" class="btn btn-primary ms-auto">
                         {{ $t('inverteradmin.Add') }}
                     </button>
                 </div>
-                <div class="alert alert-secondary" role="alert" v-html="$t('inverteradmin.AddHint')"></div>
             </form>
+            <div class="alert alert-secondary" role="alert" v-html="$t('inverteradmin.AddHint')"></div>
         </CardElement>
 
         <CardElement :text="$t('inverteradmin.InverterList')" textVariant="text-bg-primary" add-space>
@@ -81,8 +81,8 @@
                     </tbody>
                 </table>
             </div>
-            <div class="ml-auto text-right">
-                <button class="btn btn-primary my-2" @click="onSaveOrder()">
+            <div class="d-flex mt-1 mb-3">
+                <button class="btn btn-primary ms-auto" @click="onSaveOrder()">
                     {{ $t('inverteradmin.SaveOrder') }}
                 </button>
             </div>
@@ -267,7 +267,7 @@
             </div>
 
             <div
-                class="tab-pane fade show"
+                class="tab-pane fade show pt-3"
                 id="nav-advanced"
                 role="tabpanel"
                 aria-labelledby="nav-advanced-tab"
@@ -349,6 +349,7 @@ import CardElement from '@/components/CardElement.vue';
 import InputElement from '@/components/InputElement.vue';
 import InputSerial from '@/components/InputSerial.vue';
 import ModalDialog from '@/components/ModalDialog.vue';
+import type { AlertResponse } from '@/types/AlertResponse';
 import type { Inverter } from '@/types/InverterConfig';
 import { authHeader, handleResponse } from '@/utils/authentication';
 import * as bootstrap from 'bootstrap';
@@ -363,13 +364,6 @@ import {
 import Sortable from 'sortablejs';
 import { defineComponent } from 'vue';
 
-declare interface AlertResponse {
-    message: string;
-    type: string;
-    code: number;
-    show: boolean;
-}
-
 export default defineComponent({
     components: {
         BasePage,
diff --git a/webapp/src/views/LoginView.vue b/webapp/src/views/LoginView.vue
index f24a791f..aaa11bfc 100644
--- a/webapp/src/views/LoginView.vue
+++ b/webapp/src/views/LoginView.vue
@@ -20,7 +20,7 @@
                         {{ $t('login.UsernameRequired') }}
                     </div>
                 </div>
-                <div class="form-group">
+                <div class="form-group mt-3">
                     <label htmlFor="password">{{ $t('login.Password') }}</label>
                     <input
                         type="password"
@@ -33,7 +33,7 @@
                         {{ $t('login.PasswordRequired') }}
                     </div>
                 </div>
-                <div class="form-group">
+                <div class="d-flex justify-content-end mt-3">
                     <button class="btn btn-primary" :disabled="dataLoading">
                         {{ $t('login.LoginButton') }}
                     </button>
diff --git a/webapp/src/views/MaintenanceRebootView.vue b/webapp/src/views/MaintenanceRebootView.vue
index d80d050c..682ce500 100644
--- a/webapp/src/views/MaintenanceRebootView.vue
+++ b/webapp/src/views/MaintenanceRebootView.vue
@@ -36,6 +36,7 @@ import ModalDialog from '@/components/ModalDialog.vue';
 import { authHeader, handleResponse, isLoggedIn } from '@/utils/authentication';
 import * as bootstrap from 'bootstrap';
 import { defineComponent } from 'vue';
+import { waitRestart } from '@/utils/waitRestart';
 
 export default defineComponent({
     components: {
@@ -80,6 +81,7 @@ export default defineComponent({
                     this.alertMessage = this.$t('apiresponse.' + data.code, data.param);
                     this.alertType = data.type;
                     this.showAlert = true;
+                    waitRestart(this.$router);
                 });
             this.onCloseModal(this.performReboot);
         },
diff --git a/webapp/src/views/MqttAdminView.vue b/webapp/src/views/MqttAdminView.vue
index 0420a1fc..daa9fb4b 100644
--- a/webapp/src/views/MqttAdminView.vue
+++ b/webapp/src/views/MqttAdminView.vue
@@ -14,7 +14,7 @@
                 />
 
                 <InputElement
-                    v-show="mqttConfigList.mqtt_enabled"
+                    v-if="mqttConfigList.mqtt_enabled"
                     :label="$t('mqttadmin.VerboseLogging')"
                     v-model="mqttConfigList.mqtt_verbose_logging"
                     type="checkbox"
@@ -22,7 +22,7 @@
                 />
 
                 <InputElement
-                    v-show="mqttConfigList.mqtt_enabled"
+                    v-if="mqttConfigList.mqtt_enabled"
                     :label="$t('mqttadmin.EnableHass')"
                     v-model="mqttConfigList.mqtt_hass_enabled"
                     type="checkbox"
@@ -34,7 +34,7 @@
                 :text="$t('mqttadmin.MqttBrokerParameter')"
                 textVariant="text-bg-primary"
                 add-space
-                v-show="mqttConfigList.mqtt_enabled"
+                v-if="mqttConfigList.mqtt_enabled"
             >
                 <InputElement
                     :label="$t('mqttadmin.Hostname')"
@@ -107,7 +107,7 @@
                 <InputElement :label="$t('mqttadmin.EnableTls')" v-model="mqttConfigList.mqtt_tls" type="checkbox" />
 
                 <InputElement
-                    v-show="mqttConfigList.mqtt_tls"
+                    v-if="mqttConfigList.mqtt_tls"
                     :label="$t('mqttadmin.RootCa')"
                     v-model="mqttConfigList.mqtt_root_ca_cert"
                     type="textarea"
@@ -116,14 +116,14 @@
                 />
 
                 <InputElement
-                    v-show="mqttConfigList.mqtt_tls"
+                    v-if="mqttConfigList.mqtt_tls"
                     :label="$t('mqttadmin.TlsCertLoginEnable')"
                     v-model="mqttConfigList.mqtt_tls_cert_login"
                     type="checkbox"
                 />
 
                 <InputElement
-                    v-show="mqttConfigList.mqtt_tls_cert_login"
+                    v-if="mqttConfigList.mqtt_tls_cert_login"
                     :label="$t('mqttadmin.ClientCert')"
                     v-model="mqttConfigList.mqtt_client_cert"
                     type="textarea"
@@ -132,7 +132,7 @@
                 />
 
                 <InputElement
-                    v-show="mqttConfigList.mqtt_tls_cert_login"
+                    v-if="mqttConfigList.mqtt_tls_cert_login"
                     :label="$t('mqttadmin.ClientKey')"
                     v-model="mqttConfigList.mqtt_client_key"
                     type="textarea"
@@ -145,7 +145,7 @@
                 :text="$t('mqttadmin.LwtParameters')"
                 textVariant="text-bg-primary"
                 add-space
-                v-show="mqttConfigList.mqtt_enabled"
+                v-if="mqttConfigList.mqtt_enabled"
             >
                 <InputElement
                     :label="$t('mqttadmin.LwtTopic')"
@@ -190,7 +190,7 @@
                 :text="$t('mqttadmin.HassParameters')"
                 textVariant="text-bg-primary"
                 add-space
-                v-show="mqttConfigList.mqtt_enabled && mqttConfigList.mqtt_hass_enabled"
+                v-if="mqttConfigList.mqtt_enabled && mqttConfigList.mqtt_hass_enabled"
             >
                 <InputElement
                     :label="$t('mqttadmin.HassPrefixTopic')"
diff --git a/webapp/src/views/MqttInfoView.vue b/webapp/src/views/MqttInfoView.vue
index c79a4366..7aaed981 100644
--- a/webapp/src/views/MqttInfoView.vue
+++ b/webapp/src/views/MqttInfoView.vue
@@ -5,7 +5,7 @@
         :show-reload="true"
         @reload="getMqttInfo"
     >
-        <CardElement :text="$t('mqttinfo.ConfigurationSummary')" textVariant="text-bg-primary">
+        <CardElement :text="$t('mqttinfo.ConfigurationSummary')" textVariant="text-bg-primary" table>
             <div class="table-responsive">
                 <table class="table table-hover table-condensed">
                     <tbody>
@@ -89,11 +89,11 @@
                                 />
                             </td>
                         </tr>
-                        <tr v-show="mqttDataList.mqtt_tls">
+                        <tr v-if="mqttDataList.mqtt_tls">
                             <th>{{ $t('mqttinfo.RootCertifcateInfo') }}</th>
                             <td>{{ mqttDataList.mqtt_root_ca_cert_info }}</td>
                         </tr>
-                        <tr>
+                        <tr v-if="mqttDataList.mqtt_tls">
                             <th>{{ $t('mqttinfo.TlsCertLogin') }}</th>
                             <td>
                                 <StatusBadge
@@ -103,7 +103,7 @@
                                 />
                             </td>
                         </tr>
-                        <tr v-show="mqttDataList.mqtt_tls_cert_login">
+                        <tr v-if="mqttDataList.mqtt_tls && mqttDataList.mqtt_tls_cert_login">
                             <th>{{ $t('mqttinfo.ClientCertifcateInfo') }}</th>
                             <td>{{ mqttDataList.mqtt_client_cert_info }}</td>
                         </tr>
@@ -112,7 +112,7 @@
             </div>
         </CardElement>
 
-        <CardElement :text="$t('mqttinfo.HassSummary')" textVariant="text-bg-primary" add-space>
+        <CardElement :text="$t('mqttinfo.HassSummary')" textVariant="text-bg-primary" add-space table>
             <div class="table-responsive">
                 <table class="table table-hover table-condensed">
                     <tbody>
@@ -165,7 +165,7 @@
             </div>
         </CardElement>
 
-        <CardElement :text="$t('mqttinfo.RuntimeSummary')" textVariant="text-bg-primary" add-space>
+        <CardElement :text="$t('mqttinfo.RuntimeSummary')" textVariant="text-bg-primary" add-space table>
             <div class="table-responsive">
                 <table class="table table-hover table-condensed">
                     <tbody>
diff --git a/webapp/src/views/NetworkAdminView.vue b/webapp/src/views/NetworkAdminView.vue
index 058dfe32..dab84c95 100644
--- a/webapp/src/views/NetworkAdminView.vue
+++ b/webapp/src/views/NetworkAdminView.vue
@@ -26,7 +26,11 @@
                     type="text"
                     maxlength="32"
                 >
-                    <div class="alert alert-secondary" role="alert" v-html="$t('networkadmin.HostnameHint')"></div>
+                    <div
+                        class="alert alert-secondary mb-0 mt-3"
+                        role="alert"
+                        v-html="$t('networkadmin.HostnameHint')"
+                    ></div>
                 </InputElement>
 
                 <InputElement :label="$t('networkadmin.EnableDhcp')" v-model="networkConfigList.dhcp" type="checkbox" />
@@ -89,7 +93,7 @@
                     type="checkbox"
                 />
 
-                <div v-if="networkConfigList.syslogenabled">
+                <template v-if="networkConfigList.syslogenabled">
                     <InputElement
                         :label="$t('networkadmin.SyslogHostname')"
                         v-model="networkConfigList.sysloghostname"
@@ -104,7 +108,7 @@
                         min="1"
                         max="65535"
                     />
-                </div>
+                </template>
             </CardElement>
 
             <CardElement :text="$t('networkadmin.AdminAp')" textVariant="text-bg-primary" add-space>
diff --git a/webapp/src/views/NtpInfoView.vue b/webapp/src/views/NtpInfoView.vue
index 68100d1c..29aa00e4 100644
--- a/webapp/src/views/NtpInfoView.vue
+++ b/webapp/src/views/NtpInfoView.vue
@@ -1,6 +1,6 @@
 <template>
     <BasePage :title="$t('ntpinfo.NtpInformation')" :isLoading="dataLoading" :show-reload="true" @reload="getNtpInfo">
-        <CardElement :text="$t('ntpinfo.ConfigurationSummary')" textVariant="text-bg-primary">
+        <CardElement :text="$t('ntpinfo.ConfigurationSummary')" textVariant="text-bg-primary" table>
             <div class="table-responsive">
                 <table class="table table-hover table-condensed">
                     <tbody>
@@ -21,7 +21,7 @@
             </div>
         </CardElement>
 
-        <CardElement :text="$t('ntpinfo.CurrentTime')" textVariant="text-bg-primary" add-space>
+        <CardElement :text="$t('ntpinfo.CurrentTime')" textVariant="text-bg-primary" add-space table>
             <div class="table-responsive">
                 <table class="table table-hover table-condensed">
                     <tbody>
diff --git a/webapp/src/views/PowerLimiterAdminView.vue b/webapp/src/views/PowerLimiterAdminView.vue
index 05b7bdd9..1a40559e 100644
--- a/webapp/src/views/PowerLimiterAdminView.vue
+++ b/webapp/src/views/PowerLimiterAdminView.vue
@@ -30,7 +30,11 @@
         </CardElement>
 
         <form @submit="savePowerLimiterConfig" v-if="!configAlert">
-            <CardElement :text="$t('powerlimiteradmin.General')" textVariant="text-bg-primary" add-space>
+            <CardElement
+                :text="$t('powerlimiteradmin.General')"
+                textVariant="text-bg-primary"
+                :add-space="getConfigHints().length > 0"
+            >
                 <InputElement
                     :label="$t('powerlimiteradmin.Enable')"
                     v-model="powerLimiterConfigList.enabled"
@@ -38,236 +42,332 @@
                     wide
                 />
 
-                <InputElement
-                    v-show="isEnabled()"
-                    :label="$t('powerlimiteradmin.VerboseLogging')"
-                    v-model="powerLimiterConfigList.verbose_logging"
-                    type="checkbox"
-                    wide
-                />
-
-                <InputElement
-                    v-show="isEnabled() && hasPowerMeter()"
-                    :label="$t('powerlimiteradmin.TargetPowerConsumption')"
-                    :tooltip="$t('powerlimiteradmin.TargetPowerConsumptionHint')"
-                    v-model="powerLimiterConfigList.target_power_consumption"
-                    postfix="W"
-                    type="number"
-                    wide
-                />
-
-                <InputElement
-                    v-show="isEnabled()"
-                    :label="$t('powerlimiteradmin.TargetPowerConsumptionHysteresis')"
-                    :tooltip="$t('powerlimiteradmin.TargetPowerConsumptionHysteresisHint')"
-                    v-model="powerLimiterConfigList.target_power_consumption_hysteresis"
-                    postfix="W"
-                    type="number"
-                    wide
-                />
-            </CardElement>
-
-            <CardElement
-                :text="$t('powerlimiteradmin.InverterSettings')"
-                textVariant="text-bg-primary"
-                add-space
-                v-if="isEnabled()"
-            >
-                <div class="row mb-3">
-                    <label for="inverter_serial" class="col-sm-4 col-form-label">
-                        {{ $t('powerlimiteradmin.Inverter') }}
-                    </label>
-                    <div class="col-sm-8">
-                        <select
-                            id="inverter_serial"
-                            class="form-select"
-                            v-model="powerLimiterConfigList.inverter_serial"
-                            required
-                        >
-                            <option value="" disabled hidden selected>
-                                {{ $t('powerlimiteradmin.SelectInverter') }}
-                            </option>
-                            <option
-                                v-for="(inv, serial) in powerLimiterMetaData.inverters"
-                                :key="serial"
-                                :value="serial"
-                            >
-                                {{ inv.name }} ({{ inv.type }})
-                            </option>
-                        </select>
-                    </div>
-                </div>
-
-                <InputElement
-                    :label="$t('powerlimiteradmin.InverterIsSolarPowered')"
-                    v-model="powerLimiterConfigList.is_inverter_solar_powered"
-                    type="checkbox"
-                    wide
-                />
-
-                <InputElement
-                    v-show="canUseBatteryDischargeAtNight()"
-                    :label="$t('powerlimiteradmin.BatteryDischargeAtNight')"
-                    v-model="powerLimiterConfigList.battery_always_use_at_night"
-                    type="checkbox"
-                    wide
-                />
-
-                <InputElement
-                    v-show="canUseOverscaling()"
-                    :label="$t('powerlimiteradmin.UseOverscalingToCompensateShading')"
-                    :tooltip="$t('powerlimiteradmin.UseOverscalingToCompensateShadingHint')"
-                    v-model="powerLimiterConfigList.use_overscaling_to_compensate_shading"
-                    type="checkbox"
-                    wide
-                />
-
-                <div class="row mb-3" v-if="needsChannelSelection()">
-                    <label for="inverter_channel" class="col-sm-4 col-form-label">
-                        {{ $t('powerlimiteradmin.InverterChannelId') }}
-                    </label>
-                    <div class="col-sm-8">
-                        <select
-                            id="inverter_channel"
-                            class="form-select"
-                            v-model="powerLimiterConfigList.inverter_channel_id"
-                        >
-                            <option
-                                v-for="channel in range(
-                                    powerLimiterMetaData.inverters[powerLimiterConfigList.inverter_serial].channels
-                                )"
-                                :key="channel"
-                                :value="channel"
-                            >
-                                {{ channel + 1 }}
-                            </option>
-                        </select>
-                    </div>
-                </div>
-
-                <InputElement
-                    :label="$t('powerlimiteradmin.LowerPowerLimit')"
-                    :tooltip="$t('powerlimiteradmin.LowerPowerLimitHint')"
-                    v-model="powerLimiterConfigList.lower_power_limit"
-                    placeholder="50"
-                    min="10"
-                    postfix="W"
-                    type="number"
-                    wide
-                />
-
-                <InputElement
-                    :label="$t('powerlimiteradmin.BaseLoadLimit')"
-                    :tooltip="$t('powerlimiteradmin.BaseLoadLimitHint')"
-                    v-model="powerLimiterConfigList.base_load_limit"
-                    placeholder="200"
-                    :min="(powerLimiterConfigList.lower_power_limit + 1).toString()"
-                    postfix="W"
-                    type="number"
-                    wide
-                />
-
-                <InputElement
-                    :label="$t('powerlimiteradmin.UpperPowerLimit')"
-                    v-model="powerLimiterConfigList.upper_power_limit"
-                    :tooltip="$t('powerlimiteradmin.UpperPowerLimitHint')"
-                    placeholder="800"
-                    :min="(powerLimiterConfigList.base_load_limit + 1).toString()"
-                    postfix="W"
-                    type="number"
-                    wide
-                />
-
-                <InputElement
-                    v-show="hasPowerMeter()"
-                    :label="$t('powerlimiteradmin.InverterIsBehindPowerMeter')"
-                    v-model="powerLimiterConfigList.is_inverter_behind_powermeter"
-                    :tooltip="$t('powerlimiteradmin.InverterIsBehindPowerMeterHint')"
-                    type="checkbox"
-                    wide
-                />
-
-                <div class="row mb-3" v-if="!powerLimiterConfigList.is_inverter_solar_powered">
-                    <label for="inverter_restart" class="col-sm-4 col-form-label">
-                        {{ $t('powerlimiteradmin.InverterRestartHour') }}
-                        <BIconInfoCircle v-tooltip :title="$t('powerlimiteradmin.InverterRestartHint')" />
-                    </label>
-                    <div class="col-sm-8">
-                        <select
-                            id="inverter_restart"
-                            class="form-select"
-                            v-model="powerLimiterConfigList.inverter_restart_hour"
-                        >
-                            <option value="-1">
-                                {{ $t('powerlimiteradmin.InverterRestartDisabled') }}
-                            </option>
-                            <option v-for="hour in range(24)" :key="hour" :value="hour">
-                                {{ hour > 9 ? hour : '0' + hour }}:00
-                            </option>
-                        </select>
-                    </div>
-                </div>
-            </CardElement>
-
-            <CardElement
-                :text="$t('powerlimiteradmin.SolarPassthrough')"
-                textVariant="text-bg-primary"
-                add-space
-                v-if="canUseSolarPassthrough()"
-            >
-                <div
-                    class="alert alert-secondary"
-                    role="alert"
-                    v-html="$t('powerlimiteradmin.SolarpassthroughInfo')"
-                ></div>
-
-                <InputElement
-                    :label="$t('powerlimiteradmin.EnableSolarPassthrough')"
-                    v-model="powerLimiterConfigList.solar_passthrough_enabled"
-                    type="checkbox"
-                    wide
-                />
-
-                <div v-if="powerLimiterConfigList.solar_passthrough_enabled">
+                <template v-if="powerLimiterConfigList.enabled">
                     <InputElement
-                        :label="$t('powerlimiteradmin.SolarPassthroughLosses')"
-                        v-model="powerLimiterConfigList.solar_passthrough_losses"
-                        placeholder="3"
-                        min="0"
-                        max="10"
-                        postfix="%"
+                        v-for="(inv, idx) in powerLimiterConfigList.inverters"
+                        :key="idx"
+                        :label="$t('powerlimiteradmin.GovernInverter', { name: inverterName(inv.serial) })"
+                        v-model="powerLimiterConfigList.inverters[idx].is_governed"
+                        type="checkbox"
+                        wide
+                    />
+                </template>
+
+                <template v-if="isEnabled">
+                    <InputElement
+                        :label="$t('powerlimiteradmin.VerboseLogging')"
+                        v-model="powerLimiterConfigList.verbose_logging"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <InputElement
+                        v-if="hasPowerMeter"
+                        :label="$t('powerlimiteradmin.TargetPowerConsumption')"
+                        :tooltip="$t('powerlimiteradmin.TargetPowerConsumptionHint')"
+                        v-model="powerLimiterConfigList.target_power_consumption"
+                        postfix="W"
                         type="number"
                         wide
                     />
 
+                    <InputElement
+                        :label="$t('powerlimiteradmin.BaseLoadLimit')"
+                        :tooltip="$t('powerlimiteradmin.BaseLoadLimitHint')"
+                        v-model="powerLimiterConfigList.base_load_limit"
+                        placeholder="200"
+                        postfix="W"
+                        type="number"
+                        min="0"
+                        wide
+                    />
+
+                    <InputElement
+                        :label="$t('powerlimiteradmin.TargetPowerConsumptionHysteresis')"
+                        :tooltip="$t('powerlimiteradmin.TargetPowerConsumptionHysteresisHint')"
+                        v-model="powerLimiterConfigList.target_power_consumption_hysteresis"
+                        postfix="W"
+                        type="number"
+                        min="1"
+                        wide
+                    />
+
+                    <InputElement
+                        :label="$t('powerlimiteradmin.TotalUpperPowerLimit')"
+                        :tooltip="$t('powerlimiteradmin.TotalUpperPowerLimitHint')"
+                        v-model="powerLimiterConfigList.total_upper_power_limit"
+                        postfix="W"
+                        type="number"
+                        min="1"
+                        wide
+                    />
+                </template>
+            </CardElement>
+
+            <template v-if="isEnabled">
+                <template v-for="(inv, idx) in powerLimiterConfigList.inverters" :key="idx">
+                    <CardElement
+                        v-if="inv.is_governed"
+                        :text="inverterLabel(inv.serial)"
+                        textVariant="text-bg-primary"
+                        add-space
+                    >
+                        <InputElement
+                            v-if="hasPowerMeter"
+                            :label="$t('powerlimiteradmin.InverterIsBehindPowerMeter')"
+                            v-model="powerLimiterConfigList.inverters[idx].is_behind_power_meter"
+                            :tooltip="$t('powerlimiteradmin.InverterIsBehindPowerMeterHint')"
+                            type="checkbox"
+                            wide
+                        />
+
+                        <InputElement
+                            :label="$t('powerlimiteradmin.InverterIsSolarPowered')"
+                            v-model="powerLimiterConfigList.inverters[idx].is_solar_powered"
+                            type="checkbox"
+                            wide
+                        />
+
+                        <InputElement
+                            v-if="powerLimiterConfigList.inverters[idx].is_solar_powered"
+                            :label="$t('powerlimiteradmin.UseOverscalingToCompensateShading')"
+                            :tooltip="$t('powerlimiteradmin.UseOverscalingToCompensateShadingHint')"
+                            v-model="powerLimiterConfigList.inverters[idx].use_overscaling_to_compensate_shading"
+                            type="checkbox"
+                            wide
+                        />
+
+                        <InputElement
+                            :label="$t('powerlimiteradmin.LowerPowerLimit')"
+                            :tooltip="$t('powerlimiteradmin.LowerPowerLimitHint')"
+                            v-model="powerLimiterConfigList.inverters[idx].lower_power_limit"
+                            postfix="W"
+                            type="number"
+                            wide
+                        />
+
+                        <InputElement
+                            :label="$t('powerlimiteradmin.UpperPowerLimit')"
+                            v-model="powerLimiterConfigList.inverters[idx].upper_power_limit"
+                            :tooltip="$t('powerlimiteradmin.UpperPowerLimitHint')"
+                            postfix="W"
+                            type="number"
+                            wide
+                        />
+                    </CardElement>
+                </template>
+
+                <CardElement
+                    :text="$t('powerlimiteradmin.InverterSettings')"
+                    textVariant="text-bg-primary"
+                    add-space
+                    v-if="governingBatteryPoweredInverters"
+                >
+                    <InputElement
+                        :label="$t('powerlimiteradmin.BatteryDischargeAtNight')"
+                        v-model="powerLimiterConfigList.battery_always_use_at_night"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <div class="row mb-3">
+                        <label for="inverter_serial_for_dc_voltage" class="col-sm-4 col-form-label">
+                            {{ $t('powerlimiteradmin.InverterForDcVoltage') }}
+                        </label>
+                        <div class="col-sm-8">
+                            <select
+                                id="inverter_serial_for_dc_voltage"
+                                class="form-select"
+                                v-model="powerLimiterConfigList.inverter_serial_for_dc_voltage"
+                                required
+                            >
+                                <option value="" disabled hidden selected>
+                                    {{ $t('powerlimiteradmin.SelectInverter') }}
+                                </option>
+                                <option
+                                    v-for="inv in governedBatteryPoweredInverters"
+                                    :key="inv.serial"
+                                    :value="inv.serial"
+                                >
+                                    {{ inverterLabel(inv.serial) }}
+                                </option>
+                            </select>
+                        </div>
+                    </div>
+
+                    <div class="row mb-3" v-if="needsChannelSelection()">
+                        <label for="inverter_channel" class="col-sm-4 col-form-label">
+                            {{ $t('powerlimiteradmin.InverterChannelId') }}
+                        </label>
+                        <div class="col-sm-8">
+                            <select
+                                id="inverter_channel"
+                                class="form-select"
+                                v-model="powerLimiterConfigList.inverter_channel_id_for_dc_voltage"
+                            >
+                                <option
+                                    v-for="channel in range(
+                                        getInverterInfo(powerLimiterConfigList.inverter_serial_for_dc_voltage).channels
+                                    )"
+                                    :key="channel"
+                                    :value="channel"
+                                >
+                                    {{ channel + 1 }}
+                                </option>
+                            </select>
+                        </div>
+                    </div>
+
+                    <div class="row mb-3">
+                        <label for="inverter_restart" class="col-sm-4 col-form-label">
+                            {{ $t('powerlimiteradmin.InverterRestartHour') }}
+                            <BIconInfoCircle v-tooltip :title="$t('powerlimiteradmin.InverterRestartHint')" />
+                        </label>
+                        <div class="col-sm-8">
+                            <select
+                                id="inverter_restart"
+                                class="form-select"
+                                v-model="powerLimiterConfigList.inverter_restart_hour"
+                            >
+                                <option value="-1">
+                                    {{ $t('powerlimiteradmin.InverterRestartDisabled') }}
+                                </option>
+                                <option v-for="hour in range(24)" :key="hour" :value="hour">
+                                    {{ hour > 9 ? hour : '0' + hour }}:00
+                                </option>
+                            </select>
+                        </div>
+                    </div>
+                </CardElement>
+
+                <CardElement
+                    :text="$t('powerlimiteradmin.SolarPassthrough')"
+                    textVariant="text-bg-primary"
+                    add-space
+                    v-if="canUseSolarPassthrough"
+                >
+                    <div
+                        class="alert alert-secondary"
+                        role="alert"
+                        v-html="$t('powerlimiteradmin.SolarpassthroughInfo')"
+                    ></div>
+
+                    <InputElement
+                        :label="$t('powerlimiteradmin.EnableSolarPassthrough')"
+                        v-model="powerLimiterConfigList.solar_passthrough_enabled"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <template v-if="powerLimiterConfigList.solar_passthrough_enabled">
+                        <InputElement
+                            :label="$t('powerlimiteradmin.SolarPassthroughLosses')"
+                            v-model="powerLimiterConfigList.solar_passthrough_losses"
+                            placeholder="3"
+                            min="0"
+                            max="10"
+                            postfix="%"
+                            type="number"
+                            wide
+                        />
+
+                        <div
+                            class="alert alert-secondary"
+                            role="alert"
+                            v-html="$t('powerlimiteradmin.SolarPassthroughLossesInfo')"
+                        ></div>
+                    </template>
+                </CardElement>
+
+                <CardElement
+                    :text="$t('powerlimiteradmin.VoltageThresholds')"
+                    textVariant="text-bg-primary"
+                    add-space
+                    v-if="canUseVoltageThresholds"
+                >
+                    <InputElement
+                        v-if="hasBatteryInterface"
+                        :label="$t('powerlimiteradmin.IgnoreSoc')"
+                        :tooltip="$t('powerlimiteradmin.IgnoreSocHint')"
+                        v-model="powerLimiterConfigList.ignore_soc"
+                        type="checkbox"
+                        wide
+                    />
+
+                    <InputElement
+                        :label="$t('powerlimiteradmin.StartThreshold')"
+                        v-model="powerLimiterConfigList.voltage_start_threshold"
+                        placeholder="50"
+                        min="16"
+                        max="66"
+                        postfix="V"
+                        type="number"
+                        step="0.01"
+                        wide
+                    />
+
+                    <InputElement
+                        :label="$t('powerlimiteradmin.StopThreshold')"
+                        v-model="powerLimiterConfigList.voltage_stop_threshold"
+                        placeholder="49"
+                        min="16"
+                        max="66"
+                        postfix="V"
+                        type="number"
+                        step="0.01"
+                        wide
+                    />
+
+                    <template v-if="isSolarPassthroughEnabled">
+                        <InputElement
+                            :label="$t('powerlimiteradmin.FullSolarPassthroughStartThreshold')"
+                            :tooltip="$t('powerlimiteradmin.FullSolarPassthroughStartThresholdHint')"
+                            v-model="powerLimiterConfigList.full_solar_passthrough_start_voltage"
+                            placeholder="49"
+                            min="16"
+                            max="66"
+                            postfix="V"
+                            type="number"
+                            step="0.01"
+                            wide
+                        />
+
+                        <InputElement
+                            :label="$t('powerlimiteradmin.VoltageSolarPassthroughStopThreshold')"
+                            v-model="powerLimiterConfigList.full_solar_passthrough_stop_voltage"
+                            placeholder="49"
+                            min="16"
+                            max="66"
+                            postfix="V"
+                            type="number"
+                            step="0.01"
+                            wide
+                        />
+                    </template>
+
+                    <InputElement
+                        :label="$t('powerlimiteradmin.VoltageLoadCorrectionFactor')"
+                        v-model="powerLimiterConfigList.voltage_load_correction_factor"
+                        placeholder="0.0001"
+                        postfix="1/A"
+                        type="number"
+                        step="0.0001"
+                        wide
+                    />
+
                     <div
                         class="alert alert-secondary"
                         role="alert"
-                        v-html="$t('powerlimiteradmin.SolarPassthroughLossesInfo')"
-                    ></div>
-                </div>
-            </CardElement>
-
-            <CardElement
-                :text="$t('powerlimiteradmin.SocThresholds')"
-                textVariant="text-bg-primary"
-                add-space
-                v-if="canUseSoCThresholds()"
-            >
-                <InputElement
-                    :label="$t('powerlimiteradmin.IgnoreSoc')"
-                    v-model="powerLimiterConfigList.ignore_soc"
-                    type="checkbox"
-                    wide
-                />
-
-                <div v-if="!powerLimiterConfigList.ignore_soc">
-                    <div
-                        class="alert alert-secondary"
-                        role="alert"
-                        v-html="$t('powerlimiteradmin.BatterySocInfo')"
+                        v-html="$t('powerlimiteradmin.VoltageLoadCorrectionInfo')"
                     ></div>
+                </CardElement>
 
+                <CardElement
+                    :text="$t('powerlimiteradmin.SocThresholds')"
+                    textVariant="text-bg-primary"
+                    add-space
+                    v-if="canUseSoCThresholds"
+                >
                     <InputElement
                         :label="$t('powerlimiteradmin.StartThreshold')"
                         v-model="powerLimiterConfigList.battery_soc_start_threshold"
@@ -294,7 +394,7 @@
                         :label="$t('powerlimiteradmin.FullSolarPassthroughStartThreshold')"
                         :tooltip="$t('powerlimiteradmin.FullSolarPassthroughStartThresholdHint')"
                         v-model="powerLimiterConfigList.full_solar_passthrough_soc"
-                        v-if="isSolarPassthroughEnabled()"
+                        v-if="isSolarPassthroughEnabled"
                         placeholder="80"
                         min="0"
                         max="100"
@@ -302,84 +402,16 @@
                         type="number"
                         wide
                     />
-                </div>
-            </CardElement>
 
-            <CardElement
-                :text="$t('powerlimiteradmin.VoltageThresholds')"
-                textVariant="text-bg-primary"
-                add-space
-                v-if="canUseVoltageThresholds()"
-            >
-                <InputElement
-                    :label="$t('powerlimiteradmin.StartThreshold')"
-                    v-model="powerLimiterConfigList.voltage_start_threshold"
-                    placeholder="50"
-                    min="16"
-                    max="66"
-                    postfix="V"
-                    type="number"
-                    step="0.01"
-                    wide
-                />
+                    <div
+                        class="alert alert-secondary"
+                        role="alert"
+                        v-html="$t('powerlimiteradmin.BatterySocInfo')"
+                    ></div>
+                </CardElement>
+            </template>
 
-                <InputElement
-                    :label="$t('powerlimiteradmin.StopThreshold')"
-                    v-model="powerLimiterConfigList.voltage_stop_threshold"
-                    placeholder="49"
-                    min="16"
-                    max="66"
-                    postfix="V"
-                    type="number"
-                    step="0.01"
-                    wide
-                />
-
-                <div v-if="isSolarPassthroughEnabled()">
-                    <InputElement
-                        :label="$t('powerlimiteradmin.FullSolarPassthroughStartThreshold')"
-                        :tooltip="$t('powerlimiteradmin.FullSolarPassthroughStartThresholdHint')"
-                        v-model="powerLimiterConfigList.full_solar_passthrough_start_voltage"
-                        placeholder="49"
-                        min="16"
-                        max="66"
-                        postfix="V"
-                        type="number"
-                        step="0.01"
-                        wide
-                    />
-
-                    <InputElement
-                        :label="$t('powerlimiteradmin.VoltageSolarPassthroughStopThreshold')"
-                        v-model="powerLimiterConfigList.full_solar_passthrough_stop_voltage"
-                        placeholder="49"
-                        min="16"
-                        max="66"
-                        postfix="V"
-                        type="number"
-                        step="0.01"
-                        wide
-                    />
-                </div>
-
-                <InputElement
-                    :label="$t('powerlimiteradmin.VoltageLoadCorrectionFactor')"
-                    v-model="powerLimiterConfigList.voltage_load_correction_factor"
-                    placeholder="0.0001"
-                    postfix="1/A"
-                    type="number"
-                    step="0.0001"
-                    wide
-                />
-
-                <div
-                    class="alert alert-secondary"
-                    role="alert"
-                    v-html="$t('powerlimiteradmin.VoltageLoadCorrectionInfo')"
-                ></div>
-            </CardElement>
-
-            <FormFooter @reload="getAllData" />
+            <FormFooter @reload="getMetaData" />
         </form>
     </BasePage>
 </template>
@@ -393,7 +425,12 @@ import CardElement from '@/components/CardElement.vue';
 import FormFooter from '@/components/FormFooter.vue';
 import InputElement from '@/components/InputElement.vue';
 import { BIconInfoCircle } from 'bootstrap-icons-vue';
-import type { PowerLimiterConfig, PowerLimiterMetaData } from '@/types/PowerLimiterConfig';
+import type {
+    PowerLimiterConfig,
+    PowerLimiterInverterConfig,
+    PowerLimiterMetaData,
+    PowerLimiterInverterInfo,
+} from '@/types/PowerLimiterConfig';
 
 export default defineComponent({
     components: {
@@ -416,42 +453,70 @@ export default defineComponent({
         };
     },
     created() {
-        this.getAllData();
+        this.getMetaData();
     },
     watch: {
-        'powerLimiterConfigList.inverter_serial'(newVal) {
+        governedInverters() {
+            if (
+                !this.governedInverters.some(
+                    (inv: PowerLimiterInverterConfig) =>
+                        inv.serial == this.powerLimiterConfigList.inverter_serial_for_dc_voltage
+                )
+            ) {
+                // marks serial as invalid, selects placeholder option
+                this.powerLimiterConfigList.inverter_serial_for_dc_voltage = '';
+            }
+        },
+    },
+    computed: {
+        governedInverters(): PowerLimiterInverterConfig[] {
+            const inverters = this.powerLimiterConfigList?.inverters || [];
+            return inverters.filter((inv: PowerLimiterInverterConfig) => inv.is_governed) || [];
+        },
+        governedBatteryPoweredInverters(): PowerLimiterInverterConfig[] {
+            return this.governedInverters.filter((inv: PowerLimiterInverterConfig) => !inv.is_solar_powered);
+        },
+        governingBatteryPoweredInverters(): boolean {
+            return this.governedBatteryPoweredInverters.length > 0;
+        },
+        isEnabled(): boolean {
+            const cfg = this.powerLimiterConfigList;
+            return cfg.enabled && this.governedInverters.length > 0;
+        },
+        isSolarPassthroughEnabled(): boolean {
+            return (
+                this.powerLimiterMetaData.charge_controller_enabled &&
+                this.powerLimiterConfigList.solar_passthrough_enabled
+            );
+        },
+        hasPowerMeter(): boolean {
+            return this.powerLimiterMetaData.power_meter_enabled;
+        },
+        canUseSolarPassthrough(): boolean {
+            const meta = this.powerLimiterMetaData;
+            return meta.charge_controller_enabled && this.governingBatteryPoweredInverters;
+        },
+        canUseVoltageThresholds(): boolean {
+            return this.governingBatteryPoweredInverters;
+        },
+        canUseSoCThresholds(): boolean {
             const cfg = this.powerLimiterConfigList;
             const meta = this.powerLimiterMetaData;
-
-            if (newVal === '') {
-                return;
-            } // do not try to convert the placeholder value
-
-            if (meta.inverters[newVal] !== undefined) {
-                return;
-            }
-
-            for (const [serial, inverter] of Object.entries(meta.inverters)) {
-                // cfg.inverter_serial might be too large to parse as a 32 bit
-                // int, so we make sure to only try to parse two characters. if
-                // cfg.inverter_serial is indeed an old position based index,
-                // it is only one character.
-                if (inverter.pos == Number(cfg.inverter_serial.substr(0, 2))) {
-                    // inverter_serial uses the old position-based
-                    // value to identify the inverter. convert to serial.
-                    cfg.inverter_serial = serial;
-                    return;
-                }
-            }
-
-            // previously selected inverter was deleted. marks serial as
-            // invalid, selects placeholder option.
-            cfg.inverter_serial = '';
+            return meta.battery_enabled && this.governingBatteryPoweredInverters && !cfg.ignore_soc;
+        },
+        hasBatteryInterface(): boolean {
+            const meta = this.powerLimiterMetaData;
+            return meta.battery_enabled && this.governingBatteryPoweredInverters;
         },
     },
     methods: {
-        getConfigHints() {
-            const cfg = this.powerLimiterConfigList;
+        getInverterInfo(serial: string): PowerLimiterInverterInfo {
+            return (
+                this.powerLimiterMetaData.inverters?.find((inv: PowerLimiterInverterInfo) => inv.serial === serial) ||
+                ({} as PowerLimiterInverterInfo)
+            );
+        },
+        getConfigHints(): { severity: string; subject: string }[] {
             const meta = this.powerLimiterMetaData;
             const hints = [];
 
@@ -459,20 +524,26 @@ export default defineComponent({
                 hints.push({ severity: 'optional', subject: 'PowerMeterDisabled' });
             }
 
-            if (typeof meta.inverters === 'undefined' || Object.keys(meta.inverters).length == 0) {
+            if (typeof meta.inverters === 'undefined' || meta.inverters.length == 0) {
                 hints.push({ severity: 'requirement', subject: 'NoInverter' });
                 this.configAlert = true;
             } else {
-                const inv = meta.inverters[cfg.inverter_serial];
-                if (
-                    inv !== undefined &&
-                    !(inv.poll_enable && inv.command_enable && inv.poll_enable_night && inv.command_enable_night)
-                ) {
-                    hints.push({ severity: 'requirement', subject: 'InverterCommunication' });
+                for (const inv of this.powerLimiterMetaData.inverters) {
+                    if (
+                        !this.powerLimiterConfigList.inverters.some(
+                            (i: PowerLimiterInverterConfig) => i.serial == inv.serial
+                        )
+                    ) {
+                        continue;
+                    }
+                    if (!(inv.poll_enable && inv.command_enable && inv.poll_enable_night && inv.command_enable_night)) {
+                        hints.push({ severity: 'requirement', subject: 'InverterCommunication' });
+                        break;
+                    }
                 }
             }
 
-            if (!cfg.is_inverter_solar_powered) {
+            if (this.governingBatteryPoweredInverters) {
                 if (!meta.charge_controller_enabled) {
                     hints.push({ severity: 'optional', subject: 'NoChargeController' });
                 }
@@ -484,82 +555,110 @@ export default defineComponent({
 
             return hints;
         },
-        isEnabled() {
-            return this.powerLimiterConfigList.enabled;
-        },
-        hasPowerMeter() {
-            return this.powerLimiterMetaData.power_meter_enabled;
-        },
-        canUseOverscaling() {
-            const cfg = this.powerLimiterConfigList;
-            return cfg.is_inverter_solar_powered;
-        },
-        canUseBatteryDischargeAtNight() {
-            const cfg = this.powerLimiterConfigList;
-            return !cfg.is_inverter_solar_powered;
-        },
-        canUseSolarPassthrough() {
-            const cfg = this.powerLimiterConfigList;
-            const meta = this.powerLimiterMetaData;
-            return this.isEnabled() && meta.charge_controller_enabled && !cfg.is_inverter_solar_powered;
-        },
-        canUseSoCThresholds() {
-            const cfg = this.powerLimiterConfigList;
-            const meta = this.powerLimiterMetaData;
-            return this.isEnabled() && meta.battery_enabled && !cfg.is_inverter_solar_powered;
-        },
-        canUseVoltageThresholds() {
-            const cfg = this.powerLimiterConfigList;
-            return this.isEnabled() && !cfg.is_inverter_solar_powered;
-        },
-        isSolarPassthroughEnabled() {
-            return this.powerLimiterConfigList.solar_passthrough_enabled;
-        },
         range(end: number) {
             return Array.from(Array(end).keys());
         },
+        inverterName(serial: string) {
+            if (serial === undefined) {
+                return 'undefined';
+            }
+            const meta = this.powerLimiterMetaData;
+            if (meta === undefined) {
+                return 'metadata pending';
+            }
+            const inv = this.getInverterInfo(serial);
+            if (inv === undefined) {
+                return 'not found';
+            }
+            return inv.name;
+        },
+        inverterLabel(serial: string) {
+            if (serial === undefined) {
+                return 'undefined';
+            }
+            const meta = this.powerLimiterMetaData;
+            if (meta === undefined) {
+                return 'metadata pending';
+            }
+            const inv = this.getInverterInfo(serial);
+            if (inv === undefined) {
+                return 'not found';
+            }
+            return inv.name + ' (' + inv.type + ')';
+        },
         needsChannelSelection() {
             const cfg = this.powerLimiterConfigList;
-            const meta = this.powerLimiterMetaData;
 
             const reset = function () {
-                cfg.inverter_channel_id = 0;
+                cfg.inverter_channel_id_for_dc_voltage = 0;
                 return false;
             };
 
-            if (cfg.inverter_serial === '') {
+            if (!this.governingBatteryPoweredInverters) {
                 return reset();
             }
 
-            if (cfg.is_inverter_solar_powered) {
+            if (cfg.inverter_serial_for_dc_voltage === '') {
                 return reset();
             }
 
-            const inverter = meta.inverters[cfg.inverter_serial];
-            if (inverter === undefined) {
-                return reset();
-            }
-
-            if (cfg.inverter_channel_id >= inverter.channels) {
-                reset();
+            const inverter = this.getInverterInfo(cfg.inverter_serial_for_dc_voltage);
+            if (cfg.inverter_channel_id_for_dc_voltage >= inverter.channels) {
+                cfg.inverter_channel_id_for_dc_voltage = 0;
             }
 
             return inverter.channels > 1;
         },
-        getAllData() {
+        getMetaData() {
             this.dataLoading = true;
             fetch('/api/powerlimiter/metadata', { headers: authHeader() })
                 .then((response) => handleResponse(response, this.$emitter, this.$router))
                 .then((data) => {
                     this.powerLimiterMetaData = data;
-                    fetch('/api/powerlimiter/config', { headers: authHeader() })
-                        .then((response) => handleResponse(response, this.$emitter, this.$router))
-                        .then((data) => {
-                            this.powerLimiterConfigList = data;
-                            this.dataLoading = false;
-                        });
+                    this.getConfigData();
                 });
         },
+        getConfigData() {
+            fetch('/api/powerlimiter/config', { headers: authHeader() })
+                .then((response) => handleResponse(response, this.$emitter, this.$router))
+                .then((data) => {
+                    data.inverters = this.tidyUpInverterConfigs(data.inverters);
+                    this.powerLimiterConfigList = data;
+                    this.dataLoading = false;
+                });
+        },
+        tidyUpInverterConfigs(inverters: PowerLimiterInverterConfig[]): PowerLimiterInverterConfig[] {
+            const metaInverters = this.powerLimiterMetaData?.inverters || [];
+
+            // remove power limiter inverter config if no such inverter exists
+            inverters = inverters.filter((cfgInv: PowerLimiterInverterConfig) =>
+                metaInverters.some((metaInv) => metaInv.serial === cfgInv.serial)
+            );
+
+            // add default power limiter inverter config for new inverters
+            for (const metaInv of metaInverters) {
+                const known = inverters.some((cfgInv: PowerLimiterInverterConfig) => cfgInv.serial === metaInv.serial);
+                if (known) {
+                    continue;
+                }
+
+                const newInv = {} as PowerLimiterInverterConfig;
+                newInv.serial = metaInv.serial;
+                newInv.is_governed = false;
+                newInv.is_behind_power_meter = true;
+                newInv.lower_power_limit = 10 * metaInv.channels;
+                newInv.upper_power_limit = Math.max(metaInv.max_power, 300);
+                inverters.push(newInv);
+            }
+
+            inverters = inverters.sort((a, b) => {
+                const orderA = this.getInverterInfo(a.serial).order;
+                const orderB = this.getInverterInfo(b.serial).order;
+                return orderA < orderB ? -1 : 1;
+            });
+
+            return inverters;
+        },
         savePowerLimiterConfig(e: Event) {
             e.preventDefault();
 
@@ -576,6 +675,7 @@ export default defineComponent({
                     this.alertMessage = response.message;
                     this.alertType = response.type;
                     this.showAlert = true;
+                    window.scrollTo(0, 0);
                 });
         },
     },
diff --git a/webapp/src/views/PowerMeterAdminView.vue b/webapp/src/views/PowerMeterAdminView.vue
index c0a9514c..55479156 100644
--- a/webapp/src/views/PowerMeterAdminView.vue
+++ b/webapp/src/views/PowerMeterAdminView.vue
@@ -13,30 +13,35 @@
                     wide
                 />
 
-                <InputElement
-                    v-show="powerMeterConfigList.enabled"
-                    :label="$t('powermeteradmin.VerboseLogging')"
-                    v-model="powerMeterConfigList.verbose_logging"
-                    type="checkbox"
-                    wide
-                />
+                <template v-if="powerMeterConfigList.enabled">
+                    <InputElement
+                        :label="$t('powermeteradmin.VerboseLogging')"
+                        v-model="powerMeterConfigList.verbose_logging"
+                        type="checkbox"
+                        wide
+                    />
 
-                <div class="row mb-3" v-show="powerMeterConfigList.enabled">
-                    <label for="inputPowerMeterSource" class="col-sm-4 col-form-label">{{
-                        $t('powermeteradmin.PowerMeterSource')
-                    }}</label>
-                    <div class="col-sm-8">
-                        <select id="inputPowerMeterSource" class="form-select" v-model="powerMeterConfigList.source">
-                            <option v-for="source in powerMeterSourceList" :key="source.key" :value="source.key">
-                                {{ source.value }}
-                            </option>
-                        </select>
+                    <div class="row mb-3">
+                        <label for="inputPowerMeterSource" class="col-sm-4 col-form-label">{{
+                            $t('powermeteradmin.PowerMeterSource')
+                        }}</label>
+                        <div class="col-sm-8">
+                            <select
+                                id="inputPowerMeterSource"
+                                class="form-select"
+                                v-model="powerMeterConfigList.source"
+                            >
+                                <option v-for="source in powerMeterSourceList" :key="source.key" :value="source.key">
+                                    {{ source.value }}
+                                </option>
+                            </select>
+                        </div>
                     </div>
-                </div>
+                </template>
             </CardElement>
 
-            <div v-if="powerMeterConfigList.enabled">
-                <div v-if="powerMeterConfigList.source === 0 || powerMeterConfigList.source === 3">
+            <template v-if="powerMeterConfigList.enabled">
+                <template v-if="powerMeterConfigList.source === 0 || powerMeterConfigList.source === 3">
                     <div class="alert alert-secondary mt-5" role="alert">
                         <h2>{{ $t('powermeteradmin.jsonPathExamplesHeading') }}:</h2>
                         {{ $t('powermeteradmin.jsonPathExamplesExplanation') }}
@@ -58,10 +63,10 @@
                             <li><code>total</code> &mdash; <code>{ "othervalue": 66, "total": 123.4 }</code></li>
                         </ul>
                     </div>
-                </div>
+                </template>
 
                 <!-- yarn linter wants us to not combine v-if with v-for, so we need to wrap the CardElements //-->
-                <div v-if="powerMeterConfigList.source === 0">
+                <template v-if="powerMeterConfigList.source === 0">
                     <CardElement
                         v-for="(mqtt, index) in powerMeterConfigList.mqtt.values"
                         v-bind:key="index"
@@ -107,7 +112,7 @@
                             wide
                         />
                     </CardElement>
-                </div>
+                </template>
 
                 <CardElement
                     v-if="powerMeterConfigList.source === 1 || powerMeterConfigList.source === 2"
@@ -133,7 +138,7 @@
                     />
                 </CardElement>
 
-                <div v-if="powerMeterConfigList.source === 3">
+                <template v-if="powerMeterConfigList.source === 3">
                     <div class="alert alert-secondary mt-5" role="alert">
                         <h2>{{ $t('powermeteradmin.urlExamplesHeading') }}:</h2>
                         <ul>
@@ -178,7 +183,7 @@
                             wide
                         />
 
-                        <div v-if="httpJson.enabled || index == 0">
+                        <template v-if="httpJson.enabled || index == 0">
                             <HttpRequestSettings
                                 v-model="httpJson.http_request"
                                 v-if="index == 0 || powerMeterConfigList.http_json.individual_requests"
@@ -213,7 +218,7 @@
                                 type="checkbox"
                                 wide
                             />
-                        </div>
+                        </template>
                     </CardElement>
 
                     <CardElement
@@ -221,7 +226,7 @@
                         textVariant="text-bg-primary"
                         add-space
                     >
-                        <div class="text-center mt-3 mb-3">
+                        <div class="text-center mb-3">
                             <button type="button" class="btn btn-primary" @click="testHttpJsonRequest()">
                                 {{ $t('powermeteradmin.testHttpJsonRequest') }}
                             </button>
@@ -235,9 +240,9 @@
                             {{ testHttpJsonRequestAlert.message }}
                         </BootstrapAlert>
                     </CardElement>
-                </div>
+                </template>
 
-                <div v-if="powerMeterConfigList.source === 6">
+                <template v-if="powerMeterConfigList.source === 6">
                     <CardElement :text="$t('powermeteradmin.HTTP_SML')" textVariant="text-bg-primary" add-space>
                         <InputElement
                             :label="$t('powermeteradmin.pollingInterval')"
@@ -257,7 +262,7 @@
                         textVariant="text-bg-primary"
                         add-space
                     >
-                        <div class="text-center mt-3 mb-3">
+                        <div class="text-center mb-3">
                             <button type="button" class="btn btn-primary" @click="testHttpSmlRequest()">
                                 {{ $t('powermeteradmin.testHttpSmlRequest') }}
                             </button>
@@ -271,8 +276,8 @@
                             {{ testHttpSmlRequestAlert.message }}
                         </BootstrapAlert>
                     </CardElement>
-                </div>
-            </div>
+                </template>
+            </template>
 
             <FormFooter @reload="getPowerMeterConfig" />
         </form>
diff --git a/webapp/src/views/VedirectInfoView.vue b/webapp/src/views/VedirectInfoView.vue
index 0a1fdd8c..aff6da75 100644
--- a/webapp/src/views/VedirectInfoView.vue
+++ b/webapp/src/views/VedirectInfoView.vue
@@ -1,6 +1,6 @@
 <template>
     <BasePage :title="$t('vedirectinfo.VedirectInformation')" :isLoading="dataLoading">
-        <CardElement :text="$t('vedirectinfo.ConfigurationSummary')" textVariant="text-bg-primary">
+        <CardElement :text="$t('vedirectinfo.ConfigurationSummary')" textVariant="text-bg-primary" table>
             <div class="table-responsive">
                 <table class="table table-hover table-condensed">
                     <tbody>
diff --git a/webapp/src/views/WaitRestartView.vue b/webapp/src/views/WaitRestartView.vue
new file mode 100644
index 00000000..5c9aa52c
--- /dev/null
+++ b/webapp/src/views/WaitRestartView.vue
@@ -0,0 +1,64 @@
+<template>
+    <BasePage :title="$t('wait.NotReady')">
+        <CardElement :text="$t('wait.PleaseWait')" textVariant="text-bg-primary">
+            <div class="text-center">
+                <div class="spinner-border" role="status">
+                    <span class="visually-hidden"></span>
+                </div>
+            </div>
+        </CardElement>
+    </BasePage>
+</template>
+
+<script lang="ts">
+import BasePage from '@/components/BasePage.vue';
+import CardElement from '@/components/CardElement.vue';
+import { authHeader } from '@/utils/authentication';
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+    components: {
+        BasePage,
+        CardElement,
+    },
+    data() {
+        return {
+            hostCheckInterval: 0,
+        };
+    },
+    mounted() {
+        this.hostCheckInterval = setInterval(this.checkRemoteHostAndReload, 1000);
+    },
+    unmounted() {
+        clearInterval(this.hostCheckInterval);
+    },
+    methods: {
+        checkRemoteHostAndReload(): void {
+            // Check if the browser is online
+            if (navigator.onLine) {
+                const remoteHostUrl = '/api/system/status';
+
+                // Use a simple fetch request to check if the remote host is reachable
+                fetch(remoteHostUrl, { headers: authHeader() })
+                    .then((response) => {
+                        // Check if the response status is OK (200-299 range)
+                        if (response.ok) {
+                            console.log('Remote host is available. Reloading page...');
+                            clearInterval(this.hostCheckInterval);
+                            this.hostCheckInterval = 0;
+                            // Perform a page reload
+                            window.location.replace('/');
+                        } else {
+                            console.log('Remote host is not reachable. Do something else if needed.');
+                        }
+                    })
+                    .catch((error) => {
+                        console.error('Error checking remote host:', error);
+                    });
+            } else {
+                console.log('Browser is offline. Cannot check remote host.');
+            }
+        },
+    },
+});
+</script>
diff --git a/webapp/vite.config.ts b/webapp/vite.config.ts
index b898ee97..545236a0 100644
--- a/webapp/vite.config.ts
+++ b/webapp/vite.config.ts
@@ -19,7 +19,7 @@ try {
 }
 
 // https://vitejs.dev/config/
-export default defineConfig({
+export default defineConfig(({ command }) => { return {
   plugins: [
     vue(),
     viteCompression({ deleteOriginFile: true, threshold: 0 }),
@@ -27,6 +27,7 @@ export default defineConfig({
     VueI18nPlugin({
         /* options */
         include: path.resolve(path.dirname(fileURLToPath(import.meta.url)), './src/locales/**.json'),
+        runtimeOnly: false,
         fullInstall: false,
         forceStringify: true,
         strictMessage: false,
@@ -55,9 +56,10 @@ export default defineConfig({
         assetFileNames: "assets/[name].[ext]",
       },
     },
+    target: 'es2022',
   },
   esbuild: {
-    drop: ['console', 'debugger'],
+    drop: command !== 'serve' ? ['console', 'debugger'] : []
   },
   server: {
     proxy: {
@@ -86,4 +88,4 @@ export default defineConfig({
       }
     }
   }
-})
+} })
diff --git a/webapp/yarn.lock b/webapp/yarn.lock
index 73d29745..59f19e74 100644
--- a/webapp/yarn.lock
+++ b/webapp/yarn.lock
@@ -150,11 +150,16 @@
   dependencies:
     eslint-visitor-keys "^3.3.0"
 
-"@eslint-community/regexpp@^4.10.0", "@eslint-community/regexpp@^4.11.0":
+"@eslint-community/regexpp@^4.10.0":
   version "4.11.1"
   resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.11.1.tgz#a547badfc719eb3e5f4b556325e542fbe9d7a18f"
   integrity sha512-m4DVN9ZqskZoLU5GlWZadwDnYo3vAEydiUayB9widCl9ffWx2IvPnp6n3on5rJmziJSw9Bv+Z3ChDVdMwXCY8Q==
 
+"@eslint-community/regexpp@^4.12.1":
+  version "4.12.1"
+  resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.12.1.tgz#cfc6cffe39df390a3841cde2abccf92eaa7ae0e0"
+  integrity sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==
+
 "@eslint/config-array@^0.18.0":
   version "0.18.0"
   resolved "https://registry.yarnpkg.com/@eslint/config-array/-/config-array-0.18.0.tgz#37d8fe656e0d5e3dbaea7758ea56540867fd074d"
@@ -164,10 +169,10 @@
     debug "^4.3.1"
     minimatch "^3.1.2"
 
-"@eslint/core@^0.6.0":
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/@eslint/core/-/core-0.6.0.tgz#9930b5ba24c406d67a1760e94cdbac616a6eb674"
-  integrity sha512-8I2Q8ykA4J0x0o7cg67FPVnehcqWTBehu/lmY+bolPFHGjh49YzGBMXTvpqVgEbBdvNCSxj6iFgiIyHzf03lzg==
+"@eslint/core@^0.7.0":
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/@eslint/core/-/core-0.7.0.tgz#a1bb4b6a4e742a5ff1894b7ee76fbf884ec72bd3"
+  integrity sha512-xp5Jirz5DyPYlPiKat8jaq0EmYvDXKKpzTbxXMpT9eqlRJkRKIz9AGMdlvYjih+im+QlhWrpvVjl8IPC/lHlUw==
 
 "@eslint/eslintrc@^3.1.0":
   version "3.1.0"
@@ -184,10 +189,10 @@
     minimatch "^3.1.2"
     strip-json-comments "^3.1.1"
 
-"@eslint/js@9.12.0":
-  version "9.12.0"
-  resolved "https://registry.yarnpkg.com/@eslint/js/-/js-9.12.0.tgz#69ca3ca9fab9a808ec6d67b8f6edb156cbac91e1"
-  integrity sha512-eohesHH8WFRUprDNyEREgqP6beG6htMeUYeCpkEgBCieCMme5r9zFWjzAJp//9S+Kub4rqE+jXe9Cp1a7IYIIA==
+"@eslint/js@9.14.0":
+  version "9.14.0"
+  resolved "https://registry.yarnpkg.com/@eslint/js/-/js-9.14.0.tgz#2347a871042ebd11a00fd8c2d3d56a265ee6857e"
+  integrity sha512-pFoEtFWCPyDOl+C6Ift+wC7Ro89otjigCf5vcuWqWgqNSQbRrpjSvdeE6ofLz4dHmyxD5f7gIdGT4+p36L6Twg==
 
 "@eslint/object-schema@^2.1.4":
   version "2.1.4"
@@ -201,17 +206,17 @@
   dependencies:
     levn "^0.4.1"
 
-"@humanfs/core@^0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@humanfs/core/-/core-0.19.0.tgz#08db7a8c73bb07673d9ebd925f2dad746411fcec"
-  integrity sha512-2cbWIHbZVEweE853g8jymffCA+NCMiuqeECeBBLm8dg2oFdjuGJhgN4UAbI+6v0CKbbhvtXA4qV8YR5Ji86nmw==
+"@humanfs/core@^0.19.1":
+  version "0.19.1"
+  resolved "https://registry.yarnpkg.com/@humanfs/core/-/core-0.19.1.tgz#17c55ca7d426733fe3c561906b8173c336b40a77"
+  integrity sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==
 
-"@humanfs/node@^0.16.5":
-  version "0.16.5"
-  resolved "https://registry.yarnpkg.com/@humanfs/node/-/node-0.16.5.tgz#a9febb7e7ad2aff65890fdc630938f8d20aa84ba"
-  integrity sha512-KSPA4umqSG4LHYRodq31VDwKAvaTF4xmVlzM8Aeh4PlU1JQ3IG0wiA8C25d3RQ9nJyM3mBHyI53K06VVL/oFFg==
+"@humanfs/node@^0.16.6":
+  version "0.16.6"
+  resolved "https://registry.yarnpkg.com/@humanfs/node/-/node-0.16.6.tgz#ee2a10eaabd1131987bf0488fd9b820174cd765e"
+  integrity sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==
   dependencies:
-    "@humanfs/core" "^0.19.0"
+    "@humanfs/core" "^0.19.1"
     "@humanwhocodes/retry" "^0.3.0"
 
 "@humanwhocodes/module-importer@^1.0.1":
@@ -219,11 +224,16 @@
   resolved "https://registry.yarnpkg.com/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c"
   integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
 
-"@humanwhocodes/retry@^0.3.0", "@humanwhocodes/retry@^0.3.1":
+"@humanwhocodes/retry@^0.3.0":
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/@humanwhocodes/retry/-/retry-0.3.1.tgz#c72a5c76a9fbaf3488e231b13dc52c0da7bab42a"
   integrity sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==
 
+"@humanwhocodes/retry@^0.4.0":
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/retry/-/retry-0.4.0.tgz#b57438cab2a2381b4b597b0ab17339be381bd755"
+  integrity sha512-xnRgu9DxZbkWak/te3fcytNyp8MTbuiZIaueg2rgEvBuN55n04nwLYLU9TX/VVlusc9L2ZNXi99nUFNkHXtr5g==
+
 "@intlify/bundle-utils@^9.0.0-beta.0":
   version "9.0.0-beta.0"
   resolved "https://registry.yarnpkg.com/@intlify/bundle-utils/-/bundle-utils-9.0.0-beta.0.tgz#1413cf4dc8647e887a39b0b4fd7059dfbbe5af7e"
@@ -482,12 +492,12 @@
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841"
   integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==
 
-"@types/node@^22.7.4":
-  version "22.7.5"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-22.7.5.tgz#cfde981727a7ab3611a481510b473ae54442b92b"
-  integrity sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==
+"@types/node@^22.9.0":
+  version "22.9.0"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-22.9.0.tgz#b7f16e5c3384788542c72dc3d561a7ceae2c0365"
+  integrity sha512-vuyHg81vvWA1Z1ELfvLko2c8f34gyA0zaic0+Rllc5lbCnbSyuvb2Oxpm6TAUAC/2xZN3QGqxBNggD1nNR2AfQ==
   dependencies:
-    undici-types "~6.19.2"
+    undici-types "~6.19.8"
 
 "@types/pulltorefreshjs@^0.1.7":
   version "0.1.7"
@@ -499,10 +509,10 @@
   resolved "https://registry.yarnpkg.com/@types/sortablejs/-/sortablejs-1.15.8.tgz#11ed555076046e00869a5ef85d1e7651e7a66ef6"
   integrity sha512-b79830lW+RZfwaztgs1aVPgbasJ8e7AXtZYHTELNXZPsERt4ymJdjV4OccDbHQAvHrCcFpbF78jkm0R6h/pZVg==
 
-"@types/spark-md5@^3.0.4":
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/@types/spark-md5/-/spark-md5-3.0.4.tgz#c1221d63c069d95aba0c06a765b80661cacc12bf"
-  integrity sha512-qtOaDz+IXiNndPgYb6t1YoutnGvFRtWSNzpVjkAPCfB2UzTyybuD4Tjgs7VgRawum3JnJNRwNQd4N//SvrHg1Q==
+"@types/spark-md5@^3.0.5":
+  version "3.0.5"
+  resolved "https://registry.yarnpkg.com/@types/spark-md5/-/spark-md5-3.0.5.tgz#eddec8639217e518c26e9e221ff56bf5f5f5c900"
+  integrity sha512-lWf05dnD42DLVKQJZrDHtWFidcLrHuip01CtnC2/S6AMhX4t9ZlEUj4iuRlAnts0PQk7KESOqKxeGE/b6sIPGg==
 
 "@typescript-eslint/eslint-plugin@8.8.1", "@typescript-eslint/eslint-plugin@^8.8.1":
   version "8.8.1"
@@ -625,24 +635,24 @@
   resolved "https://registry.yarnpkg.com/@vitejs/plugin-vue/-/plugin-vue-5.1.4.tgz#72b8b705cfce36b00b59af196195146e356500c4"
   integrity sha512-N2XSI2n3sQqp5w7Y/AN/L2XDjBIRGqXko+eDp42sydYSBeJuSm5a1sLf8zakmo8u7tA8NmBgoDLA1HeOESjp9A==
 
-"@volar/language-core@2.4.6", "@volar/language-core@~2.4.1":
-  version "2.4.6"
-  resolved "https://registry.yarnpkg.com/@volar/language-core/-/language-core-2.4.6.tgz#159625a6e1263fe68d1afad524ae2bd40c4ee0dd"
-  integrity sha512-FxUfxaB8sCqvY46YjyAAV6c3mMIq/NWQMVvJ+uS4yxr1KzOvyg61gAuOnNvgCvO4TZ7HcLExBEsWcDu4+K4E8A==
+"@volar/language-core@2.4.8", "@volar/language-core@~2.4.8":
+  version "2.4.8"
+  resolved "https://registry.yarnpkg.com/@volar/language-core/-/language-core-2.4.8.tgz#022f9a8f8c0615469d2f8290f9b44528807c99ca"
+  integrity sha512-K/GxMOXGq997bO00cdFhTNuR85xPxj0BEEAy+BaqqayTmy9Tmhfgmq2wpJcVspRhcwfgPoE2/mEJa26emUhG/g==
   dependencies:
-    "@volar/source-map" "2.4.6"
+    "@volar/source-map" "2.4.8"
 
-"@volar/source-map@2.4.6":
-  version "2.4.6"
-  resolved "https://registry.yarnpkg.com/@volar/source-map/-/source-map-2.4.6.tgz#b71ad241216f646812639f359262e6a84b46b6ed"
-  integrity sha512-Nsh7UW2ruK+uURIPzjJgF0YRGP5CX9nQHypA2OMqdM2FKy7rh+uv3XgPnWPw30JADbKvZ5HuBzG4gSbVDYVtiw==
+"@volar/source-map@2.4.8":
+  version "2.4.8"
+  resolved "https://registry.yarnpkg.com/@volar/source-map/-/source-map-2.4.8.tgz#bc699a095aaab405ddc0e2c5a011edc151e787fd"
+  integrity sha512-jeWJBkC/WivdelMwxKkpFL811uH/jJ1kVxa+c7OvG48DXc3VrP7pplSWPP2W1dLMqBxD+awRlg55FQQfiup4cA==
 
-"@volar/typescript@~2.4.1":
-  version "2.4.6"
-  resolved "https://registry.yarnpkg.com/@volar/typescript/-/typescript-2.4.6.tgz#6a4611b9fae793ad0d4c66d11d765f2731d93a12"
-  integrity sha512-NMIrA7y5OOqddL9VtngPWYmdQU03htNKFtAYidbYfWA0TOhyGVd9tfcP4TsLWQ+RBWDZCbBqsr8xzU0ZOxYTCQ==
+"@volar/typescript@~2.4.8":
+  version "2.4.8"
+  resolved "https://registry.yarnpkg.com/@volar/typescript/-/typescript-2.4.8.tgz#4cfb90b3226e04d781d48fa519fed0838d7b1504"
+  integrity sha512-6xkIYJ5xxghVBhVywMoPMidDDAFT1OoQeXwa27HSgJ6AiIKRe61RXLoik+14Z7r0JvnblXVsjsRLmCr42SGzqg==
   dependencies:
-    "@volar/language-core" "2.4.6"
+    "@volar/language-core" "2.4.8"
     path-browserify "^1.0.1"
     vscode-uri "^3.0.8"
 
@@ -668,7 +678,7 @@
     estree-walker "^2.0.2"
     source-map-js "^1.2.0"
 
-"@vue/compiler-dom@3.5.11", "@vue/compiler-dom@^3.2.45", "@vue/compiler-dom@^3.4.0":
+"@vue/compiler-dom@3.5.11", "@vue/compiler-dom@^3.2.45":
   version "3.5.11"
   resolved "https://registry.yarnpkg.com/@vue/compiler-dom/-/compiler-dom-3.5.11.tgz#950f8fc610e26326fed008b8d102cc8ee78a6ce5"
   integrity sha512-pyGf8zdbDDRkBrEzf8p7BQlMKNNF5Fk/Cf/fQ6PiUz9at4OaUfyXW0dGJTo2Vl1f5U9jSLCNf0EZJEogLXoeew==
@@ -676,7 +686,7 @@
     "@vue/compiler-core" "3.5.11"
     "@vue/shared" "3.5.11"
 
-"@vue/compiler-dom@3.5.12":
+"@vue/compiler-dom@3.5.12", "@vue/compiler-dom@^3.5.0":
   version "3.5.12"
   resolved "https://registry.yarnpkg.com/@vue/compiler-dom/-/compiler-dom-3.5.12.tgz#456d631d11102535b7ee6fd954cf2c93158d0354"
   integrity sha512-9G6PbJ03uwxLHKQ3P42cMTi85lDRvGLB2rSGOiQqtXELat6uI4n8cNz9yjfVHRPIu+MsK6TE418Giruvgptckg==
@@ -743,26 +753,26 @@
   resolved "https://registry.yarnpkg.com/@vue/devtools-api/-/devtools-api-6.6.4.tgz#cbe97fe0162b365edc1dba80e173f90492535343"
   integrity sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==
 
-"@vue/eslint-config-typescript@^14.1.1":
-  version "14.1.1"
-  resolved "https://registry.yarnpkg.com/@vue/eslint-config-typescript/-/eslint-config-typescript-14.1.1.tgz#7a1956cca1e71cd3678b60486a8030dfd30076d6"
-  integrity sha512-zw6q8pXUuFHfdZsdKYr344giBRhnq6WmWSO2abFHajxR8wDX2p2hkj0/Mf6W2phTkerU4b8WF2jgq2Z/c+PdMA==
+"@vue/eslint-config-typescript@^14.1.3":
+  version "14.1.3"
+  resolved "https://registry.yarnpkg.com/@vue/eslint-config-typescript/-/eslint-config-typescript-14.1.3.tgz#6df0d2fab863585def1f4c3e41b6fee1b0806f9b"
+  integrity sha512-L4NUJQz/0We2QYtrNwRAGRy4KfpOagl5V3MpZZ+rQ51a+bKjlKYYrugi7lp7PIX8LolRgu06ZwDoswnSGWnAmA==
   dependencies:
     "@typescript-eslint/eslint-plugin" "^8.8.1"
     fast-glob "^3.3.2"
     typescript-eslint "^8.8.1"
     vue-eslint-parser "^9.4.3"
 
-"@vue/language-core@2.1.6":
-  version "2.1.6"
-  resolved "https://registry.yarnpkg.com/@vue/language-core/-/language-core-2.1.6.tgz#b48186bdb9b3ef2b83e1f76d5b1ac357b3a7ed94"
-  integrity sha512-MW569cSky9R/ooKMh6xa2g1D0AtRKbL56k83dzus/bx//RDJk24RHWkMzbAlXjMdDNyxAaagKPRquBIxkxlCkg==
+"@vue/language-core@2.1.10":
+  version "2.1.10"
+  resolved "https://registry.yarnpkg.com/@vue/language-core/-/language-core-2.1.10.tgz#5988e9ea155f3e09ccbbb3b2a0ddd530dad912e6"
+  integrity sha512-DAI289d0K3AB5TUG3xDp9OuQ71CnrujQwJrQnfuZDwo6eGNf0UoRlPuaVNO+Zrn65PC3j0oB2i7mNmVPggeGeQ==
   dependencies:
-    "@volar/language-core" "~2.4.1"
-    "@vue/compiler-dom" "^3.4.0"
+    "@volar/language-core" "~2.4.8"
+    "@vue/compiler-dom" "^3.5.0"
     "@vue/compiler-vue2" "^2.7.16"
-    "@vue/shared" "^3.4.0"
-    computeds "^0.0.1"
+    "@vue/shared" "^3.5.0"
+    alien-signals "^0.2.0"
     minimatch "^9.0.3"
     muggle-string "^0.4.1"
     path-browserify "^1.0.1"
@@ -833,12 +843,12 @@
     "@vue/compiler-ssr" "3.5.12"
     "@vue/shared" "3.5.12"
 
-"@vue/shared@3.5.11", "@vue/shared@^3.4.0":
+"@vue/shared@3.5.11":
   version "3.5.11"
   resolved "https://registry.yarnpkg.com/@vue/shared/-/shared-3.5.11.tgz#464b840afc89be9373addff9eeb9dfc98bf3fe2e"
   integrity sha512-W8GgysJVnFo81FthhzurdRAWP/byq3q2qIw70e0JWblzVhjgOMiC2GyovXrZTFQJnFVryYaKGP3Tc9vYzYm6PQ==
 
-"@vue/shared@3.5.12":
+"@vue/shared@3.5.12", "@vue/shared@^3.5.0":
   version "3.5.12"
   resolved "https://registry.yarnpkg.com/@vue/shared/-/shared-3.5.12.tgz#f9e45b7f63f2c3f40d84237b1194b7f67de192e3"
   integrity sha512-L2RPSAwUFbgZH20etwrXyVyCBu9OxRSi8T/38QsvnkJyvq2LufW2lDCOzm7t/U9C1mkhJGWYfCuFBCmIuNivrg==
@@ -858,6 +868,11 @@ acorn@^8.12.0, acorn@^8.12.1, acorn@^8.5.0, acorn@^8.8.2, acorn@^8.9.0:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.12.1.tgz#71616bdccbe25e27a54439e0046e89ca76df2248"
   integrity sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==
 
+acorn@^8.14.0:
+  version "8.14.0"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.14.0.tgz#063e2c70cac5fb4f6467f0b11152e04c682795b0"
+  integrity sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==
+
 ajv@^6.12.4:
   version "6.12.6"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
@@ -868,6 +883,11 @@ ajv@^6.12.4:
     json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
+alien-signals@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/alien-signals/-/alien-signals-0.2.0.tgz#f159e1b767802f2444fed4e58b8d15fd8bab1c24"
+  integrity sha512-StlonZhBBrsPPwrDjiPAiVTf/rolxffLxVPT60Qv/t88BZ81BvUVzHgGqEFvJ1ii8HXtm1+zU2Icr59tfWEcag==
+
 ansi-styles@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
@@ -1058,11 +1078,6 @@ commander@^2.20.0:
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
 
-computeds@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/computeds/-/computeds-0.0.1.tgz#215b08a4ba3e08a11ff6eee5d6d8d7166a97ce2e"
-  integrity sha512-7CEBgcMjVmitjYo5q8JTJVra6X5mQ20uTThdK+0kR7UEaDrAWEQcRiBtWJzga4eRpP6afNwwLsX2SET2JhVB1Q==
-
 concat-map@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
@@ -1323,10 +1338,10 @@ escodegen@^2.1.0:
   optionalDependencies:
     source-map "~0.6.1"
 
-eslint-plugin-vue@^9.29.0:
-  version "9.29.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-vue/-/eslint-plugin-vue-9.29.0.tgz#fa1d62a88c22102be4fb8c275929698a1aee4b04"
-  integrity sha512-hamyjrBhNH6Li6R1h1VF9KHfshJlKgKEg3ARbGTn72CMNDSMhWbgC7NdkRDEh25AFW+4SDATzyNM+3gWuZii8g==
+eslint-plugin-vue@^9.30.0:
+  version "9.30.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-vue/-/eslint-plugin-vue-9.30.0.tgz#801a7d2d7d3bb878fcf71932a1e11fd07529e2c4"
+  integrity sha512-CyqlRgShvljFkOeYK8wN5frh/OGTvkj1S7wlr2Q2pUvwq+X5VYiLd6ZjujpgSgLnys2W8qrBLkXQ41SUYaoPIQ==
   dependencies:
     "@eslint-community/eslint-utils" "^4.4.0"
     globals "^13.24.0"
@@ -1345,10 +1360,10 @@ eslint-scope@^7.1.1:
     esrecurse "^4.3.0"
     estraverse "^5.2.0"
 
-eslint-scope@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-8.1.0.tgz#70214a174d4cbffbc3e8a26911d8bf51b9ae9d30"
-  integrity sha512-14dSvlhaVhKKsa9Fx1l8A17s7ah7Ef7wCakJ10LYk6+GYmP9yDti2oq2SEwcyndt6knfcZyhyxwY3i9yL78EQw==
+eslint-scope@^8.2.0:
+  version "8.2.0"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-8.2.0.tgz#377aa6f1cb5dc7592cfd0b7f892fd0cf352ce442"
+  integrity sha512-PHlWUfG6lvPc3yvP5A4PNyBL1W8fkDUccmI21JUu/+GKZBoH/W5u6usENXUrWFRsyoW5ACUjFGgAFQp5gUlb/A==
   dependencies:
     esrecurse "^4.3.0"
     estraverse "^5.2.0"
@@ -1363,21 +1378,26 @@ eslint-visitor-keys@^4.1.0:
   resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-4.1.0.tgz#1f785cc5e81eb7534523d85922248232077d2f8c"
   integrity sha512-Q7lok0mqMUSf5a/AdAZkA5a/gHcO6snwQClVNNvFKCAVlxXucdU8pKydU5ZVZjBx5xr37vGbFFWtLQYreLzrZg==
 
-eslint@^9.12.0:
-  version "9.12.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-9.12.0.tgz#54fcba2876c90528396da0fa44b6446329031e86"
-  integrity sha512-UVIOlTEWxwIopRL1wgSQYdnVDcEvs2wyaO6DGo5mXqe3r16IoCNWkR29iHhyaP4cICWjbgbmFUGAhh0GJRuGZw==
+eslint-visitor-keys@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz#687bacb2af884fcdda8a6e7d65c606f46a14cd45"
+  integrity sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==
+
+eslint@^9.14.0:
+  version "9.14.0"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-9.14.0.tgz#534180a97c00af08bcf2b60b0ebf0c4d6c1b2c95"
+  integrity sha512-c2FHsVBr87lnUtjP4Yhvk4yEhKrQavGafRA/Se1ouse8PfbfC/Qh9Mxa00yWsZRlqeUB9raXip0aiiUZkgnr9g==
   dependencies:
     "@eslint-community/eslint-utils" "^4.2.0"
-    "@eslint-community/regexpp" "^4.11.0"
+    "@eslint-community/regexpp" "^4.12.1"
     "@eslint/config-array" "^0.18.0"
-    "@eslint/core" "^0.6.0"
+    "@eslint/core" "^0.7.0"
     "@eslint/eslintrc" "^3.1.0"
-    "@eslint/js" "9.12.0"
+    "@eslint/js" "9.14.0"
     "@eslint/plugin-kit" "^0.2.0"
-    "@humanfs/node" "^0.16.5"
+    "@humanfs/node" "^0.16.6"
     "@humanwhocodes/module-importer" "^1.0.1"
-    "@humanwhocodes/retry" "^0.3.1"
+    "@humanwhocodes/retry" "^0.4.0"
     "@types/estree" "^1.0.6"
     "@types/json-schema" "^7.0.15"
     ajv "^6.12.4"
@@ -1385,9 +1405,9 @@ eslint@^9.12.0:
     cross-spawn "^7.0.2"
     debug "^4.3.2"
     escape-string-regexp "^4.0.0"
-    eslint-scope "^8.1.0"
-    eslint-visitor-keys "^4.1.0"
-    espree "^10.2.0"
+    eslint-scope "^8.2.0"
+    eslint-visitor-keys "^4.2.0"
+    espree "^10.3.0"
     esquery "^1.5.0"
     esutils "^2.0.2"
     fast-deep-equal "^3.1.3"
@@ -1404,7 +1424,7 @@ eslint@^9.12.0:
     optionator "^0.9.3"
     text-table "^0.2.0"
 
-espree@^10.0.1, espree@^10.2.0:
+espree@^10.0.1:
   version "10.2.0"
   resolved "https://registry.yarnpkg.com/espree/-/espree-10.2.0.tgz#f4bcead9e05b0615c968e85f83816bc386a45df6"
   integrity sha512-upbkBJbckcCNBDBDXEbuhjbP68n+scUd3k/U2EkyM9nw+I/jPiL4cLF/Al06CF96wRltFda16sxDFrxsI1v0/g==
@@ -1413,6 +1433,15 @@ espree@^10.0.1, espree@^10.2.0:
     acorn-jsx "^5.3.2"
     eslint-visitor-keys "^4.1.0"
 
+espree@^10.3.0:
+  version "10.3.0"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-10.3.0.tgz#29267cf5b0cb98735b65e64ba07e0ed49d1eed8a"
+  integrity sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==
+  dependencies:
+    acorn "^8.14.0"
+    acorn-jsx "^5.3.2"
+    eslint-visitor-keys "^4.2.0"
+
 espree@^9.0.0, espree@^9.3.1:
   version "9.6.1"
   resolved "https://registry.yarnpkg.com/espree/-/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f"
@@ -2569,10 +2598,10 @@ supports-preserve-symlinks-flag@^1.0.0:
   resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
-terser@^5.34.1:
-  version "5.34.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-5.34.1.tgz#af40386bdbe54af0d063e0670afd55c3105abeb6"
-  integrity sha512-FsJZ7iZLd/BXkz+4xrRTGJ26o/6VTjQytUk8b8OxkwcD2I+79VPJlz7qss1+zE7h8GNIScFqXcDyJ/KqBYZFVA==
+terser@^5.36.0:
+  version "5.36.0"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.36.0.tgz#8b0dbed459ac40ff7b4c9fd5a3a2029de105180e"
+  integrity sha512-IYV9eNMuFAV4THUspIRXkLakHnV6XO7FEdtKjf/mDyrnqUg9LnlOn6/RwRvM9SZjR4GUq8Nk8zj67FzVARr74w==
   dependencies:
     "@jridgewell/source-map" "^0.3.3"
     acorn "^8.8.2"
@@ -2686,7 +2715,7 @@ unbox-primitive@^1.0.2:
     has-symbols "^1.0.3"
     which-boxed-primitive "^1.0.2"
 
-undici-types@~6.19.2:
+undici-types@~6.19.8:
   version "6.19.8"
   resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.19.8.tgz#35111c9d1437ab83a7cdc0abae2f26d88eda0a02"
   integrity sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==
@@ -2738,10 +2767,10 @@ vite-plugin-css-injected-by-js@^3.5.2:
   resolved "https://registry.yarnpkg.com/vite-plugin-css-injected-by-js/-/vite-plugin-css-injected-by-js-3.5.2.tgz#1f75d16ad5c05b6b49bf18018099a189ec2e46ad"
   integrity sha512-2MpU/Y+SCZyWUB6ua3HbJCrgnF0KACAsmzOQt1UvRVJCGF6S8xdA3ZUhWcWdM9ivG4I5az8PnQmwwrkC2CAQrQ==
 
-vite@^5.4.9:
-  version "5.4.9"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-5.4.9.tgz#215c80cbebfd09ccbb9ceb8c0621391c9abdc19c"
-  integrity sha512-20OVpJHh0PAM0oSOELa5GaZNWeDjcAvQjGXy2Uyr+Tp+/D2/Hdz6NLgpJLsarPTA2QJ6v8mX2P1ZfbsSKvdMkg==
+vite@^5.4.10:
+  version "5.4.10"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-5.4.10.tgz#d358a7bd8beda6cf0f3b7a450a8c7693a4f80c18"
+  integrity sha512-1hvaPshuPUtxeQ0hsVH3Mud0ZanOLwVTneA1EgbAM5LhaZEqyPWGRQ7BtaMvUrTDeEaC8pxtj6a6jku3x4z6SQ==
   dependencies:
     esbuild "^0.21.3"
     postcss "^8.4.43"
@@ -2783,13 +2812,13 @@ vue-router@^4.4.5:
   dependencies:
     "@vue/devtools-api" "^6.6.4"
 
-vue-tsc@^2.1.6:
-  version "2.1.6"
-  resolved "https://registry.yarnpkg.com/vue-tsc/-/vue-tsc-2.1.6.tgz#d93fdc617da6546674301a746fd7089ea6d4543d"
-  integrity sha512-f98dyZp5FOukcYmbFpuSCJ4Z0vHSOSmxGttZJCsFeX0M4w/Rsq0s4uKXjcSRsZqsRgQa6z7SfuO+y0HVICE57Q==
+vue-tsc@^2.1.10:
+  version "2.1.10"
+  resolved "https://registry.yarnpkg.com/vue-tsc/-/vue-tsc-2.1.10.tgz#4d61a64e5fad763b8b40c1884259fd48986f0b4e"
+  integrity sha512-RBNSfaaRHcN5uqVqJSZh++Gy/YUzryuv9u1aFWhsammDJXNtUiJMNoJ747lZcQ68wUQFx6E73y4FY3D8E7FGMA==
   dependencies:
-    "@volar/typescript" "~2.4.1"
-    "@vue/language-core" "2.1.6"
+    "@volar/typescript" "~2.4.8"
+    "@vue/language-core" "2.1.10"
     semver "^7.5.4"
 
 vue@^3.4: