diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 754dcd074..b7529427e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -5,6 +5,11 @@ on:
     paths-ignore:
       - docs/**
       - '**/*.md'
+    branches:
+      - master
+      - development
+    tags-ignore:        
+      - v*
   pull_request:
     paths-ignore:
       - docs/**
diff --git a/include/Battery.h b/include/Battery.h
index ab9399e8a..7e9290348 100644
--- a/include/Battery.h
+++ b/include/Battery.h
@@ -2,44 +2,32 @@
 #pragma once
 
 #include <stdint.h>
+#include <memory>
+#include <mutex>
+
+#include "BatteryStats.h"
+
+class BatteryProvider {
+    public:
+        // returns true if the provider is ready for use, false otherwise
+        virtual bool init(bool verboseLogging) = 0;
+
+        virtual void deinit() = 0;
+        virtual void loop() = 0;
+        virtual std::shared_ptr<BatteryStats> getStats() const = 0;
+};
 
 class BatteryClass {
-public:
-    uint32_t lastUpdate;
-
-    float chargeVoltage;
-    float chargeCurrentLimitation;
-    float dischargeCurrentLimitation;
-    uint16_t stateOfCharge;
-    uint32_t stateOfChargeLastUpdate;
-    uint16_t stateOfHealth;
-    float voltage;
-    float current;
-    float temperature;
-    bool alarmOverCurrentDischarge;
-    bool alarmUnderTemperature;
-    bool alarmOverTemperature;
-    bool alarmUnderVoltage;
-    bool alarmOverVoltage;
-
-    bool alarmBmsInternal;
-    bool alarmOverCurrentCharge;
-
-
-    bool warningHighCurrentDischarge;
-    bool warningLowTemperature;
-    bool warningHighTemperature;
-    bool warningLowVoltage;
-    bool warningHighVoltage;
-
-    bool warningBmsInternal;
-    bool warningHighCurrentCharge;
-    char manufacturer[9];
-    bool chargeEnabled;
-    bool dischargeEnabled;
-    bool chargeImmediately;
-
-private:
+    public:
+        void init();
+        void loop();
+
+        std::shared_ptr<BatteryStats const> getStats() const;
+
+    private:
+        uint32_t _lastMqttPublish = 0;
+        mutable std::mutex _mutex;
+        std::unique_ptr<BatteryProvider> _upProvider = nullptr;
 };
 
 extern BatteryClass Battery;
diff --git a/include/BatteryStats.h b/include/BatteryStats.h
new file mode 100644
index 000000000..ebdca11fd
--- /dev/null
+++ b/include/BatteryStats.h
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <stdint.h>
+
+#include "AsyncJson.h"
+#include "Arduino.h"
+#include "JkBmsDataPoints.h"
+
+// mandatory interface for all kinds of batteries
+class BatteryStats {
+    public:
+        String const& getManufacturer() const { return _manufacturer; }
+
+        // the last time *any* datum was updated
+        uint32_t getAgeSeconds() const { return (millis() - _lastUpdate) / 1000; }
+        bool updateAvailable(uint32_t since) const { return _lastUpdate > since; }
+
+        uint8_t getSoC() const { return _SoC; }
+        uint32_t getSoCAgeSeconds() const { return (millis() - _lastUpdateSoC) / 1000; }
+
+        // convert stats to JSON for web application live view
+        virtual void getLiveViewData(JsonVariant& root) const;
+
+        virtual void mqttPublish() const;
+
+        bool isValid() const { return _lastUpdateSoC > 0 && _lastUpdate > 0; }
+
+    protected:
+        template<typename T>
+        void addLiveViewValue(JsonVariant& root, std::string const& name,
+                T&& value, std::string const& unit, uint8_t precision) const;
+        void addLiveViewText(JsonVariant& root, std::string const& name,
+            std::string const& text) const;
+        void addLiveViewWarning(JsonVariant& root, std::string const& name,
+            bool warning) const;
+        void addLiveViewAlarm(JsonVariant& root, std::string const& name,
+            bool alarm) const;
+
+        String _manufacturer = "unknown";
+        uint8_t _SoC = 0;
+        uint32_t _lastUpdateSoC = 0;
+        uint32_t _lastUpdate = 0;
+};
+
+class PylontechBatteryStats : public BatteryStats {
+    friend class PylontechCanReceiver;
+
+    public:
+        void getLiveViewData(JsonVariant& root) const final;
+        void mqttPublish() const final;
+
+    private:
+        void setManufacturer(String&& m) { _manufacturer = std::move(m); }
+        void setSoC(uint8_t SoC) { _SoC = SoC; _lastUpdateSoC = millis(); }
+        void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
+
+        float _chargeVoltage;
+        float _chargeCurrentLimitation;
+        float _dischargeCurrentLimitation;
+        uint16_t _stateOfHealth;
+        float _voltage; // total voltage of the battery pack
+        // total current into (positive) or from (negative)
+        // the battery, i.e., the charging current
+        float _current;
+        float _temperature;
+
+        bool _alarmOverCurrentDischarge;
+        bool _alarmOverCurrentCharge;
+        bool _alarmUnderTemperature;
+        bool _alarmOverTemperature;
+        bool _alarmUnderVoltage;
+        bool _alarmOverVoltage;
+        bool _alarmBmsInternal;
+
+        bool _warningHighCurrentDischarge;
+        bool _warningHighCurrentCharge;
+        bool _warningLowTemperature;
+        bool _warningHighTemperature;
+        bool _warningLowVoltage;
+        bool _warningHighVoltage;
+        bool _warningBmsInternal;
+
+        bool _chargeEnabled;
+        bool _dischargeEnabled;
+        bool _chargeImmediately;
+};
+
+class JkBmsBatteryStats : public BatteryStats {
+    public:
+        void getLiveViewData(JsonVariant& root) const final;
+        void mqttPublish() const final;
+
+        void updateFrom(JkBms::DataPointContainer const& dp);
+
+    private:
+        JkBms::DataPointContainer _dataPoints;
+};
diff --git a/include/Configuration.h b/include/Configuration.h
index be1864d23..5c10e15bb 100644
--- a/include/Configuration.h
+++ b/include/Configuration.h
@@ -127,6 +127,7 @@ struct CONFIG_T {
     char Mqtt_ClientKey[MQTT_MAX_CERT_STRLEN +1];
 
     bool Vedirect_Enabled;
+    bool Vedirect_VerboseLogging;
     bool Vedirect_UpdatesOnly;
 
     bool PowerMeter_Enabled;
@@ -166,6 +167,11 @@ struct CONFIG_T {
     float PowerLimiter_FullSolarPassThroughStopVoltage;
 
     bool Battery_Enabled;
+    bool Battery_VerboseLogging;
+    uint8_t Battery_Provider;
+    uint8_t Battery_JkBmsInterface;
+    uint8_t Battery_JkBmsPollingInterval;
+
     bool Huawei_Enabled;
     bool Huawei_Auto_Power_Enabled;
     float Huawei_Auto_Power_Voltage_Limit;
diff --git a/include/JkBmsController.h b/include/JkBmsController.h
new file mode 100644
index 000000000..0cb2e46e0
--- /dev/null
+++ b/include/JkBmsController.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "Battery.h"
+#include "JkBmsSerialMessage.h"
+
+class DataPointContainer;
+
+namespace JkBms {
+
+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:
+        enum class Status : unsigned {
+            Initializing,
+            Timeout,
+            WaitingForPollInterval,
+            HwSerialNotAvailableForWrite,
+            BusyReading,
+            RequestSent,
+            FrameCompleted
+        };
+
+        std::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,
+            StartMarkerReceived,
+            FrameLengthMsbReceived,
+            ReadingFrame
+        };
+        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;
+        uint16_t _frameLength = 0;
+        uint8_t _protocolVersion = -1;
+        SerialResponse::tData _buffer = {};
+        std::shared_ptr<JkBmsBatteryStats> _stats =
+            std::make_shared<JkBmsBatteryStats>();
+};
+
+} /* namespace JkBms */
diff --git a/include/JkBmsDataPoints.h b/include/JkBmsDataPoints.h
new file mode 100644
index 000000000..db7cd37ab
--- /dev/null
+++ b/include/JkBmsDataPoints.h
@@ -0,0 +1,250 @@
+#pragma once
+
+#include <Arduino.h>
+#include <map>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+namespace JkBms {
+
+enum class DataPointLabel : uint8_t {
+    CellsMilliVolt = 0x79,
+    BmsTempCelsius = 0x80,
+    BatteryTempOneCelsius = 0x81,
+    BatteryTempTwoCelsius = 0x82,
+    BatteryVoltageMilliVolt = 0x83,
+    BatteryCurrentMilliAmps = 0x84,
+    BatterySoCPercent = 0x85,
+    BatteryTemperatureSensorAmount = 0x86,
+    BatteryCycles = 0x87,
+    BatteryCycleCapacity = 0x89,
+    BatteryCellAmount = 0x8a,
+    AlarmsBitmask = 0x8b,
+    StatusBitmask = 0x8c,
+    TotalOvervoltageThresholdMilliVolt = 0x8e,
+    TotalUndervoltageThresholdMilliVolt = 0x8f,
+    CellOvervoltageThresholdMilliVolt = 0x90,
+    CellOvervoltageRecoveryMilliVolt = 0x91,
+    CellOvervoltageProtectionDelaySeconds = 0x92,
+    CellUndervoltageThresholdMilliVolt = 0x93,
+    CellUndervoltageRecoveryMilliVolt = 0x94,
+    CellUndervoltageProtectionDelaySeconds = 0x95,
+    CellVoltageDiffThresholdMilliVolt = 0x96,
+    DischargeOvercurrentThresholdAmperes = 0x97,
+    DischargeOvercurrentDelaySeconds = 0x98,
+    ChargeOvercurrentThresholdAmps = 0x99,
+    ChargeOvercurrentDelaySeconds = 0x9a,
+    BalanceCellVoltageThresholdMilliVolt = 0x9b,
+    BalanceVoltageDiffThresholdMilliVolt = 0x9c,
+    BalancingEnabled = 0x9d,
+    BmsTempProtectionThresholdCelsius = 0x9e,
+    BmsTempRecoveryThresholdCelsius = 0x9f,
+    BatteryTempProtectionThresholdCelsius = 0xa0,
+    BatteryTempRecoveryThresholdCelsius = 0xa1,
+    BatteryTempDiffThresholdCelsius = 0xa2,
+    ChargeHighTempThresholdCelsius = 0xa3,
+    DischargeHighTempThresholdCelsius = 0xa4,
+    ChargeLowTempThresholdCelsius = 0xa5,
+    ChargeLowTempRecoveryCelsius = 0xa6,
+    DischargeLowTempThresholdCelsius = 0xa7,
+    DischargeLowTempRecoveryCelsius = 0xa8,
+    CellAmountSetting = 0xa9,
+    BatteryCapacitySettingAmpHours = 0xaa,
+    BatteryChargeEnabled = 0xab,
+    BatteryDischargeEnabled = 0xac,
+    CurrentCalibrationMilliAmps = 0xad,
+    BmsAddress = 0xae,
+    BatteryType = 0xaf,
+    SleepWaitTime = 0xb0, // what's this?
+    LowCapacityAlarmThresholdPercent = 0xb1,
+    ModificationPassword = 0xb2,
+    DedicatedChargerSwitch = 0xb3, // what's this?
+    EquipmentId = 0xb4,
+    DateOfManufacturing = 0xb5,
+    BmsHourMeterMinutes = 0xb6,
+    BmsSoftwareVersion = 0xb7,
+    CurrentCalibration = 0xb8,
+    ActualBatteryCapacityAmpHours = 0xb9,
+    ProductId = 0xba,
+    ProtocolVersion = 0xc0
+};
+
+using tCells = std::map<uint8_t, uint16_t>;
+
+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 JkBms::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(BmsTempCelsius,                         int16_t,     "°C");
+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(BatteryCycleCapacity,                   uint32_t,    "Ah");
+LABEL_TRAIT(BatteryCellAmount,                      uint16_t,    "");
+LABEL_TRAIT(AlarmsBitmask,                          uint16_t,    "");
+LABEL_TRAIT(StatusBitmask,                          uint16_t,    "");
+LABEL_TRAIT(TotalOvervoltageThresholdMilliVolt,     uint32_t,    "mV");
+LABEL_TRAIT(TotalUndervoltageThresholdMilliVolt,    uint32_t,    "mV");
+LABEL_TRAIT(CellOvervoltageThresholdMilliVolt,      uint16_t,    "mV");
+LABEL_TRAIT(CellOvervoltageRecoveryMilliVolt,       uint16_t,    "mV");
+LABEL_TRAIT(CellOvervoltageProtectionDelaySeconds,  uint16_t,    "s");
+LABEL_TRAIT(CellUndervoltageThresholdMilliVolt,     uint16_t,    "mV");
+LABEL_TRAIT(CellUndervoltageRecoveryMilliVolt,      uint16_t,    "mV");
+LABEL_TRAIT(CellUndervoltageProtectionDelaySeconds, uint16_t,    "s");
+LABEL_TRAIT(CellVoltageDiffThresholdMilliVolt,      uint16_t,    "mV");
+LABEL_TRAIT(DischargeOvercurrentThresholdAmperes,   uint16_t,    "A");
+LABEL_TRAIT(DischargeOvercurrentDelaySeconds,       uint16_t,    "s");
+LABEL_TRAIT(ChargeOvercurrentThresholdAmps,         uint16_t,    "A");
+LABEL_TRAIT(ChargeOvercurrentDelaySeconds,          uint16_t,    "s");
+LABEL_TRAIT(BalanceCellVoltageThresholdMilliVolt,   uint16_t,    "mV");
+LABEL_TRAIT(BalanceVoltageDiffThresholdMilliVolt,   uint16_t,    "mV");
+LABEL_TRAIT(BalancingEnabled,                       bool,        "");
+LABEL_TRAIT(BmsTempProtectionThresholdCelsius,      uint16_t,    "°C");
+LABEL_TRAIT(BmsTempRecoveryThresholdCelsius,        uint16_t,    "°C");
+LABEL_TRAIT(BatteryTempProtectionThresholdCelsius,  uint16_t,    "°C");
+LABEL_TRAIT(BatteryTempRecoveryThresholdCelsius,    uint16_t,    "°C");
+LABEL_TRAIT(BatteryTempDiffThresholdCelsius,        uint16_t,    "°C");
+LABEL_TRAIT(ChargeHighTempThresholdCelsius,         uint16_t,    "°C");
+LABEL_TRAIT(DischargeHighTempThresholdCelsius,      uint16_t,    "°C");
+LABEL_TRAIT(ChargeLowTempThresholdCelsius,          int16_t,     "°C");
+LABEL_TRAIT(ChargeLowTempRecoveryCelsius,           int16_t,     "°C");
+LABEL_TRAIT(DischargeLowTempThresholdCelsius,       int16_t,     "°C");
+LABEL_TRAIT(DischargeLowTempRecoveryCelsius,        int16_t,     "°C");
+LABEL_TRAIT(CellAmountSetting,                      uint8_t,     "");
+LABEL_TRAIT(BatteryCapacitySettingAmpHours,         uint32_t,    "Ah");
+LABEL_TRAIT(BatteryChargeEnabled,                   bool,        "");
+LABEL_TRAIT(BatteryDischargeEnabled,                bool,        "");
+LABEL_TRAIT(CurrentCalibrationMilliAmps,            uint16_t,    "mA");
+LABEL_TRAIT(BmsAddress,                             uint8_t,     "");
+LABEL_TRAIT(BatteryType,                            uint8_t,     "");
+LABEL_TRAIT(SleepWaitTime,                          uint16_t,    "s");
+LABEL_TRAIT(LowCapacityAlarmThresholdPercent,       uint8_t,     "%");
+LABEL_TRAIT(ModificationPassword,                   std::string, "");
+LABEL_TRAIT(DedicatedChargerSwitch,                 bool,        "");
+LABEL_TRAIT(EquipmentId,                            std::string, "");
+LABEL_TRAIT(DateOfManufacturing,                    std::string, "");
+LABEL_TRAIT(BmsHourMeterMinutes,                    uint32_t,    "min");
+LABEL_TRAIT(BmsSoftwareVersion,                     std::string, "");
+LABEL_TRAIT(CurrentCalibration,                     bool,        "");
+LABEL_TRAIT(ActualBatteryCapacityAmpHours,          uint32_t,    "Ah");
+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; }
+
+    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 */
diff --git a/include/JkBmsSerialMessage.h b/include/JkBmsSerialMessage.h
new file mode 100644
index 000000000..6f869d70a
--- /dev/null
+++ b/include/JkBmsSerialMessage.h
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <Arduino.h>
+
+#include "JkBmsDataPoints.h"
+
+namespace JkBms {
+
+class SerialMessage {
+    public:
+        using tData = std::vector<uint8_t>;
+
+        SerialMessage() = delete;
+
+        enum class Command : uint8_t {
+            Activate = 0x01,
+            Write = 0x02,
+            Read = 0x03,
+            Password = 0x05,
+            ReadAll = 0x06
+        };
+
+        Command getCommand() const { return static_cast<Command>(_raw[8]); }
+
+        enum class Source : uint8_t {
+            BMS = 0x00,
+            Bluetooth = 0x01,
+            GPS = 0x02,
+            Host = 0x03
+        };
+        Source getSource() const { return static_cast<Source>(_raw[9]); }
+
+        enum class Type : uint8_t {
+            Command = 0x00,
+            Response = 0x01,
+            Unsolicited = 0x02
+        };
+        Type getType() const { return static_cast<Type>(_raw[10]); }
+
+        // this does *not* include the two byte start marker
+        uint16_t getFrameLength() const { return get<uint16_t>(_raw.cbegin()+2); }
+
+        uint32_t getTerminalId() const { return get<uint32_t>(_raw.cbegin()+4); }
+
+        // there are 20 bytes of overhead. two of those are the start marker
+        // bytes, which are *not* counted by the frame length.
+        uint16_t getVariableFieldLength() const { return getFrameLength() - 18; }
+
+        // the upper byte of the 4-byte "record number" is reserved (for encryption)
+        uint32_t getSequence() const { return get<uint32_t>(_raw.cend()-9) >> 8; }
+
+        bool isValid() const;
+
+        uint8_t const* data() { return _raw.data(); }
+        size_t size() { return _raw.size(); }
+
+    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;
+        void processBatteryCurrent(tData::const_iterator& pos, uint8_t protocolVersion);
+        template<typename T> void set(tData::iterator const& pos, T val);
+        uint16_t calcChecksum() const;
+        void updateChecksum();
+
+        tData _raw;
+        JkBms::DataPointContainer _dp;
+
+        static constexpr uint16_t startMarker = 0x4e57;
+        static constexpr uint8_t endMarker = 0x68;
+};
+
+class SerialResponse : public SerialMessage {
+    public:
+        using tData = SerialMessage::tData;
+        explicit SerialResponse(tData&& raw, uint8_t protocolVersion = -1);
+
+        DataPointContainer const& getDataPoints() const { return _dp; }
+};
+
+class SerialCommand : public SerialMessage {
+    public:
+        using Command = SerialMessage::Command;
+        explicit SerialCommand(Command cmd);
+};
+
+} /* namespace JkBms */
diff --git a/include/MessageOutput.h b/include/MessageOutput.h
index 7c56a6f47..7ff745ebd 100644
--- a/include/MessageOutput.h
+++ b/include/MessageOutput.h
@@ -2,11 +2,12 @@
 #pragma once
 
 #include <AsyncWebSocket.h>
-#include <HardwareSerial.h>
-#include <Stream.h>
+#include <Print.h>
+#include <freertos/task.h>
 #include <mutex>
-
-#define BUFFER_SIZE 500
+#include <vector>
+#include <unordered_map>
+#include <queue>
 
 class MessageOutputClass : public Print {
 public:
@@ -16,13 +17,19 @@ class MessageOutputClass : public Print {
     void register_ws_output(AsyncWebSocket* output);
 
 private:
-    AsyncWebSocket* _ws = NULL;
-    char _buffer[BUFFER_SIZE];
-    uint16_t _buff_pos = 0;
-    uint32_t _lastSend = 0;
-    bool _forceSend = false;
+    using message_t = std::vector<uint8_t>;
+
+    // we keep a buffer for every task and only write complete lines to the
+    // serial output and then move them to be pushed through the websocket.
+    // this way we prevent mangling of messages from different contexts.
+    std::unordered_map<TaskHandle_t, message_t> _task_messages;
+    std::queue<message_t> _lines;
+
+    AsyncWebSocket* _ws = nullptr;
 
     std::mutex _msgLock;
+
+    void serialWrite(message_t const& m);
 };
 
 extern MessageOutputClass MessageOutput;
\ No newline at end of file
diff --git a/include/MqttHandlePylontechHass.h b/include/MqttHandlePylontechHass.h
index 7204bc57b..318b970bf 100644
--- a/include/MqttHandlePylontechHass.h
+++ b/include/MqttHandlePylontechHass.h
@@ -12,8 +12,8 @@ class MqttHandlePylontechHassClass {
 
 private:
     void publish(const String& subtopic, const String& payload);
-    void publishBinarySensor(const char* caption, const char* subTopic, const char* payload_on, const char* payload_off);
-    void publishSensor(const char* caption, const char* subTopic, const char* deviceClass = NULL, const char* stateClass = NULL, const char* unitOfMeasurement = NULL);
+    void publishBinarySensor(const char* caption, const char* icon, const char* subTopic, const char* payload_on, const char* payload_off);
+    void publishSensor(const char* caption, const char* icon, const char* subTopic, const char* deviceClass = NULL, const char* stateClass = NULL, const char* unitOfMeasurement = NULL);
     void createDeviceInfo(JsonObject& object);
 
     bool _wasConnected = false;
diff --git a/include/MqttHandleVedirectHass.h b/include/MqttHandleVedirectHass.h
index fe19cf1de..3a7209912 100644
--- a/include/MqttHandleVedirectHass.h
+++ b/include/MqttHandleVedirectHass.h
@@ -13,8 +13,8 @@ class MqttHandleVedirectHassClass {
 
 private:
     void publish(const String& subtopic, const String& payload);
-    void publishBinarySensor(const char* caption, const char* subTopic, const char* payload_on, const char* payload_off);
-    void publishSensor(const char* caption, const char* subTopic, const char* deviceClass = NULL, const char* stateClass = NULL, const char* unitOfMeasurement = NULL);
+    void publishBinarySensor(const char* caption, const char* icon, const char* subTopic, const char* payload_on, const char* payload_off);
+    void publishSensor(const char* caption, const char* icon, const char* subTopic, const char* deviceClass = NULL, const char* stateClass = NULL, const char* unitOfMeasurement = NULL);
     void createDeviceInfo(JsonObject& object);
 
     bool _wasConnected = false;
diff --git a/include/PinMapping.h b/include/PinMapping.h
index a9c14926a..5e4c7fa04 100644
--- a/include/PinMapping.h
+++ b/include/PinMapping.h
@@ -41,7 +41,9 @@ struct PinMapping_t {
     int8_t victron_tx;
     int8_t victron_rx;
     int8_t battery_rx;
+    int8_t battery_rxen;
     int8_t battery_tx;
+    int8_t battery_txen;
     int8_t huawei_miso;
     int8_t huawei_mosi;
     int8_t huawei_clk;
@@ -61,7 +63,6 @@ class PinMappingClass {
     bool isValidCmt2300Config();
     bool isValidEthConfig();
     bool isValidVictronConfig();
-    bool isValidBatteryConfig();
     bool isValidHuaweiConfig();
     
 private:
diff --git a/include/PylontechCanReceiver.h b/include/PylontechCanReceiver.h
index 726a1af4c..2b2b922d9 100644
--- a/include/PylontechCanReceiver.h
+++ b/include/PylontechCanReceiver.h
@@ -2,40 +2,28 @@
 #pragma once
 
 #include "Configuration.h"
+#include "Battery.h"
 #include <espMqttClient.h>
 #include <driver/twai.h>
 #include <Arduino.h>
 #include <memory>
 
-#ifndef PYLONTECH_PIN_RX
-#define PYLONTECH_PIN_RX 27
-#endif
-
-#ifndef PYLONTECH_PIN_TX
-#define PYLONTECH_PIN_TX 26
-#endif
-
-class PylontechCanReceiverClass {
+class PylontechCanReceiver : public BatteryProvider {
 public:
-    void init(int8_t rx, int8_t tx);
-    void enable();
-    void disable();
-    void loop();
-    void parseCanPackets();
-    void mqtt();
+    bool init(bool verboseLogging) final;
+    void deinit() final;
+    void loop() final;
+    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
 
 private:
     uint16_t readUnsignedInt16(uint8_t *data);
     int16_t readSignedInt16(uint8_t *data);
-    void readString(char* str, uint8_t numBytes);
-    void readBooleanBits8(bool* b, uint8_t numBits);
     float scaleValue(int16_t value, float factor);
     bool getBit(uint8_t value, uint8_t bit);
 
-    bool _isEnabled = false;
-    uint32_t _lastPublish;
-    twai_general_config_t g_config;
-    esp_err_t twaiLastResult;
-};
+    void dummyData();
 
-extern PylontechCanReceiverClass PylontechCanReceiver;
+    bool _verboseLogging = true;
+    std::shared_ptr<PylontechBatteryStats> _stats =
+        std::make_shared<PylontechBatteryStats>();
+};
diff --git a/include/WebApi.h b/include/WebApi.h
index 0084258e8..d7a8ab85c 100644
--- a/include/WebApi.h
+++ b/include/WebApi.h
@@ -27,8 +27,7 @@
 #include "WebApi_vedirect.h"
 #include "WebApi_ws_Huawei.h"
 #include "WebApi_Huawei.h"
-#include "WebApi_ws_Pylontech.h"
-#include "WebApi_Pylontech.h"
+#include "WebApi_ws_battery.h"
 #include <ESPAsyncWebServer.h>
 
 class WebApiClass {
@@ -72,9 +71,7 @@ class WebApiClass {
     WebApiVedirectClass _webApiVedirect;
     WebApiHuaweiClass _webApiHuaweiClass;
     WebApiWsHuaweiLiveClass _webApiWsHuaweiLive;
-    WebApiPylontechClass _webApiPylontechClass;
-    WebApiWsPylontechLiveClass _webApiWsPylontechLive;
-    
+    WebApiWsBatteryLiveClass _webApiWsBatteryLive;
 };
 
 extern WebApiClass WebApi;
\ No newline at end of file
diff --git a/include/WebApi_Pylontech.h b/include/WebApi_Pylontech.h
deleted file mode 100644
index 26f61e260..000000000
--- a/include/WebApi_Pylontech.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include <ESPAsyncWebServer.h>
-#include <AsyncJson.h>
-
-class WebApiPylontechClass {
-public:
-    void init(AsyncWebServer* server);
-    void loop();
-    void getJsonData(JsonObject& root);
-
-private:
-    void onStatus(AsyncWebServerRequest* request);
-
-    AsyncWebServer* _server;
-};
\ No newline at end of file
diff --git a/include/WebApi_ws_Pylontech.h b/include/WebApi_ws_battery.h
similarity index 79%
rename from include/WebApi_ws_Pylontech.h
rename to include/WebApi_ws_battery.h
index 9651d2fb1..5fe5b228b 100644
--- a/include/WebApi_ws_Pylontech.h
+++ b/include/WebApi_ws_battery.h
@@ -4,9 +4,9 @@
 #include "ArduinoJson.h"
 #include <ESPAsyncWebServer.h>
 
-class WebApiWsPylontechLiveClass {
+class WebApiWsBatteryLiveClass {
 public:
-    WebApiWsPylontechLiveClass();
+    WebApiWsBatteryLiveClass();
     void init(AsyncWebServer* server);
     void loop();
 
@@ -20,4 +20,5 @@ class WebApiWsPylontechLiveClass {
 
     uint32_t _lastWsCleanup = 0;
     uint32_t _lastUpdateCheck = 0;
+    static constexpr uint16_t _responseSize = 1024 + 512;
 };
\ No newline at end of file
diff --git a/include/defaults.h b/include/defaults.h
index 8e561b491..051b0ba9c 100644
--- a/include/defaults.h
+++ b/include/defaults.h
@@ -96,8 +96,8 @@
 #define DISPLAY_LANGUAGE 0U
 
 #define VEDIRECT_ENABLED false
+#define VEDIRECT_VERBOSE_LOGGING false
 #define VEDIRECT_UPDATESONLY true
-#define VEDIRECT_POLL_INTERVAL 5
 
 #define POWERMETER_ENABLED false
 #define POWERMETER_INTERVAL 10
@@ -129,6 +129,9 @@
 #define POWERLIMITER_FULL_SOLAR_PASSTHROUGH_STOP_VOLTAGE 100.0
 
 #define BATTERY_ENABLED false
+#define BATTERY_PROVIDER 0 // Pylontech CAN receiver
+#define BATTERY_JKBMS_INTERFACE 0
+#define BATTERY_JKBMS_POLLING_INTERVAL 5
 
 #define HUAWEI_ENABLED false
 #define HUAWEI_AUTO_POWER_VOLTAGE_LIMIT 42.0
diff --git a/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp b/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp
index aa028ca53..4c026e67b 100644
--- a/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp
+++ b/lib/VeDirectFrameHandler/VeDirectFrameHandler.cpp
@@ -36,27 +36,33 @@
 #include <Arduino.h>
 #include "VeDirectFrameHandler.h"
 
-char MODULE[] = "VE.Frame";	// Victron seems to use this to find out where logging messages were generated
-
 // The name of the record that contains the checksum.
 static constexpr char checksumTagName[] = "CHECKSUM";
 
 // state machine
-enum States {                               
-	IDLE,
-	RECORD_BEGIN,
-	RECORD_NAME,
-	RECORD_VALUE,
-	CHECKSUM,
-	RECORD_HEX
+enum States {
+	IDLE = 1,
+	RECORD_BEGIN = 2,
+	RECORD_NAME = 3,
+	RECORD_VALUE = 4,
+	CHECKSUM = 5,
+	RECORD_HEX = 6
 };
 
 HardwareSerial VedirectSerial(1);
 
 VeDirectFrameHandler VeDirect;
 
+class Silent : public Print {
+    public:
+        size_t write(uint8_t c) final { return 0; }
+};
+
+static Silent MessageOutputDummy;
+
 VeDirectFrameHandler::VeDirectFrameHandler() :
 	//mStop(false),	// don't know what Victron uses this for, not using
+	_msgOut(&MessageOutputDummy),
 	_state(IDLE),
 	_checksum(0),
 	_textPointer(0),
@@ -64,20 +70,53 @@ VeDirectFrameHandler::VeDirectFrameHandler() :
 	_name(""),
 	_value(""),
 	_tmpFrame(),
+	_debugIn(0),
+	_lastByteMillis(0),
 	_lastUpdate(0)
 {
 }
 
-void VeDirectFrameHandler::init(int8_t rx, int8_t tx)
+void VeDirectFrameHandler::setVerboseLogging(bool verboseLogging)
 {
-    VedirectSerial.begin(19200, SERIAL_8N1, rx, tx);
-    VedirectSerial.flush();
+	_verboseLogging = verboseLogging;
+}
+
+void VeDirectFrameHandler::init(int8_t rx, int8_t tx, Print* msgOut, bool verboseLogging)
+{
+	VedirectSerial.begin(19200, SERIAL_8N1, rx, tx);
+	VedirectSerial.flush();
+	_msgOut = msgOut;
+	setVerboseLogging(verboseLogging);
+}
+
+void VeDirectFrameHandler::dumpDebugBuffer() {
+	_msgOut->printf("[VE.Direct] serial input (%d Bytes):", _debugIn);
+	for (int i = 0; i < _debugIn; ++i) {
+		if (i % 16 == 0) {
+			_msgOut->printf("\r\n[VE.Direct]");
+		}
+		_msgOut->printf(" %02x", _debugBuffer[i]);
+	}
+	_msgOut->println("");
+	_debugIn = 0;
 }
 
 void VeDirectFrameHandler::loop()
 {
 	while ( VedirectSerial.available()) {
 		rxData(VedirectSerial.read());
+		_lastByteMillis = millis();
+	}
+
+	// there will never be a large gap between two bytes of the same frame.
+	// if such a large gap is observed, reset the state machine so it tries
+	// to decode a new frame once more data arrives.
+	if (IDLE != _state && _lastByteMillis + 500 < millis()) {
+		_msgOut->printf("[VE.Direct] Resetting state machine (was %d) after timeout\r\n", _state);
+		if (_verboseLogging) { dumpDebugBuffer(); }
+		_checksum = 0;
+		_state = IDLE;
+		_tmpFrame = { };
 	}
 }
 
@@ -88,6 +127,12 @@ void VeDirectFrameHandler::loop()
  */
 void VeDirectFrameHandler::rxData(uint8_t inbyte)
 {
+	_debugBuffer[_debugIn] = inbyte;
+	_debugIn = (_debugIn + 1) % _debugBuffer.size();
+	if (0 == _debugIn) {
+		_msgOut->println("[VE.Direct] ERROR: debug buffer overrun!");
+	}
+
 	//if (mStop) return;
 	if ( (inbyte == ':') && (_state != CHECKSUM) ) {
 		_prevState = _state; //hex frame can interrupt TEXT
@@ -162,8 +207,10 @@ void VeDirectFrameHandler::rxData(uint8_t inbyte)
 	case CHECKSUM:
 	{
 		bool valid = _checksum == 0;
-		if (!valid)
-			logE(MODULE,"[CHECKSUM] Invalid frame");
+		if (!valid) {
+			_msgOut->printf("[VE.Direct] checksum 0x%02x != 0, invalid frame\r\n", _checksum);
+		}
+		if (_verboseLogging) { dumpDebugBuffer(); }
 		_checksum = 0;
 		_state = IDLE;
 		frameEndEvent(valid);
@@ -268,18 +315,6 @@ void VeDirectFrameHandler::frameEndEvent(bool valid) {
 	_tmpFrame = {};
 }
 
-/*
- *	logE
- *  This function included for continuity and possible future use.	
- */
-void VeDirectFrameHandler::logE(const char * module, const char * error) {
-	Serial.print("MODULE: ");
-    Serial.println(module);
-    Serial.print("ERROR: ");
-    Serial.println(error);
-	return;
-}
-
 /*
  *	hexRxEvent
  *  This function records hex answers or async messages	
@@ -296,7 +331,7 @@ int VeDirectFrameHandler::hexRxEvent(uint8_t inbyte) {
 	default:
 		_hexSize++;
 		if (_hexSize>=VE_MAX_HEX_LEN) { // oops -buffer overflow - something went wrong, we abort
-			logE(MODULE,"hexRx buffer overflow - aborting read");
+			_msgOut->println("[VE.Direct] hexRx buffer overflow - aborting read");
 			_hexSize=0;
 			ret=IDLE;
 		}
diff --git a/lib/VeDirectFrameHandler/VeDirectFrameHandler.h b/lib/VeDirectFrameHandler/VeDirectFrameHandler.h
index 69b4cd488..db4345718 100644
--- a/lib/VeDirectFrameHandler/VeDirectFrameHandler.h
+++ b/lib/VeDirectFrameHandler/VeDirectFrameHandler.h
@@ -12,6 +12,7 @@
 #pragma once
 
 #include <Arduino.h>
+#include <array>
 
 #ifndef VICTRON_PIN_TX
 #define VICTRON_PIN_TX 21      // HardwareSerial TX Pin
@@ -87,7 +88,8 @@ class VeDirectFrameHandler {
 public:
 
     VeDirectFrameHandler();
-    void init(int8_t rx, int8_t tx);             // initialize HardewareSerial
+    void setVerboseLogging(bool verboseLogging);
+    void init(int8_t rx, int8_t tx, Print* msgOut, bool verboseLogging);
     void loop();                                 // main loop to read ve.direct data
     unsigned long getLastUpdate();               // timestamp of last successful frame read
     bool isDataValid();                          // return true if data valid and not outdated
@@ -101,13 +103,15 @@ class VeDirectFrameHandler {
 
 private:
     void setLastUpdate();                     // set timestampt after successful frame read
+    void dumpDebugBuffer();
     void rxData(uint8_t inbyte);              // byte of serial data
     void textRxEvent(char *, char *);
     void frameEndEvent(bool);                 // copy temp struct to public struct
-    void logE(const char *, const char *);    
     int hexRxEvent(uint8_t);
 
     //bool mStop;                               // not sure what Victron uses this for, not using
+    Print* _msgOut;
+    bool _verboseLogging;
     int _state;                                // current state
     int _prevState;                            // previous state
     uint8_t	_checksum;                         // checksum value
@@ -117,7 +121,10 @@ class VeDirectFrameHandler {
     char _value[VE_MAX_VALUE_LEN];             // buffer for the field value
     veStruct _tmpFrame{};                        // private struct for received name and value pairs
     MovingAverage<double, 5> _efficiency;
-    unsigned long _lastUpdate;
+    std::array<uint8_t, 512> _debugBuffer;
+    unsigned _debugIn;
+    uint32_t _lastByteMillis;
+    uint32_t _lastUpdate;
 };
 
 extern VeDirectFrameHandler VeDirect;
diff --git a/src/Battery.cpp b/src/Battery.cpp
index 661665ac3..805a5779b 100644
--- a/src/Battery.cpp
+++ b/src/Battery.cpp
@@ -1,4 +1,69 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include "Battery.h"
+#include "MessageOutput.h"
+#include "MqttSettings.h"
+#include "PylontechCanReceiver.h"
+#include "JkBmsController.h"
 
 BatteryClass Battery;
+
+std::shared_ptr<BatteryStats const> BatteryClass::getStats() const
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    if (!_upProvider) {
+        static auto sspDummyStats = std::make_shared<BatteryStats>();
+        return sspDummyStats;
+    }
+
+    return _upProvider->getStats();
+}
+
+void BatteryClass::init()
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    if (_upProvider) {
+        _upProvider->deinit();
+        _upProvider = nullptr;
+    }
+
+    CONFIG_T& config = Configuration.get();
+    if (!config.Battery_Enabled) { return; }
+
+    bool verboseLogging = config.Battery_VerboseLogging;
+
+    switch (config.Battery_Provider) {
+        case 0:
+            _upProvider = std::make_unique<PylontechCanReceiver>();
+            if (!_upProvider->init(verboseLogging)) { _upProvider = nullptr; }
+            break;
+        case 1:
+            _upProvider = std::make_unique<JkBms::Controller>();
+            if (!_upProvider->init(verboseLogging)) { _upProvider = nullptr; }
+            break;
+        default:
+            MessageOutput.printf("Unknown battery provider: %d\r\n", config.Battery_Provider);
+            break;
+    }
+}
+
+void BatteryClass::loop()
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    if (!_upProvider) { return; }
+
+    _upProvider->loop();
+
+    CONFIG_T& config = Configuration.get();
+
+    if (!MqttSettings.getConnected()
+            || (millis() - _lastMqttPublish) < (config.Mqtt_PublishInterval * 1000)) {
+        return;
+    }
+
+    _upProvider->getStats()->mqttPublish();
+
+    _lastMqttPublish = millis();
+}
diff --git a/src/BatteryStats.cpp b/src/BatteryStats.cpp
new file mode 100644
index 000000000..2c4997e97
--- /dev/null
+++ b/src/BatteryStats.cpp
@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include "BatteryStats.h"
+#include "MqttSettings.h"
+#include "JkBmsDataPoints.h"
+
+template<typename T>
+void BatteryStats::addLiveViewValue(JsonVariant& root, std::string const& name,
+    T&& value, std::string const& unit, uint8_t precision) const
+{
+    auto jsonValue = root["values"][name];
+    jsonValue["v"] = value;
+    jsonValue["u"] = unit;
+    jsonValue["d"] = precision;
+}
+
+void BatteryStats::addLiveViewText(JsonVariant& root, std::string const& name,
+    std::string const& text) const
+{
+    root["values"][name] = text;
+}
+
+void BatteryStats::addLiveViewWarning(JsonVariant& root, std::string const& name,
+    bool warning) const
+{
+    if (!warning) { return; }
+    root["issues"][name] = 1;
+}
+
+void BatteryStats::addLiveViewAlarm(JsonVariant& root, std::string const& name,
+    bool alarm) const
+{
+    if (!alarm) { return; }
+    root["issues"][name] = 2;
+}
+
+void BatteryStats::getLiveViewData(JsonVariant& root) const
+{
+    root[F("manufacturer")] = _manufacturer;
+    root[F("data_age")] = getAgeSeconds();
+
+    addLiveViewValue(root, "SoC", _SoC, "%", 0);
+}
+
+void PylontechBatteryStats::getLiveViewData(JsonVariant& root) const
+{
+    BatteryStats::getLiveViewData(root);
+
+    // 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, "voltage", _voltage, "V", 2);
+    addLiveViewValue(root, "current", _current, "A", 1);
+    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
+
+    addLiveViewText(root, "chargeEnabled", (_chargeEnabled?"yes":"no"));
+    addLiveViewText(root, "dischargeEnabled", (_dischargeEnabled?"yes":"no"));
+    addLiveViewText(root, "chargeImmediately", (_chargeImmediately?"yes":"no"));
+
+    // alarms and warnings go into the "Issues" card of the web application
+    addLiveViewWarning(root, "highCurrentDischarge", _warningHighCurrentDischarge);
+    addLiveViewAlarm(root, "overCurrentDischarge", _alarmOverCurrentDischarge);
+
+    addLiveViewWarning(root, "highCurrentCharge", _warningHighCurrentCharge);
+    addLiveViewAlarm(root, "overCurrentCharge", _alarmOverCurrentCharge);
+
+    addLiveViewWarning(root, "lowTemperature", _warningLowTemperature);
+    addLiveViewAlarm(root, "underTemperature", _alarmUnderTemperature);
+
+    addLiveViewWarning(root, "highTemperature", _warningHighTemperature);
+    addLiveViewAlarm(root, "overTemperature", _alarmOverTemperature);
+
+    addLiveViewWarning(root, "lowVoltage", _warningLowVoltage);
+    addLiveViewAlarm(root, "underVoltage", _alarmUnderVoltage);
+
+    addLiveViewWarning(root, "highVoltage", _warningHighVoltage);
+    addLiveViewAlarm(root, "overVoltage", _alarmOverVoltage);
+
+    addLiveViewWarning(root, "bmsInternal", _warningBmsInternal);
+    addLiveViewAlarm(root, "bmsInternal", _alarmBmsInternal);
+}
+
+void JkBmsBatteryStats::getLiveViewData(JsonVariant& root) const
+{
+    BatteryStats::getLiveViewData(root);
+
+    using Label = JkBms::DataPointLabel;
+
+    auto oVoltage = _dataPoints.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value()) {
+        addLiveViewValue(root, "voltage",
+                static_cast<float>(*oVoltage) / 1000, "V", 2);
+    }
+
+    auto oCurrent = _dataPoints.get<Label::BatteryCurrentMilliAmps>();
+    if (oCurrent.has_value()) {
+        addLiveViewValue(root, "current",
+                static_cast<float>(*oCurrent) / 1000, "A", 2);
+    }
+
+    auto oTemperature = _dataPoints.get<Label::BatteryTempOneCelsius>();
+    if (oTemperature.has_value()) {
+        addLiveViewValue(root, "temperature", *oTemperature, "°C", 0);
+    }
+}
+
+void BatteryStats::mqttPublish() const
+{
+    MqttSettings.publish(F("battery/manufacturer"), _manufacturer);
+    MqttSettings.publish(F("battery/dataAge"), String(getAgeSeconds()));
+    MqttSettings.publish(F("battery/stateOfCharge"), String(_SoC));
+}
+
+void PylontechBatteryStats::mqttPublish() const
+{
+    BatteryStats::mqttPublish();
+
+    MqttSettings.publish(F("battery/settings/chargeVoltage"), String(_chargeVoltage));
+    MqttSettings.publish(F("battery/settings/chargeCurrentLimitation"), String(_chargeCurrentLimitation));
+    MqttSettings.publish(F("battery/settings/dischargeCurrentLimitation"), String(_dischargeCurrentLimitation));
+    MqttSettings.publish(F("battery/stateOfHealth"), String(_stateOfHealth));
+    MqttSettings.publish(F("battery/voltage"), String(_voltage));
+    MqttSettings.publish(F("battery/current"), String(_current));
+    MqttSettings.publish(F("battery/temperature"), String(_temperature));
+    MqttSettings.publish(F("battery/alarm/overCurrentDischarge"), String(_alarmOverCurrentDischarge));
+    MqttSettings.publish(F("battery/alarm/overCurrentCharge"), String(_alarmOverCurrentCharge));
+    MqttSettings.publish(F("battery/alarm/underTemperature"), String(_alarmUnderTemperature));
+    MqttSettings.publish(F("battery/alarm/overTemperature"), String(_alarmOverTemperature));
+    MqttSettings.publish(F("battery/alarm/underVoltage"), String(_alarmUnderVoltage));
+    MqttSettings.publish(F("battery/alarm/overVoltage"), String(_alarmOverVoltage));
+    MqttSettings.publish(F("battery/alarm/bmsInternal"), String(_alarmBmsInternal));
+    MqttSettings.publish(F("battery/warning/highCurrentDischarge"), String(_warningHighCurrentDischarge));
+    MqttSettings.publish(F("battery/warning/highCurrentCharge"), String(_warningHighCurrentCharge));
+    MqttSettings.publish(F("battery/warning/lowTemperature"), String(_warningLowTemperature));
+    MqttSettings.publish(F("battery/warning/highTemperature"), String(_warningHighTemperature));
+    MqttSettings.publish(F("battery/warning/lowVoltage"), String(_warningLowVoltage));
+    MqttSettings.publish(F("battery/warning/highVoltage"), String(_warningHighVoltage));
+    MqttSettings.publish(F("battery/warning/bmsInternal"), String(_warningBmsInternal));
+    MqttSettings.publish(F("battery/charging/chargeEnabled"), String(_chargeEnabled));
+    MqttSettings.publish(F("battery/charging/dischargeEnabled"), String(_dischargeEnabled));
+    MqttSettings.publish(F("battery/charging/chargeImmediately"), String(_chargeImmediately));
+}
+
+void JkBmsBatteryStats::mqttPublish() const
+{
+    BatteryStats::mqttPublish();
+}
+
+void JkBmsBatteryStats::updateFrom(JkBms::DataPointContainer const& dp)
+{
+    _dataPoints.updateFrom(dp);
+
+    using Label = JkBms::DataPointLabel;
+
+    _manufacturer = "JKBMS";
+    auto oProductId = _dataPoints.get<Label::ProductId>();
+    if (oProductId.has_value()) {
+        _manufacturer = oProductId->c_str();
+        auto pos = oProductId->rfind("JK");
+        if (pos != std::string::npos) {
+            _manufacturer = oProductId->substr(pos).c_str();
+        }
+    }
+
+    auto oSoCValue = _dataPoints.get<Label::BatterySoCPercent>();
+    if (oSoCValue.has_value()) {
+        _SoC = *oSoCValue;
+        auto oSoCDataPoint = _dataPoints.getDataPointFor<Label::BatterySoCPercent>();
+        _lastUpdateSoC = oSoCDataPoint->getTimestamp();
+    }
+
+    _lastUpdate = millis();
+}
diff --git a/src/Configuration.cpp b/src/Configuration.cpp
index 6389a490c..909e64dd8 100644
--- a/src/Configuration.cpp
+++ b/src/Configuration.cpp
@@ -123,6 +123,7 @@ bool ConfigurationClass::write()
 
     JsonObject vedirect = doc.createNestedObject("vedirect");
     vedirect["enabled"] = config.Vedirect_Enabled;
+    vedirect["verbose_logging"] = config.Vedirect_VerboseLogging;
     vedirect["updates_only"] = config.Vedirect_UpdatesOnly;
 
     JsonObject powermeter = doc.createNestedObject("powermeter");
@@ -178,6 +179,10 @@ bool ConfigurationClass::write()
 
     JsonObject battery = doc.createNestedObject("battery");
     battery["enabled"] = config.Battery_Enabled;
+    battery["verbose_logging"] = config.Battery_VerboseLogging;
+    battery["provider"] = config.Battery_Provider;
+    battery["jkbms_interface"] = config.Battery_JkBmsInterface;
+    battery["jkbms_polling_interval"] = config.Battery_JkBmsPollingInterval;
 
     JsonObject huawei = doc.createNestedObject("huawei");
     huawei["enabled"] = config.Huawei_Enabled;
@@ -337,6 +342,7 @@ bool ConfigurationClass::read()
 
     JsonObject vedirect = doc["vedirect"];
     config.Vedirect_Enabled = vedirect["enabled"] | VEDIRECT_ENABLED;
+    config.Vedirect_VerboseLogging = vedirect["verbose_logging"] | VEDIRECT_VERBOSE_LOGGING;
     config.Vedirect_UpdatesOnly = vedirect["updates_only"] | VEDIRECT_UPDATESONLY;
 
     JsonObject powermeter = doc["powermeter"];
@@ -392,6 +398,10 @@ bool ConfigurationClass::read()
 
     JsonObject battery = doc["battery"];
     config.Battery_Enabled = battery["enabled"] | BATTERY_ENABLED;
+    config.Battery_VerboseLogging = battery["verbose_logging"] | VERBOSE_LOGGING;
+    config.Battery_Provider = battery["provider"] | BATTERY_PROVIDER;
+    config.Battery_JkBmsInterface = battery["jkbms_interface"] | BATTERY_JKBMS_INTERFACE;
+    config.Battery_JkBmsPollingInterval = battery["jkbms_polling_interval"] | BATTERY_JKBMS_POLLING_INTERVAL;
 
     JsonObject huawei = doc["huawei"];
     config.Huawei_Enabled = huawei["enabled"] | HUAWEI_ENABLED;
diff --git a/src/JkBmsController.cpp b/src/JkBmsController.cpp
new file mode 100644
index 000000000..b1ef8b5aa
--- /dev/null
+++ b/src/JkBmsController.cpp
@@ -0,0 +1,352 @@
+#include <Arduino.h>
+#include "Configuration.h"
+#include "HardwareSerial.h"
+#include "PinMapping.h"
+#include "MessageOutput.h"
+#include "JkBmsDataPoints.h"
+#include "JkBmsController.h"
+#include <map>
+
+//#define JKBMS_DUMMY_SERIAL
+
+#ifdef JKBMS_DUMMY_SERIAL
+class DummySerial {
+    public:
+        DummySerial() = default;
+        void begin(uint32_t, uint32_t, int8_t, int8_t) {
+            MessageOutput.println("JK BMS Dummy Serial: begin()");
+        }
+        void end() { MessageOutput.println("JK BMS Dummy Serial: end()"); }
+        void flush() { }
+        bool availableForWrite() const { return true; }
+        size_t write(const uint8_t *buffer, size_t size) {
+            MessageOutput.printf("JK BMS Dummy Serial: write(%d Bytes)\r\n", size);
+            _byte_idx = 0;
+            _msg_idx = (_msg_idx + 1) % _data.size();
+            return size;
+        }
+        bool available() const {
+            return _byte_idx < _data[_msg_idx].size();
+        }
+        int read() {
+            if (_byte_idx >= _data[_msg_idx].size()) { return 0; }
+            return _data[_msg_idx][_byte_idx++];
+        }
+
+    private:
+        std::vector<std::vector<uint8_t>> const _data =
+        {
+            {
+                0x4e, 0x57, 0x01, 0x21, 0x00, 0x00, 0x00, 0x00,
+                0x06, 0x00, 0x01, 0x79, 0x30, 0x01, 0x0c, 0xfb,
+                0x02, 0x0c, 0xfb, 0x03, 0x0c, 0xfb, 0x04, 0x0c,
+                0xfb, 0x05, 0x0c, 0xfb, 0x06, 0x0c, 0xfb, 0x07,
+                0x0c, 0xfb, 0x08, 0x0c, 0xf7, 0x09, 0x0d, 0x01,
+                0x0a, 0x0c, 0xf9, 0x0b, 0x0c, 0xfb, 0x0c, 0x0c,
+                0xfb, 0x0d, 0x0c, 0xfb, 0x0e, 0x0c, 0xf8, 0x0f,
+                0x0c, 0xf9, 0x10, 0x0c, 0xfb, 0x80, 0x00, 0x1a,
+                0x81, 0x00, 0x12, 0x82, 0x00, 0x12, 0x83, 0x14,
+                0xc3, 0x84, 0x83, 0xf4, 0x85, 0x2e, 0x86, 0x02,
+                0x87, 0x00, 0x15, 0x89, 0x00, 0x00, 0x13, 0x52,
+                0x8a, 0x00, 0x10, 0x8b, 0x00, 0x00, 0x8c, 0x00,
+                0x03, 0x8e, 0x16, 0x80, 0x8f, 0x12, 0xc0, 0x90,
+                0x0e, 0x10, 0x91, 0x0c, 0xda, 0x92, 0x00, 0x05,
+                0x93, 0x0b, 0xb8, 0x94, 0x0c, 0x80, 0x95, 0x00,
+                0x05, 0x96, 0x01, 0x2c, 0x97, 0x00, 0x28, 0x98,
+                0x01, 0x2c, 0x99, 0x00, 0x28, 0x9a, 0x00, 0x1e,
+                0x9b, 0x0b, 0xb8, 0x9c, 0x00, 0x0a, 0x9d, 0x01,
+                0x9e, 0x00, 0x64, 0x9f, 0x00, 0x50, 0xa0, 0x00,
+                0x64, 0xa1, 0x00, 0x64, 0xa2, 0x00, 0x14, 0xa3,
+                0x00, 0x46, 0xa4, 0x00, 0x46, 0xa5, 0x00, 0x00,
+                0xa6, 0x00, 0x02, 0xa7, 0xff, 0xec, 0xa8, 0xff,
+                0xf6, 0xa9, 0x10, 0xaa, 0x00, 0x00, 0x00, 0xe6,
+                0xab, 0x01, 0xac, 0x01, 0xad, 0x04, 0x4d, 0xae,
+                0x01, 0xaf, 0x00, 0xb0, 0x00, 0x0a, 0xb1, 0x14,
+                0xb2, 0x32, 0x32, 0x31, 0x31, 0x38, 0x37, 0x00,
+                0x00, 0x00, 0x00, 0xb3, 0x00, 0xb4, 0x62, 0x65,
+                0x6b, 0x69, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x32,
+                0x33, 0x30, 0x36, 0xb6, 0x00, 0x01, 0x4a, 0xc3,
+                0xb7, 0x31, 0x31, 0x2e, 0x58, 0x57, 0x5f, 0x53,
+                0x31, 0x31, 0x2e, 0x32, 0x36, 0x32, 0x48, 0x5f,
+                0xb8, 0x00, 0xb9, 0x00, 0x00, 0x00, 0xe6, 0xba,
+                0x62, 0x65, 0x6b, 0x69, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x4a, 0x4b, 0x5f, 0x42,
+                0x31, 0x41, 0x32, 0x34, 0x53, 0x31, 0x35, 0x50,
+                0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00,
+                0x00, 0x53, 0xbb
+            },
+            {
+                0x4e, 0x57, 0x01, 0x21, 0x00, 0x00, 0x00, 0x00,
+                0x06, 0x00, 0x01, 0x79, 0x30, 0x01, 0x0c, 0xc0,
+                0x02, 0x0c, 0xc1, 0x03, 0x0c, 0xc0, 0x04, 0x0c,
+                0xc4, 0x05, 0x0c, 0xc4, 0x06, 0x0c, 0xc2, 0x07,
+                0x0c, 0xc2, 0x08, 0x0c, 0xc1, 0x09, 0x0c, 0xba,
+                0x0a, 0x0c, 0xc1, 0x0b, 0x0c, 0xc2, 0x0c, 0x0c,
+                0xc2, 0x0d, 0x0c, 0xc2, 0x0e, 0x0c, 0xc4, 0x0f,
+                0x0c, 0xc2, 0x10, 0x0c, 0xc1, 0x80, 0x00, 0x1b,
+                0x81, 0x00, 0x1b, 0x82, 0x00, 0x1a, 0x83, 0x14,
+                0x68, 0x84, 0x03, 0x70, 0x85, 0x3c, 0x86, 0x02,
+                0x87, 0x00, 0x19, 0x89, 0x00, 0x00, 0x16, 0x86,
+                0x8a, 0x00, 0x10, 0x8b, 0x00, 0x00, 0x8c, 0x00,
+                0x07, 0x8e, 0x16, 0x80, 0x8f, 0x12, 0xc0, 0x90,
+                0x0e, 0x10, 0x91, 0x0c, 0xda, 0x92, 0x00, 0x05,
+                0x93, 0x0b, 0xb8, 0x94, 0x0c, 0x80, 0x95, 0x00,
+                0x05, 0x96, 0x01, 0x2c, 0x97, 0x00, 0x28, 0x98,
+                0x01, 0x2c, 0x99, 0x00, 0x28, 0x9a, 0x00, 0x1e,
+                0x9b, 0x0b, 0xb8, 0x9c, 0x00, 0x0a, 0x9d, 0x01,
+                0x9e, 0x00, 0x64, 0x9f, 0x00, 0x50, 0xa0, 0x00,
+                0x64, 0xa1, 0x00, 0x64, 0xa2, 0x00, 0x14, 0xa3,
+                0x00, 0x46, 0xa4, 0x00, 0x46, 0xa5, 0x00, 0x00,
+                0xa6, 0x00, 0x02, 0xa7, 0xff, 0xec, 0xa8, 0xff,
+                0xf6, 0xa9, 0x10, 0xaa, 0x00, 0x00, 0x00, 0xe6,
+                0xab, 0x01, 0xac, 0x01, 0xad, 0x04, 0x4d, 0xae,
+                0x01, 0xaf, 0x00, 0xb0, 0x00, 0x0a, 0xb1, 0x14,
+                0xb2, 0x32, 0x32, 0x31, 0x31, 0x38, 0x37, 0x00,
+                0x00, 0x00, 0x00, 0xb3, 0x00, 0xb4, 0x62, 0x65,
+                0x6b, 0x69, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x32,
+                0x33, 0x30, 0x36, 0xb6, 0x00, 0x01, 0x7f, 0x2a,
+                0xb7, 0x31, 0x31, 0x2e, 0x58, 0x57, 0x5f, 0x53,
+                0x31, 0x31, 0x2e, 0x32, 0x36, 0x32, 0x48, 0x5f,
+                0xb8, 0x00, 0xb9, 0x00, 0x00, 0x00, 0xe6, 0xba,
+                0x62, 0x65, 0x6b, 0x69, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x4a, 0x4b, 0x5f, 0x42,
+                0x31, 0x41, 0x32, 0x34, 0x53, 0x31, 0x35, 0x50,
+                0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00,
+                0x00, 0x4f, 0xc1
+            }
+        };
+        size_t _msg_idx = 0;
+        size_t _byte_idx = 0;
+};
+DummySerial HwSerial;
+#else
+HardwareSerial HwSerial(2);
+#endif
+
+namespace JkBms {
+
+bool Controller::init(bool verboseLogging)
+{
+    _verboseLogging = verboseLogging;
+
+    std::string ifcType = "transceiver";
+    if (Interface::Transceiver != getInterface()) { ifcType = "TTL-UART"; }
+    MessageOutput.printf("[JK BMS] Initialize %s interface...\r\n", ifcType.c_str());
+
+    const PinMapping_t& pin = PinMapping.get();
+    MessageOutput.printf("[JK 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(F("[JK BMS] Invalid RX/TX pin config"));
+        return false;
+    }
+
+    HwSerial.begin(115200, SERIAL_8N1, pin.battery_rx, pin.battery_tx);
+    HwSerial.flush();
+
+    if (Interface::Transceiver != getInterface()) { return true; }
+
+    _rxEnablePin = pin.battery_rxen;
+    _txEnablePin = pin.battery_txen;
+
+    if (_rxEnablePin < 0 || _txEnablePin < 0) {
+        MessageOutput.println(F("[JK BMS] Invalid transceiver pin config"));
+        return false;
+    }
+
+    pinMode(_rxEnablePin, OUTPUT);
+    pinMode(_txEnablePin, OUTPUT);
+
+    return true;
+}
+
+void Controller::deinit()
+{
+    HwSerial.end();
+
+    if (_rxEnablePin > 0) { pinMode(_rxEnablePin, INPUT); }
+    if (_txEnablePin > 0) { pinMode(_txEnablePin, INPUT); }
+}
+
+Controller::Interface Controller::getInterface() const
+{
+    CONFIG_T& config = Configuration.get();
+    if (0x00 == config.Battery_JkBmsInterface) { return Interface::Uart; }
+    if (0x01 == config.Battery_JkBmsInterface) { return Interface::Transceiver; }
+    return Interface::Invalid;
+}
+
+std::string const& Controller::getStatusText(Controller::Status status)
+{
+    static const std::string missing =  "programmer error: missing status text";
+
+    static const std::map<Status, const std::string> 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] JK BMS: %s\r\n",
+        static_cast<double>(millis())/1000, getStatusText(status).c_str());
+
+    _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 (!HwSerial.availableForWrite()) {
+        return announceStatus(Status::HwSerialNotAvailableForWrite);
+    }
+
+    SerialCommand readAll(SerialCommand::Command::ReadAll);
+
+    if (Interface::Transceiver == getInterface()) {
+        digitalWrite(_rxEnablePin, HIGH); // disable reception (of our own data)
+        digitalWrite(_txEnablePin, HIGH); // enable transmission
+    }
+
+    HwSerial.write(readAll.data(), readAll.size());
+
+    if (Interface::Transceiver == getInterface()) {
+        HwSerial.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()
+{
+    CONFIG_T& config = Configuration.get();
+    uint8_t pollInterval = config.Battery_JkBmsPollingInterval;
+
+    while (HwSerial.available()) {
+        rxData(HwSerial.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 == 0x4E) {
+                return setReadState(ReadState::FrameStartReceived);
+            }
+            break;
+        case ReadState::FrameStartReceived:
+            if (inbyte == 0x57) {
+                return setReadState(ReadState::StartMarkerReceived);
+            }
+            break;
+        case ReadState::StartMarkerReceived:
+            _frameLength = inbyte << 8 | 0x00;
+            return setReadState(ReadState::FrameLengthMsbReceived);
+            break;
+        case ReadState::FrameLengthMsbReceived:
+            _frameLength |= inbyte;
+            _frameLength -= 2; // length field already read
+            return setReadState(ReadState::ReadingFrame);
+            break;
+        case ReadState::ReadingFrame:
+            _frameLength--;
+            if (_frameLength == 0) {
+                return frameComplete();
+            }
+            return setReadState(ReadState::ReadingFrame);
+            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] JK 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] JK BMS: ", ts);
+            }
+            MessageOutput.printf("%02x ", _buffer[ctr]);
+        }
+        MessageOutput.println();
+    }
+
+    auto pResponse = std::make_unique<SerialResponse>(std::move(_buffer), _protocolVersion);
+    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);
+
+    using Label = JkBms::DataPointLabel;
+
+    auto oProtocolVersion = dataPoints.get<Label::ProtocolVersion>();
+    if (oProtocolVersion.has_value()) { _protocolVersion = *oProtocolVersion; }
+
+    if (!_verboseLogging) { return; }
+
+    auto iter = dataPoints.cbegin();
+    while ( iter != dataPoints.cend() ) {
+        MessageOutput.printf("[%11.3f] JK 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 JkBms */
diff --git a/src/JkBmsDataPoints.cpp b/src/JkBmsDataPoints.cpp
new file mode 100644
index 000000000..471b9daf1
--- /dev/null
+++ b/src/JkBmsDataPoints.cpp
@@ -0,0 +1,56 @@
+#include <stdio.h>
+
+#include "JkBmsDataPoints.h"
+
+namespace JkBms {
+
+static char conversionBuffer[16];
+
+template<typename T>
+std::string dataPointValueToStr(T const& v) {
+    snprintf(conversionBuffer, sizeof(conversionBuffer), "%d", v);
+    return conversionBuffer;
+}
+
+// explicit instanciations for the above unspecialized implementation
+template std::string dataPointValueToStr(int16_t const& v);
+template std::string dataPointValueToStr(int32_t const& v);
+template std::string dataPointValueToStr(uint8_t const& v);
+template std::string dataPointValueToStr(uint16_t const& v);
+template std::string dataPointValueToStr(uint32_t const& v);
+
+template<>
+std::string dataPointValueToStr(std::string const& v) {
+    return v;
+}
+
+template<>
+std::string dataPointValueToStr(bool const& v) {
+    return v?"yes":"no";
+}
+
+template<>
+std::string dataPointValueToStr(tCells const& v) {
+    std::string res;
+    res.reserve(v.size()*(2+2+1+4)); // separator, index, equal sign, value
+    res += "(";
+    std::string sep = "";
+    for(auto const& mapval : v) {
+        snprintf(conversionBuffer, sizeof(conversionBuffer), "%s%d=%d",
+                sep.c_str(), mapval.first, mapval.second);
+        res += conversionBuffer;
+        sep = ", ";
+    }
+    res += ")";
+    return std::move(res);
+}
+
+void DataPointContainer::updateFrom(DataPointContainer const& source)
+{
+    for (auto iter = source.cbegin(); iter != source.cend(); ++iter) {
+        _dataPoints.erase(iter->first);
+        _dataPoints.insert(*iter);
+    }
+}
+
+} /* namespace JkBms */
diff --git a/src/JkBmsSerialMessage.cpp b/src/JkBmsSerialMessage.cpp
new file mode 100644
index 000000000..95744a6d1
--- /dev/null
+++ b/src/JkBmsSerialMessage.cpp
@@ -0,0 +1,363 @@
+#include <numeric>
+
+#include "JkBmsSerialMessage.h"
+#include "MessageOutput.h"
+
+namespace JkBms {
+
+SerialCommand::SerialCommand(SerialCommand::Command cmd)
+    : SerialMessage(20, 0x00)
+{
+    set(_raw.begin(), startMarker);
+    set(_raw.begin() + 2, static_cast<uint16_t>(_raw.size() - 2)); // frame length
+    set(_raw.begin() + 8, static_cast<uint8_t>(cmd));
+    set(_raw.begin() + 9, static_cast<uint8_t>(Source::Host));
+    set(_raw.begin() + 10, static_cast<uint8_t>(Type::Command));
+    set(_raw.end() - 5, endMarker);
+    updateChecksum();
+}
+
+using Label = JkBms::DataPointLabel;
+template<Label L> using Traits = DataPointLabelTraits<L>;
+
+SerialResponse::SerialResponse(tData&& raw, uint8_t protocolVersion)
+    : SerialMessage(std::move(raw))
+{
+    if (!isValid()) { return; }
+
+    auto pos = _raw.cbegin() + 11;
+    auto end = pos + getVariableFieldLength();
+
+    while ( pos < end ) {
+        uint8_t fieldType = *(pos++);
+
+        /**
+         * there seems to be no way to make this more generic. the main reason
+         * is that a non-constexpr value (fieldType cast as Label) cannot be
+         * used as a template parameter.
+         */
+        switch(fieldType) {
+            case 0x79:
+            {
+                uint8_t cellAmount = *(pos++) / 3;
+                std::map<uint8_t, uint16_t> voltages;
+                for (size_t cellCounter = 0; cellCounter < cellAmount; ++cellCounter) {
+                    uint8_t idx = *(pos++);
+                    auto cellMilliVolt = get<uint16_t>(pos);
+                    voltages[idx] = cellMilliVolt;
+                }
+                _dp.add<Label::CellsMilliVolt>(voltages);
+                break;
+            }
+            case 0x80:
+                _dp.add<Label::BmsTempCelsius>(getTemperature(pos));
+                break;
+            case 0x81:
+                _dp.add<Label::BatteryTempOneCelsius>(getTemperature(pos));
+                break;
+            case 0x82:
+                _dp.add<Label::BatteryTempTwoCelsius>(getTemperature(pos));
+                break;
+            case 0x83:
+                _dp.add<Label::BatteryVoltageMilliVolt>(static_cast<uint32_t>(get<uint16_t>(pos)) * 10);
+                break;
+            case 0x84:
+                processBatteryCurrent(pos, protocolVersion);
+                break;
+            case 0x85:
+                _dp.add<Label::BatterySoCPercent>(get<uint8_t>(pos));
+                break;
+            case 0x86:
+                _dp.add<Label::BatteryTemperatureSensorAmount>(get<uint8_t>(pos));
+                break;
+            case 0x87:
+                _dp.add<Label::BatteryCycles>(get<uint16_t>(pos));
+                break;
+            case 0x89:
+                _dp.add<Label::BatteryCycleCapacity>(get<uint32_t>(pos));
+                break;
+            case 0x8a:
+                _dp.add<Label::BatteryCellAmount>(get<uint16_t>(pos));
+                break;
+            case 0x8b:
+                _dp.add<Label::AlarmsBitmask>(get<uint16_t>(pos));
+                break;
+            case 0x8c:
+                _dp.add<Label::StatusBitmask>(get<uint16_t>(pos));
+                break;
+            case 0x8e:
+                _dp.add<Label::TotalOvervoltageThresholdMilliVolt>(static_cast<uint32_t>(get<uint16_t>(pos)) * 10);
+                break;
+            case 0x8f:
+                _dp.add<Label::TotalUndervoltageThresholdMilliVolt>(static_cast<uint32_t>(get<uint16_t>(pos)) * 10);
+                break;
+            case 0x90:
+                _dp.add<Label::CellOvervoltageThresholdMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x91:
+                _dp.add<Label::CellOvervoltageRecoveryMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x92:
+                _dp.add<Label::CellOvervoltageProtectionDelaySeconds>(get<uint16_t>(pos));
+                break;
+            case 0x93:
+                _dp.add<Label::CellUndervoltageThresholdMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x94:
+                _dp.add<Label::CellUndervoltageRecoveryMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x95:
+                _dp.add<Label::CellUndervoltageProtectionDelaySeconds>(get<uint16_t>(pos));
+                break;
+            case 0x96:
+                _dp.add<Label::CellVoltageDiffThresholdMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x97:
+                _dp.add<Label::DischargeOvercurrentThresholdAmperes>(get<uint16_t>(pos));
+                break;
+            case 0x98:
+                _dp.add<Label::DischargeOvercurrentDelaySeconds>(get<uint16_t>(pos));
+                break;
+            case 0x99:
+                _dp.add<Label::ChargeOvercurrentThresholdAmps>(get<uint16_t>(pos));
+                break;
+            case 0x9a:
+                _dp.add<Label::ChargeOvercurrentDelaySeconds>(get<uint16_t>(pos));
+                break;
+            case 0x9b:
+                _dp.add<Label::BalanceCellVoltageThresholdMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x9c:
+                _dp.add<Label::BalanceVoltageDiffThresholdMilliVolt>(get<uint16_t>(pos));
+                break;
+            case 0x9d:
+                _dp.add<Label::BalancingEnabled>(get<bool>(pos));
+                break;
+            case 0x9e:
+                _dp.add<Label::BmsTempProtectionThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0x9f:
+                _dp.add<Label::BmsTempRecoveryThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0xa0:
+                _dp.add<Label::BatteryTempProtectionThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0xa1:
+                _dp.add<Label::BatteryTempRecoveryThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0xa2:
+                _dp.add<Label::BatteryTempDiffThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0xa3:
+                _dp.add<Label::ChargeHighTempThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0xa4:
+                _dp.add<Label::DischargeHighTempThresholdCelsius>(get<uint16_t>(pos));
+                break;
+            case 0xa5:
+                _dp.add<Label::ChargeLowTempThresholdCelsius>(get<int16_t>(pos));
+                break;
+            case 0xa6:
+                _dp.add<Label::ChargeLowTempRecoveryCelsius>(get<int16_t>(pos));
+                break;
+            case 0xa7:
+                _dp.add<Label::DischargeLowTempThresholdCelsius>(get<int16_t>(pos));
+                break;
+            case 0xa8:
+                _dp.add<Label::DischargeLowTempRecoveryCelsius>(get<int16_t>(pos));
+                break;
+            case 0xa9:
+                _dp.add<Label::CellAmountSetting>(get<uint8_t>(pos));
+                break;
+            case 0xaa:
+                _dp.add<Label::BatteryCapacitySettingAmpHours>(get<uint32_t>(pos));
+                break;
+            case 0xab:
+                _dp.add<Label::BatteryChargeEnabled>(get<bool>(pos));
+                break;
+            case 0xac:
+                _dp.add<Label::BatteryDischargeEnabled>(get<bool>(pos));
+                break;
+            case 0xad:
+                _dp.add<Label::CurrentCalibrationMilliAmps>(get<uint16_t>(pos));
+                break;
+            case 0xae:
+                _dp.add<Label::BmsAddress>(get<uint8_t>(pos));
+                break;
+            case 0xaf:
+                _dp.add<Label::BatteryType>(get<uint8_t>(pos));
+                break;
+            case 0xb0:
+                _dp.add<Label::SleepWaitTime>(get<uint16_t>(pos));
+                break;
+            case 0xb1:
+                _dp.add<Label::LowCapacityAlarmThresholdPercent>(get<uint8_t>(pos));
+                break;
+            case 0xb2:
+                _dp.add<Label::ModificationPassword>(getString(pos, 10));
+                break;
+            case 0xb3:
+                _dp.add<Label::DedicatedChargerSwitch>(getBool(pos));
+                break;
+            case 0xb4:
+                _dp.add<Label::EquipmentId>(getString(pos, 8));
+                break;
+            case 0xb5:
+                _dp.add<Label::DateOfManufacturing >(getString(pos, 4));
+                break;
+            case 0xb6:
+                _dp.add<Label::BmsHourMeterMinutes>(get<uint32_t>(pos));
+                break;
+            case 0xb7:
+                _dp.add<Label::BmsSoftwareVersion>(getString(pos, 15));
+                break;
+            case 0xb8:
+                _dp.add<Label::CurrentCalibration>(getBool(pos));
+                break;
+            case 0xb9:
+                _dp.add<Label::ActualBatteryCapacityAmpHours>(get<uint32_t>(pos));
+                break;
+            case 0xba:
+                _dp.add<Label::ProductId>(getString(pos, 24, true));
+                break;
+            case 0xc0:
+                _dp.add<Label::ProtocolVersion>(get<uint8_t>(pos));
+                break;
+            default:
+                MessageOutput.printf("unknown field type 0x%02x\r\n", fieldType);
+                break;
+        }
+    }
+}
+
+/**
+ * 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
+{
+    uint16_t raw = get<uint16_t>(pos);
+    if (raw <= 100) { return static_cast<int16_t>(raw); }
+    return static_cast<int16_t>(raw - 100) * (-1);
+}
+
+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);
+}
+
+void SerialMessage::processBatteryCurrent(SerialMessage::tData::const_iterator& pos, uint8_t protocolVersion)
+{
+    uint16_t raw = get<uint16_t>(pos);
+
+    if (0x00 == protocolVersion) {
+        // untested!
+        _dp.add<Label::BatteryCurrentMilliAmps>((static_cast<int32_t>(10000) - raw) * 10);
+        return;
+    }
+    else if (0x01 == protocolVersion) {
+        bool charging = (raw & 0x8000) > 0;
+        _dp.add<Label::BatteryCurrentMilliAmps>(static_cast<int32_t>(raw & 0x7FFF) * (charging ? 10 : -10));
+        return;
+    }
+
+    MessageOutput.println("cannot decode battery current field without knowing the protocol version");
+}
+
+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(), _raw.cend()-4, 0);
+}
+
+void SerialMessage::updateChecksum()
+{
+    set(_raw.end()-2, calcChecksum());
+}
+
+bool SerialMessage::isValid() const {
+    uint16_t const actualStartMarker = get<uint16_t>(_raw.cbegin());
+    if (actualStartMarker != startMarker) {
+        MessageOutput.printf("JkBms::SerialMessage: invalid start marker %04x, expected 0x%04x\r\n",
+            actualStartMarker, startMarker);
+        return false;
+    }
+
+    uint16_t const frameLength = get<uint16_t>(_raw.cbegin()+2);
+    if (frameLength != _raw.size() - 2) {
+        MessageOutput.printf("JkBms::SerialMessage: unexpected frame length %04x, expected 0x%04x\r\n",
+            frameLength, _raw.size() - 2);
+        return false;
+    }
+
+    uint8_t const actualEndMarker = *(_raw.cend()-5);
+    if (actualEndMarker != endMarker) {
+        MessageOutput.printf("JkBms::SerialMessage: invalid end marker %02x, expected 0x%02x\r\n",
+            actualEndMarker, endMarker);
+        return false;
+    }
+
+    uint16_t const actualChecksum = get<uint16_t>(_raw.cend()-2);
+    uint16_t const expectedChecksum = calcChecksum();
+    if (actualChecksum != expectedChecksum) {
+        MessageOutput.printf("JkBms::SerialMessage: invalid checksum 0x%04x, expected 0x%04x\r\n",
+            actualChecksum, expectedChecksum);
+        return false;
+    }
+
+    return true;
+}
+
+} /* namespace JkBms */
diff --git a/src/MessageOutput.cpp b/src/MessageOutput.cpp
index 23c644bc9..79e53a4e5 100644
--- a/src/MessageOutput.cpp
+++ b/src/MessageOutput.cpp
@@ -2,54 +2,104 @@
 /*
  * Copyright (C) 2022 Thomas Basler and others
  */
+#include <HardwareSerial.h>
 #include "MessageOutput.h"
 
-#include <Arduino.h>
-
 MessageOutputClass MessageOutput;
 
 void MessageOutputClass::register_ws_output(AsyncWebSocket* output)
 {
+    std::lock_guard<std::mutex> lock(_msgLock);
+
     _ws = output;
 }
 
+void MessageOutputClass::serialWrite(MessageOutputClass::message_t const& m)
+{
+    // on ESP32-S3, Serial.flush() blocks until a serial console is attached.
+    // operator bool() of HWCDC returns false if the device is not attached to
+    // a USB host. in general it makes sense to skip writing entirely if the
+    // default serial port is not ready.
+    if (!Serial) { return; }
+
+    size_t written = 0;
+    while (written < m.size()) {
+        written += Serial.write(m.data() + written, m.size() - written);
+    }
+    Serial.flush();
+}
+
 size_t MessageOutputClass::write(uint8_t c)
 {
-    if (_buff_pos < BUFFER_SIZE) {
-        std::lock_guard<std::mutex> lock(_msgLock);
-        _buffer[_buff_pos] = c;
-        _buff_pos++;
-    } else {
-        _forceSend = true;
+    std::lock_guard<std::mutex> lock(_msgLock);
+
+    auto res = _task_messages.emplace(xTaskGetCurrentTaskHandle(), message_t());
+    auto iter = res.first;
+    auto& message = iter->second;
+
+    message.push_back(c);
+
+    if (c == '\n') {
+        serialWrite(message);
+        _lines.emplace(std::move(message));
+        _task_messages.erase(iter);
     }
 
-    return Serial.write(c);
+    return 1;
 }
 
-size_t MessageOutputClass::write(const uint8_t* buffer, size_t size)
+size_t MessageOutputClass::write(const uint8_t *buffer, size_t size)
 {
     std::lock_guard<std::mutex> lock(_msgLock);
-    if (_buff_pos + size < BUFFER_SIZE) {
-        memcpy(&_buffer[_buff_pos], buffer, size);
-        _buff_pos += size;
+
+    auto res = _task_messages.emplace(xTaskGetCurrentTaskHandle(), message_t());
+    auto iter = res.first;
+    auto& message = iter->second;
+
+    message.reserve(message.size() + size);
+
+    for (size_t idx = 0; idx < size; ++idx) {
+        uint8_t c = buffer[idx];
+
+        message.push_back(c);
+
+        if (c == '\n') {
+            serialWrite(message);
+            _lines.emplace(std::move(message));
+            message.clear();
+            message.reserve(size - idx - 1);
+        }
     }
-    _forceSend = true;
 
-    return Serial.write(buffer, size);
+    if (message.empty()) { _task_messages.erase(iter); }
+
+    return size;
 }
 
 void MessageOutputClass::loop()
 {
-    // Send data via websocket if either time is over or buffer is full
-    if (_forceSend || (millis() - _lastSend > 1000)) {
-        std::lock_guard<std::mutex> lock(_msgLock);
-        if (_ws && _buff_pos > 0) {
-            _ws->textAll(_buffer, _buff_pos);
-            _buff_pos = 0;
+    std::lock_guard<std::mutex> lock(_msgLock);
+
+    // clean up (possibly filled) buffers of deleted tasks
+    auto map_iter = _task_messages.begin();
+    while (map_iter != _task_messages.end()) {
+        if (eTaskGetState(map_iter->first) == eDeleted) {
+            map_iter = _task_messages.erase(map_iter);
+            continue;
         }
-        if (_forceSend) {
-            _buff_pos = 0;
+
+        ++map_iter;
+    }
+
+    if (!_ws) {
+        while (!_lines.empty()) {
+            _lines.pop(); // do not hog memory
         }
-        _forceSend = false;
+        return;
+    }
+
+    while (!_lines.empty() && _ws->availableForWriteAll()) {
+        _ws->textAll(std::make_shared<message_t>(std::move(_lines.front())));
+        _lines.pop();
     }
 }
\ No newline at end of file
diff --git a/src/MqttHandlVedirectHass.cpp b/src/MqttHandlVedirectHass.cpp
index f6fbf19cc..687e9ac3b 100644
--- a/src/MqttHandlVedirectHass.cpp
+++ b/src/MqttHandlVedirectHass.cpp
@@ -55,32 +55,32 @@ void MqttHandleVedirectHassClass::publishConfig()
     }
 
     // device info
-    publishBinarySensor("MPPT load output state", "LOAD", "ON", "OFF");
-    publishSensor("MPPT serial number", "SER");
-    publishSensor("MPPT firmware number", "FW");
-    publishSensor("MPPT state of operation", "CS");
-    publishSensor("MPPT error code", "ERR");
-    publishSensor("MPPT off reason", "OR");
-    publishSensor("MPPT tracker operation mode", "MPPT");
-    publishSensor("MPPT Day sequence number (0...364)", "HSDS", NULL, "total", "d");
+    publishBinarySensor("MPPT load output state", "mdi:export", "LOAD", "ON", "OFF");
+    publishSensor("MPPT serial number", "mdi:counter", "SER");
+    publishSensor("MPPT firmware number", "mdi:counter", "FW");
+    publishSensor("MPPT state of operation", "mdi:wrench", "CS");
+    publishSensor("MPPT error code", "mdi:bell", "ERR");
+    publishSensor("MPPT off reason", "mdi:wrench", "OR");
+    publishSensor("MPPT tracker operation mode", "mdi:wrench", "MPPT");
+    publishSensor("MPPT Day sequence number (0...364)", "mdi:calendar-month-outline", "HSDS", NULL, "total", "d");
 
     // battery info
-    publishSensor("Battery voltage", "V", "voltage", "measurement", "V");
-    publishSensor("Battery current", "I", "current", "measurement", "A");
+    publishSensor("Battery voltage", NULL, "V", "voltage", "measurement", "V");
+    publishSensor("Battery current", NULL, "I", "current", "measurement", "A");
 
     // panel info
-    publishSensor("Panel voltage", "VPV", "voltage", "measurement", "V");
-    publishSensor("Panel power", "PPV", "power", "measurement", "W");
-    publishSensor("Panel yield total", "H19", "energy", "total_increasing", "kWh");
-    publishSensor("Panel yield today", "H20", "energy", "total", "kWh");
-    publishSensor("Panel maximum power today", "H21", "power", "measurement", "W");
-    publishSensor("Panel yield yesterday", "H22", "energy", "total", "kWh");
-    publishSensor("Panel maximum power yesterday", "H23", "power", "measurement", "W");
+    publishSensor("Panel voltage", NULL, "VPV", "voltage", "measurement", "V");
+    publishSensor("Panel power", NULL, "PPV", "power", "measurement", "W");
+    publishSensor("Panel yield total", NULL, "H19", "energy", "total_increasing", "kWh");
+    publishSensor("Panel yield today", NULL, "H20", "energy", "total", "kWh");
+    publishSensor("Panel maximum power today", NULL, "H21", "power", "measurement", "W");
+    publishSensor("Panel yield yesterday", NULL, "H22", "energy", "total", "kWh");
+    publishSensor("Panel maximum power yesterday", NULL, "H23", "power", "measurement", "W");
 
     yield();
 }
 
-void MqttHandleVedirectHassClass::publishSensor(const char* caption, const char* subTopic, const char* deviceClass, const char* stateClass, const char* unitOfMeasurement )
+void MqttHandleVedirectHassClass::publishSensor(const char* caption, const char* icon, const char* subTopic, const char* deviceClass, const char* stateClass, const char* unitOfMeasurement )
 {
     String serial = VeDirect.veFrame.SER;
 
@@ -105,6 +105,10 @@ void MqttHandleVedirectHassClass::publishSensor(const char* caption, const char*
     root[F("stat_t")] = statTopic;
     root[F("uniq_id")] = serial + "_" + sensorId;
 
+    if (icon != NULL) {
+        root[F("icon")] = icon;
+    }
+
     if (unitOfMeasurement != NULL) {
         root[F("unit_of_meas")] = unitOfMeasurement;
     }
@@ -127,7 +131,7 @@ void MqttHandleVedirectHassClass::publishSensor(const char* caption, const char*
     publish(configTopic, buffer);
 
 }
-void MqttHandleVedirectHassClass::publishBinarySensor(const char* caption, const char* subTopic, const char* payload_on, const char* payload_off)
+void MqttHandleVedirectHassClass::publishBinarySensor(const char* caption, const char* icon, const char* subTopic, const char* payload_on, const char* payload_off)
 {
     String serial = VeDirect.veFrame.SER;
 
@@ -154,6 +158,10 @@ void MqttHandleVedirectHassClass::publishBinarySensor(const char* caption, const
     root[F("pl_on")] = payload_on;
     root[F("pl_off")] = payload_off;
 
+    if (icon != NULL) {
+        root[F("icon")] = icon;
+    }
+
     JsonObject deviceObj = root.createNestedObject("dev");
     createDeviceInfo(deviceObj);
 
diff --git a/src/MqttHandlePylontechHass.cpp b/src/MqttHandlePylontechHass.cpp
index c11c5953c..7259cf91f 100644
--- a/src/MqttHandlePylontechHass.cpp
+++ b/src/MqttHandlePylontechHass.cpp
@@ -51,47 +51,47 @@ void MqttHandlePylontechHassClass::publishConfig()
     }
 
     // device info
-    publishSensor("Manufacturer", "manufacturer");
+    publishSensor("Manufacturer", "mdi:factory", "manufacturer");
 
     // battery info
-    publishSensor("Battery voltage", "voltage", "voltage", "measurement", "V");
-    publishSensor("Battery current", "current", "current", "measurement", "A");
-    publishSensor("Temperature", "temperature", "temperature", "measurement", "°C");
-    publishSensor("State of Charge (SOC)", "stateOfCharge", "battery", "measurement", "%");
-    publishSensor("State of Health (SOH)", "stateOfHealth", NULL, "measurement", "%");
-    publishSensor("Charge voltage (BMS)", "settings/chargeVoltage", "voltage", "measurement", "V");
-    publishSensor("Charge current limit", "settings/chargeCurrentLimitation", "current", "measurement", "A");
-    publishSensor("Discharge current limit", "settings/dischargeCurrentLimitation", "current", "measurement", "A");
+    publishSensor("Battery voltage", NULL, "voltage", "voltage", "measurement", "V");
+    publishSensor("Battery current", NULL, "current", "current", "measurement", "A");
+    publishSensor("Temperature", NULL, "temperature", "temperature", "measurement", "°C");
+    publishSensor("State of Charge (SOC)", NULL, "stateOfCharge", "battery", "measurement", "%");
+    publishSensor("State of Health (SOH)", "mdi:heart-plus", "stateOfHealth", NULL, "measurement", "%");
+    publishSensor("Charge voltage (BMS)", NULL, "settings/chargeVoltage", "voltage", "measurement", "V");
+    publishSensor("Charge current limit", NULL, "settings/chargeCurrentLimitation", "current", "measurement", "A");
+    publishSensor("Discharge current limit", NULL, "settings/dischargeCurrentLimitation", "current", "measurement", "A");
 
-    publishBinarySensor("Alarm Discharge current", "alarm/overCurrentDischarge", "1", "0");
-    publishBinarySensor("Warning Discharge current", "warning/highCurrentDischarge", "1", "0");
+    publishBinarySensor("Alarm Discharge current", "mdi:alert", "alarm/overCurrentDischarge", "1", "0");
+    publishBinarySensor("Warning Discharge current", "mdi:alert-outline", "warning/highCurrentDischarge", "1", "0");
 
-    publishBinarySensor("Alarm Temperature low", "alarm/underTemperature", "1", "0");
-    publishBinarySensor("Warning Temperature low", "warning/lowTemperature", "1", "0");
+    publishBinarySensor("Alarm Temperature low", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
+    publishBinarySensor("Warning Temperature low", "mdi:thermometer-low", "warning/lowTemperature", "1", "0");
 
-    publishBinarySensor("Alarm Temperature high", "alarm/overTemperature", "1", "0");
-    publishBinarySensor("Warning Temperature high", "warning/highTemperature", "1", "0");
+    publishBinarySensor("Alarm Temperature high", "mdi:thermometer-high", "alarm/overTemperature", "1", "0");
+    publishBinarySensor("Warning Temperature high", "mdi:thermometer-high", "warning/highTemperature", "1", "0");
 
-    publishBinarySensor("Alarm Voltage low", "alarm/underVoltage", "1", "0");
-    publishBinarySensor("Warning Voltage low", "warning/lowVoltage", "1", "0");
+    publishBinarySensor("Alarm Voltage low", "mdi:alert", "alarm/underVoltage", "1", "0");
+    publishBinarySensor("Warning Voltage low", "mdi:alert-outline", "warning/lowVoltage", "1", "0");
 
-    publishBinarySensor("Alarm Voltage high", "alarm/overVoltage", "1", "0");
-    publishBinarySensor("Warning Voltage high", "warning/highVoltage", "1", "0");
+    publishBinarySensor("Alarm Voltage high", "mdi:alert", "alarm/overVoltage", "1", "0");
+    publishBinarySensor("Warning Voltage high", "mdi:alert-outline", "warning/highVoltage", "1", "0");
 
-    publishBinarySensor("Alarm BMS internal", "alarm/bmsInternal", "1", "0");
-    publishBinarySensor("Warning BMS internal", "warning/bmsInternal", "1", "0");
+    publishBinarySensor("Alarm BMS internal", "mdi:alert", "alarm/bmsInternal", "1", "0");
+    publishBinarySensor("Warning BMS internal", "mdi:alert-outline", "warning/bmsInternal", "1", "0");
 
-    publishBinarySensor("Alarm High charge current", "alarm/overCurrentCharge", "1", "0");
-    publishBinarySensor("Warning High charge current", "warning/highCurrentCharge", "1", "0");
+    publishBinarySensor("Alarm High charge current", "mdi:alert", "alarm/overCurrentCharge", "1", "0");
+    publishBinarySensor("Warning High charge current", "mdi:alert-outline", "warning/highCurrentCharge", "1", "0");
 
-    publishBinarySensor("Charge enabled", "charging/chargeEnabled", "1", "0");
-    publishBinarySensor("Discharge enabled", "charging/dischargeEnabled", "1", "0");
-    publishBinarySensor("Charge immediately", "charging/chargeImmediately", "1", "0");
+    publishBinarySensor("Charge enabled", "mdi:battery-arrow-up", "charging/chargeEnabled", "1", "0");
+    publishBinarySensor("Discharge enabled", "mdi:battery-arrow-down", "charging/dischargeEnabled", "1", "0");
+    publishBinarySensor("Charge immediately", "mdi:alert", "charging/chargeImmediately", "1", "0");
 
     yield();
 }
 
-void MqttHandlePylontechHassClass::publishSensor(const char* caption, const char* subTopic, const char* deviceClass, const char* stateClass, const char* unitOfMeasurement )
+void MqttHandlePylontechHassClass::publishSensor(const char* caption, const char* icon, const char* subTopic, const char* deviceClass, const char* stateClass, const char* unitOfMeasurement )
 {
     String sensorId = caption;
     sensorId.replace(" ", "_");
@@ -115,6 +115,10 @@ void MqttHandlePylontechHassClass::publishSensor(const char* caption, const char
     root[F("stat_t")] = statTopic;
     root[F("uniq_id")] = serial + "_" + sensorId;
 
+    if (icon != NULL) {
+        root[F("icon")] = icon;
+    }
+
     if (unitOfMeasurement != NULL) {
         root[F("unit_of_meas")] = unitOfMeasurement;
     }
@@ -137,7 +141,8 @@ void MqttHandlePylontechHassClass::publishSensor(const char* caption, const char
     publish(configTopic, buffer);
 
 }
-void MqttHandlePylontechHassClass::publishBinarySensor(const char* caption, const char* subTopic, const char* payload_on, const char* payload_off)
+
+void MqttHandlePylontechHassClass::publishBinarySensor(const char* caption, const char* icon, const char* subTopic, const char* payload_on, const char* payload_off)
 {
     String sensorId = caption;
     sensorId.replace(" ", "_");
@@ -163,6 +168,10 @@ void MqttHandlePylontechHassClass::publishBinarySensor(const char* caption, cons
     root[F("pl_on")] = payload_on;
     root[F("pl_off")] = payload_off;
 
+    if (icon != NULL) {
+        root[F("icon")] = icon;
+    }
+
     JsonObject deviceObj = root.createNestedObject("dev");
     createDeviceInfo(deviceObj);
 
@@ -177,7 +186,7 @@ void MqttHandlePylontechHassClass::createDeviceInfo(JsonObject& object)
     object[F("ids")] = serial;
     object[F("cu")] = String(F("http://")) + NetworkSettings.localIP().toString();
     object[F("mf")] = F("OpenDTU");
-    object[F("mdl")] = Battery.manufacturer;
+    object[F("mdl")] = Battery.getStats()->getManufacturer();
     object[F("sw")] = AUTO_GIT_HASH;
 }
 
diff --git a/src/PinMapping.cpp b/src/PinMapping.cpp
index 027615134..31cb0f58a 100644
--- a/src/PinMapping.cpp
+++ b/src/PinMapping.cpp
@@ -94,12 +94,30 @@
 #define VICTRON_PIN_RX -1
 #endif
 
-#ifndef PYLONTECH_PIN_RX
-#define PYLONTECH_PIN_RX -1
+#ifndef BATTERY_PIN_RX
+#define BATTERY_PIN_RX -1
 #endif
 
-#ifndef PYLONTECH_PIN_TX
-#define PYLONTECH_PIN_TX -1
+#ifdef PYLONTECH_PIN_RX
+#undef BATTERY_PIN_RX
+#define BATTERY_PIN_RX PYLONTECH_PIN_RX
+#endif
+
+#ifndef BATTERY_PIN_RXEN
+#define BATTERY_PIN_RXEN -1
+#endif
+
+#ifndef BATTERY_PIN_TX
+#define BATTERY_PIN_TX -1
+#endif
+
+#ifdef PYLONTECH_PIN_TX
+#undef BATTERY_PIN_TX
+#define BATTERY_PIN_TX PYLONTECH_PIN_TX
+#endif
+
+#ifndef BATTERY_PIN_TXEN
+#define BATTERY_PIN_TXEN -1
 #endif
 
 #ifndef HUAWEI_PIN_MISO
@@ -167,8 +185,10 @@ PinMappingClass::PinMappingClass()
     _pinMapping.victron_tx = VICTRON_PIN_TX;
     _pinMapping.victron_rx = VICTRON_PIN_RX;
 
-    _pinMapping.battery_rx = PYLONTECH_PIN_RX;
-    _pinMapping.battery_tx = PYLONTECH_PIN_TX;
+    _pinMapping.battery_rx = BATTERY_PIN_RX;
+    _pinMapping.battery_rxen = BATTERY_PIN_RXEN;
+    _pinMapping.battery_tx = BATTERY_PIN_TX;
+    _pinMapping.battery_txen = BATTERY_PIN_TXEN;
 
     _pinMapping.huawei_miso = HUAWEI_PIN_MISO;
     _pinMapping.huawei_mosi = HUAWEI_PIN_MOSI;
@@ -240,8 +260,10 @@ bool PinMappingClass::init(const String& deviceMapping)
             _pinMapping.victron_rx = doc[i]["victron"]["rx"] | VICTRON_PIN_RX;
             _pinMapping.victron_tx = doc[i]["victron"]["tx"] | VICTRON_PIN_TX;
 
-            _pinMapping.battery_rx = doc[i]["battery"]["rx"] | PYLONTECH_PIN_RX;
-            _pinMapping.battery_tx = doc[i]["battery"]["tx"] | PYLONTECH_PIN_TX;
+            _pinMapping.battery_rx = doc[i]["battery"]["rx"] | BATTERY_PIN_RX;
+            _pinMapping.battery_rxen = doc[i]["battery"]["rxen"] | BATTERY_PIN_RXEN;
+            _pinMapping.battery_tx = doc[i]["battery"]["tx"] | BATTERY_PIN_TX;
+            _pinMapping.battery_txen = doc[i]["battery"]["txen"] | BATTERY_PIN_TXEN;
 
             _pinMapping.huawei_miso = doc[i]["huawei"]["miso"] | HUAWEI_PIN_MISO;
             _pinMapping.huawei_mosi = doc[i]["huawei"]["mosi"] | HUAWEI_PIN_MOSI;
@@ -289,12 +311,6 @@ bool PinMappingClass::isValidVictronConfig()
         && _pinMapping.victron_tx >= 0;
 }
 
-bool PinMappingClass::isValidBatteryConfig()
-{
-    return _pinMapping.battery_rx >= 0
-        && _pinMapping.battery_tx >= 0;
-}
-
 bool PinMappingClass::isValidHuaweiConfig()
 {
     return _pinMapping.huawei_miso >= 0
diff --git a/src/PowerLimiter.cpp b/src/PowerLimiter.cpp
index 354f25853..41d16db9e 100644
--- a/src/PowerLimiter.cpp
+++ b/src/PowerLimiter.cpp
@@ -284,10 +284,12 @@ void PowerLimiterClass::loop()
     }
 
     if (_verboseLogging) {
-        MessageOutput.printf("[DPL::loop] battery interface %s, SoC: %d %%, StartTH: %d %%, StopTH: %d %%, SoC age: %li ms\r\n",
-                (config.Battery_Enabled?"enabled":"disabled"), Battery.stateOfCharge,
-                config.PowerLimiter_BatterySocStartThreshold, config.PowerLimiter_BatterySocStopThreshold,
-                millis() - Battery.stateOfChargeLastUpdate);
+        MessageOutput.printf("[DPL::loop] battery interface %s, SoC: %d %%, StartTH: %d %%, StopTH: %d %%, SoC age: %d s\r\n",
+                (config.Battery_Enabled?"enabled":"disabled"),
+                Battery.getStats()->getSoC(),
+                config.PowerLimiter_BatterySocStartThreshold,
+                config.PowerLimiter_BatterySocStopThreshold,
+                Battery.getStats()->getSoCAgeSeconds());
 
         float dcVoltage = _inverter->Statistics()->getChannelFieldValue(TYPE_DC, (ChannelNum_t)config.PowerLimiter_InverterChannelId, FLD_UDC);
         MessageOutput.printf("[DPL::loop] dcVoltage: %.2f V, loadCorrectedVoltage: %.2f V, StartTH: %.2f V, StopTH: %.2f V\r\n",
@@ -598,8 +600,9 @@ bool PowerLimiterClass::testThreshold(float socThreshold, float voltThreshold,
 
     // prefer SoC provided through battery interface
     if (config.Battery_Enabled && socThreshold > 0.0
-            && (millis() - Battery.stateOfChargeLastUpdate) < 60000) {
-              return compare(Battery.stateOfCharge, socThreshold);
+            && Battery.getStats()->isValid()
+            && Battery.getStats()->getSoCAgeSeconds() < 60) {
+              return compare(Battery.getStats()->getSoC(), socThreshold);
     }
 
     // use voltage threshold as fallback
diff --git a/src/PylontechCanReceiver.cpp b/src/PylontechCanReceiver.cpp
index 7522b04fa..95fafe270 100644
--- a/src/PylontechCanReceiver.cpp
+++ b/src/PylontechCanReceiver.cpp
@@ -1,48 +1,53 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include "PylontechCanReceiver.h"
-#include "Battery.h"
 #include "Configuration.h"
 #include "MessageOutput.h"
-#include "MqttSettings.h"
+#include "PinMapping.h"
 #include <driver/twai.h>
 #include <ctime>
 
-//#define PYLONTECH_DEBUG_ENABLED
+//#define PYLONTECH_DUMMY
 
-PylontechCanReceiverClass PylontechCanReceiver;
-
-void PylontechCanReceiverClass::init(int8_t rx, int8_t tx)
+bool PylontechCanReceiver::init(bool verboseLogging)
 {
-    CONFIG_T& config = Configuration.get();
-    g_config = TWAI_GENERAL_CONFIG_DEFAULT((gpio_num_t)tx, (gpio_num_t)rx, TWAI_MODE_NORMAL);
-    if (config.Battery_Enabled) {
-        enable();
-    }
-}
+    _verboseLogging = verboseLogging;
 
-void PylontechCanReceiverClass::enable()
-{
-    if (_isEnabled) {
-        return;
+    MessageOutput.println(F("[Pylontech] Initialize interface..."));
+
+    const PinMapping_t& pin = PinMapping.get();
+    MessageOutput.printf("[Pylontech] Interface rx = %d, tx = %d\r\n",
+            pin.battery_rx, pin.battery_tx);
+
+    if (pin.battery_rx < 0 || pin.battery_tx < 0) {
+        MessageOutput.println(F("[Pylontech] Invalid pin config"));
+        return false;
     }
+
+    auto tx = static_cast<gpio_num_t>(pin.battery_tx);
+    auto rx = static_cast<gpio_num_t>(pin.battery_rx);
+    twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(tx, rx, TWAI_MODE_NORMAL);
+
     // Initialize configuration structures using macro initializers
     twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();
     twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
 
     // Install TWAI driver
-    twaiLastResult = twai_driver_install(&g_config, &t_config, &f_config);
+    esp_err_t twaiLastResult = twai_driver_install(&g_config, &t_config, &f_config);
     switch (twaiLastResult) {
         case ESP_OK:
             MessageOutput.println(F("[Pylontech] Twai driver installed"));
             break;
         case ESP_ERR_INVALID_ARG:
             MessageOutput.println(F("[Pylontech] Twai driver install - invalid arg"));
+            return false;
             break;
         case ESP_ERR_NO_MEM:
             MessageOutput.println(F("[Pylontech] Twai driver install - no memory"));
+            return false;
             break;
         case ESP_ERR_INVALID_STATE:
             MessageOutput.println(F("[Pylontech] Twai driver install - invalid state"));
+            return false;
             break;
     }
 
@@ -51,22 +56,20 @@ void PylontechCanReceiverClass::enable()
     switch (twaiLastResult) {
         case ESP_OK:
             MessageOutput.println(F("[Pylontech] Twai driver started"));
-            _isEnabled = true;
             break;
         case ESP_ERR_INVALID_STATE:
             MessageOutput.println(F("[Pylontech] Twai driver start - invalid state"));
+            return false;
             break;
     }
+
+    return true;
 }
 
-void PylontechCanReceiverClass::disable()
+void PylontechCanReceiver::deinit()
 {
-    if (!_isEnabled) {
-        return;
-    }
-
     // Stop TWAI driver
-    twaiLastResult = twai_stop();
+    esp_err_t twaiLastResult = twai_stop();
     switch (twaiLastResult) {
         case ESP_OK:
             MessageOutput.println(F("[Pylontech] Twai driver stopped"));
@@ -81,7 +84,6 @@ void PylontechCanReceiverClass::disable()
     switch (twaiLastResult) {
         case ESP_OK:
             MessageOutput.println(F("[Pylontech] Twai driver uninstalled"));
-            _isEnabled = false;
             break;
         case ESP_ERR_INVALID_STATE:
             MessageOutput.println(F("[Pylontech] Twai driver uninstall - invalid state"));
@@ -89,64 +91,15 @@ void PylontechCanReceiverClass::disable()
     }
 }
 
-void PylontechCanReceiverClass::loop()
+void PylontechCanReceiver::loop()
 {
-    CONFIG_T& config = Configuration.get();
-
-    if (!config.Battery_Enabled) {
-        return;
-    }
-
-    parseCanPackets();
-    mqtt();
-}
-
-void PylontechCanReceiverClass::mqtt()
-{
-    CONFIG_T& config = Configuration.get();
-
-    if (!MqttSettings.getConnected()
-            || (millis() - _lastPublish) < (config.Mqtt_PublishInterval * 1000)) {
-        return;
-    }    
-
-    _lastPublish = millis();
-
-    String topic = "battery";
-    MqttSettings.publish(topic + "/settings/chargeVoltage", String(Battery.chargeVoltage));
-    MqttSettings.publish(topic + "/settings/chargeCurrentLimitation", String(Battery.chargeCurrentLimitation));
-    MqttSettings.publish(topic + "/settings/dischargeCurrentLimitation", String(Battery.dischargeCurrentLimitation));
-    MqttSettings.publish(topic + "/stateOfCharge", String(Battery.stateOfCharge));
-    MqttSettings.publish(topic + "/stateOfHealth", String(Battery.stateOfHealth));
-    MqttSettings.publish(topic + "/dataAge", String((millis() - Battery.lastUpdate) / 1000));
-    MqttSettings.publish(topic + "/voltage", String(Battery.voltage));
-    MqttSettings.publish(topic + "/current", String(Battery.current));
-    MqttSettings.publish(topic + "/temperature", String(Battery.temperature));
-    MqttSettings.publish(topic + "/alarm/overCurrentDischarge", String(Battery.alarmOverCurrentDischarge));
-    MqttSettings.publish(topic + "/alarm/underTemperature", String(Battery.alarmUnderTemperature));
-    MqttSettings.publish(topic + "/alarm/overTemperature", String(Battery.alarmOverTemperature));
-    MqttSettings.publish(topic + "/alarm/underVoltage", String(Battery.alarmUnderVoltage));
-    MqttSettings.publish(topic + "/alarm/overVoltage", String(Battery.alarmOverVoltage));
-    MqttSettings.publish(topic + "/alarm/bmsInternal", String(Battery.alarmBmsInternal));
-    MqttSettings.publish(topic + "/alarm/overCurrentCharge", String(Battery.alarmOverCurrentCharge));
-    MqttSettings.publish(topic + "/warning/highCurrentDischarge", String(Battery.warningHighCurrentDischarge));
-    MqttSettings.publish(topic + "/warning/lowTemperature", String(Battery.warningLowTemperature));
-    MqttSettings.publish(topic + "/warning/highTemperature", String(Battery.warningHighTemperature));
-    MqttSettings.publish(topic + "/warning/lowVoltage", String(Battery.warningLowVoltage));
-    MqttSettings.publish(topic + "/warning/highVoltage", String(Battery.warningHighVoltage));
-    MqttSettings.publish(topic + "/warning/bmsInternal", String(Battery.warningBmsInternal));
-    MqttSettings.publish(topic + "/warning/highCurrentCharge", String(Battery.warningHighCurrentCharge));
-    MqttSettings.publish(topic + "/manufacturer", Battery.manufacturer);
-    MqttSettings.publish(topic + "/charging/chargeEnabled", String(Battery.chargeEnabled));
-    MqttSettings.publish(topic + "/charging/dischargeEnabled", String(Battery.dischargeEnabled));
-    MqttSettings.publish(topic + "/charging/chargeImmediately", String(Battery.chargeImmediately));
-}
+#ifdef PYLONTECH_DUMMY
+    return dummyData();
+#endif
 
-void PylontechCanReceiverClass::parseCanPackets()
-{
     // Check for messages. twai_receive is blocking when there is no data so we return if there are no frames in the buffer
     twai_status_info_t status_info;
-    twaiLastResult = twai_get_status_info(&status_info);
+    esp_err_t twaiLastResult = twai_get_status_info(&status_info);
     if (twaiLastResult != ESP_OK) {
         switch (twaiLastResult) {
             case ESP_ERR_INVALID_ARG:
@@ -171,124 +124,126 @@ void PylontechCanReceiverClass::parseCanPackets()
 
     switch (rx_message.identifier) {
         case 0x351: {
-            Battery.chargeVoltage = this->scaleValue(this->readUnsignedInt16(rx_message.data), 0.1);
-            Battery.chargeCurrentLimitation = this->scaleValue(this->readSignedInt16(rx_message.data + 2), 0.1);
-            Battery.dischargeCurrentLimitation = this->scaleValue(this->readSignedInt16(rx_message.data + 4), 0.1);
+            _stats->_chargeVoltage = this->scaleValue(this->readUnsignedInt16(rx_message.data), 0.1);
+            _stats->_chargeCurrentLimitation = this->scaleValue(this->readSignedInt16(rx_message.data + 2), 0.1);
+            _stats->_dischargeCurrentLimitation = this->scaleValue(this->readSignedInt16(rx_message.data + 4), 0.1);
 
-#ifdef PYLONTECH_DEBUG_ENABLED
-           MessageOutput.printf("[Pylontech] chargeVoltage: %f chargeCurrentLimitation: %f dischargeCurrentLimitation: %f\n",
-                Battery.chargeVoltage, Battery.chargeCurrentLimitation, Battery.dischargeCurrentLimitation);
-#endif
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] chargeVoltage: %f chargeCurrentLimitation: %f dischargeCurrentLimitation: %f\n",
+                        _stats->_chargeVoltage, _stats->_chargeCurrentLimitation, _stats->_dischargeCurrentLimitation);
+            }
             break;
         }
 
         case 0x355: {
-            Battery.stateOfCharge = this->readUnsignedInt16(rx_message.data);
-            Battery.stateOfChargeLastUpdate = millis();
-            Battery.stateOfHealth = this->readUnsignedInt16(rx_message.data + 2);
-            Battery.lastUpdate = millis();
-
-#ifdef PYLONTECH_DEBUG_ENABLED
-            MessageOutput.printf("[Pylontech] soc: %d soh: %d\n",
-                Battery.stateOfCharge, Battery.stateOfHealth);
-#endif
+            _stats->setSoC(static_cast<uint8_t>(this->readUnsignedInt16(rx_message.data)));
+            _stats->_stateOfHealth = this->readUnsignedInt16(rx_message.data + 2);
+
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] soc: %d soh: %d\n",
+                        _stats->getSoC(), _stats->_stateOfHealth);
+            }
             break;
         }
 
         case 0x356: {
-            Battery.voltage = this->scaleValue(this->readSignedInt16(rx_message.data), 0.01);
-            Battery.current = this->scaleValue(this->readSignedInt16(rx_message.data + 2), 0.1);
-            Battery.temperature = this->scaleValue(this->readSignedInt16(rx_message.data + 4), 0.1);
+            _stats->_voltage = this->scaleValue(this->readSignedInt16(rx_message.data), 0.01);
+            _stats->_current = this->scaleValue(this->readSignedInt16(rx_message.data + 2), 0.1);
+            _stats->_temperature = this->scaleValue(this->readSignedInt16(rx_message.data + 4), 0.1);
 
-#ifdef PYLONTECH_DEBUG_ENABLED
-            MessageOutput.printf("[Pylontech] voltage: %f current: %f temperature: %f\n",
-                Battery.voltage, Battery.current, Battery.temperature);
-#endif
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] voltage: %f current: %f temperature: %f\n",
+                        _stats->_voltage, _stats->_current, _stats->_temperature);
+            }
             break;
         }
 
         case 0x359: {
             uint16_t alarmBits = rx_message.data[0];
-            Battery.alarmOverCurrentDischarge = this->getBit(alarmBits, 7);
-            Battery.alarmUnderTemperature = this->getBit(alarmBits, 4);
-            Battery.alarmOverTemperature = this->getBit(alarmBits, 3);
-            Battery.alarmUnderVoltage = this->getBit(alarmBits, 2);
-            Battery.alarmOverVoltage= this->getBit(alarmBits, 1);
+            _stats->_alarmOverCurrentDischarge = this->getBit(alarmBits, 7);
+            _stats->_alarmUnderTemperature = this->getBit(alarmBits, 4);
+            _stats->_alarmOverTemperature = this->getBit(alarmBits, 3);
+            _stats->_alarmUnderVoltage = this->getBit(alarmBits, 2);
+            _stats->_alarmOverVoltage= this->getBit(alarmBits, 1);
 
             alarmBits = rx_message.data[1];
-            Battery.alarmBmsInternal= this->getBit(alarmBits, 3);
-            Battery.alarmOverCurrentCharge = this->getBit(alarmBits, 0);
-
-#ifdef PYLONTECH_DEBUG_ENABLED
-            MessageOutput.printf("[Pylontech] Alarms: %d %d %d %d %d %d %d\n",
-                Battery.alarmOverCurrentDischarge,
-                Battery.alarmUnderTemperature,
-                Battery.alarmOverTemperature,
-                Battery.alarmUnderVoltage,
-                Battery.alarmOverVoltage,
-                Battery.alarmBmsInternal,
-                Battery.alarmOverCurrentCharge);
-#endif
+            _stats->_alarmBmsInternal= this->getBit(alarmBits, 3);
+            _stats->_alarmOverCurrentCharge = this->getBit(alarmBits, 0);
+
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] Alarms: %d %d %d %d %d %d %d\n",
+                        _stats->_alarmOverCurrentDischarge,
+                        _stats->_alarmUnderTemperature,
+                        _stats->_alarmOverTemperature,
+                        _stats->_alarmUnderVoltage,
+                        _stats->_alarmOverVoltage,
+                        _stats->_alarmBmsInternal,
+                        _stats->_alarmOverCurrentCharge);
+            }
 
             uint16_t warningBits = rx_message.data[2];
-            Battery.warningHighCurrentDischarge = this->getBit(warningBits, 7);
-            Battery.warningLowTemperature = this->getBit(warningBits, 4);
-            Battery.warningHighTemperature = this->getBit(warningBits, 3);
-            Battery.warningLowVoltage = this->getBit(warningBits, 2);
-            Battery.warningHighVoltage = this->getBit(warningBits, 1);
+            _stats->_warningHighCurrentDischarge = this->getBit(warningBits, 7);
+            _stats->_warningLowTemperature = this->getBit(warningBits, 4);
+            _stats->_warningHighTemperature = this->getBit(warningBits, 3);
+            _stats->_warningLowVoltage = this->getBit(warningBits, 2);
+            _stats->_warningHighVoltage = this->getBit(warningBits, 1);
 
             warningBits = rx_message.data[3];
-            Battery.warningBmsInternal= this->getBit(warningBits, 3);
-            Battery.warningHighCurrentCharge = this->getBit(warningBits, 0);
-
-#ifdef PYLONTECH_DEBUG_ENABLED
-            MessageOutput.printf("[Pylontech] Warnings: %d %d %d %d %d %d %d\n",
-                Battery.warningHighCurrentDischarge,
-                Battery.warningLowTemperature,
-                Battery.warningHighTemperature,
-                Battery.warningLowVoltage,
-                Battery.warningHighVoltage,
-                Battery.warningBmsInternal,
-                Battery.warningHighCurrentCharge);
-#endif
+            _stats->_warningBmsInternal= this->getBit(warningBits, 3);
+            _stats->_warningHighCurrentCharge = this->getBit(warningBits, 0);
+
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] Warnings: %d %d %d %d %d %d %d\n",
+                        _stats->_warningHighCurrentDischarge,
+                        _stats->_warningLowTemperature,
+                        _stats->_warningHighTemperature,
+                        _stats->_warningLowVoltage,
+                        _stats->_warningHighVoltage,
+                        _stats->_warningBmsInternal,
+                        _stats->_warningHighCurrentCharge);
+            }
             break;
         }
 
         case 0x35E: {
-            String manufacturer = String(rx_message.data, rx_message.data_length_code);
-            //CAN.readString();
+            String manufacturer(reinterpret_cast<char*>(rx_message.data),
+                    rx_message.data_length_code);
 
-            if (manufacturer == "") {
-                break;
-            }
+            if (manufacturer.isEmpty()) { break; }
 
-            strlcpy(Battery.manufacturer, manufacturer.c_str(), sizeof(Battery.manufacturer));
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] Manufacturer: %s\n", manufacturer.c_str());
+            }
 
-#ifdef PYLONTECH_DEBUG_ENABLED
-            MessageOutput.printf("[Pylontech] Manufacturer: %s\n", manufacturer.c_str());
-#endif   
+            _stats->setManufacturer(std::move(manufacturer));
             break;
         }
 
         case 0x35C: {
             uint16_t chargeStatusBits = rx_message.data[0];
-            Battery.chargeEnabled = this->getBit(chargeStatusBits, 7);
-            Battery.dischargeEnabled = this->getBit(chargeStatusBits, 6);
-            Battery.chargeImmediately = this->getBit(chargeStatusBits, 5);
-
-#ifdef PYLONTECH_DEBUG_ENABLED
-            MessageOutput.printf("[Pylontech] chargeStatusBits: %d %d %d\n",
-                Battery.chargeEnabled,
-                Battery.dischargeEnabled,
-                Battery.chargeImmediately);
-#endif
+            _stats->_chargeEnabled = this->getBit(chargeStatusBits, 7);
+            _stats->_dischargeEnabled = this->getBit(chargeStatusBits, 6);
+            _stats->_chargeImmediately = this->getBit(chargeStatusBits, 5);
+
+            if (_verboseLogging) {
+                MessageOutput.printf("[Pylontech] chargeStatusBits: %d %d %d\n",
+                    _stats->_chargeEnabled,
+                    _stats->_dischargeEnabled,
+                    _stats->_chargeImmediately);
+            }
 
             break;
         }
+
+        default:
+            return; // do not update last update timestamp
+            break;
     }
+
+    _stats->setLastUpdate(millis());
 }
 
-uint16_t PylontechCanReceiverClass::readUnsignedInt16(uint8_t *data)
+uint16_t PylontechCanReceiver::readUnsignedInt16(uint8_t *data)
 {
     uint8_t bytes[2];
     bytes[0] = *data;
@@ -296,17 +251,94 @@ uint16_t PylontechCanReceiverClass::readUnsignedInt16(uint8_t *data)
     return (bytes[1] << 8) + bytes[0];
 }
 
-int16_t PylontechCanReceiverClass::readSignedInt16(uint8_t *data)
+int16_t PylontechCanReceiver::readSignedInt16(uint8_t *data)
 {
     return this->readUnsignedInt16(data);
 }
 
-float PylontechCanReceiverClass::scaleValue(int16_t value, float factor)
+float PylontechCanReceiver::scaleValue(int16_t value, float factor)
 {
     return value * factor;
 }
 
-bool PylontechCanReceiverClass::getBit(uint8_t value, uint8_t bit)
+bool PylontechCanReceiver::getBit(uint8_t value, uint8_t bit)
 {
     return (value & (1 << bit)) >> bit;
 }
+
+#ifdef PYLONTECH_DUMMY
+void PylontechCanReceiver::dummyData()
+{
+    static uint32_t lastUpdate = millis();
+    static uint8_t issues = 0;
+
+    if (millis() < (lastUpdate + 5 * 1000)) { return; }
+
+    lastUpdate = millis();
+    _stats->setLastUpdate(lastUpdate);
+
+    auto dummyFloat = [](int offset) -> float {
+        return offset + (static_cast<float>((lastUpdate + offset) % 10) / 10);
+    };
+
+    _stats->setManufacturer("Pylontech US3000C");
+    _stats->setSoC(42);
+    _stats->_chargeVoltage = dummyFloat(50);
+    _stats->_chargeCurrentLimitation = dummyFloat(33);
+    _stats->_dischargeCurrentLimitation = dummyFloat(12);
+    _stats->_stateOfHealth = 99;
+    _stats->_voltage = 48.67;
+    _stats->_current = dummyFloat(-1);
+    _stats->_temperature = dummyFloat(20);
+
+    _stats->_chargeEnabled = true;
+    _stats->_dischargeEnabled = true;
+    _stats->_chargeImmediately = false;
+
+    _stats->_warningHighCurrentDischarge = false;
+    _stats->_warningHighCurrentCharge = false;
+    _stats->_warningLowTemperature = false;
+    _stats->_warningHighTemperature = false;
+    _stats->_warningLowVoltage = false;
+    _stats->_warningHighVoltage = false;
+    _stats->_warningBmsInternal = false;
+
+    _stats->_alarmOverCurrentDischarge = false;
+    _stats->_alarmOverCurrentCharge = false;
+    _stats->_alarmUnderTemperature = false;
+    _stats->_alarmOverTemperature = false;
+    _stats->_alarmUnderVoltage = false;
+    _stats->_alarmOverVoltage = false;
+    _stats->_alarmBmsInternal = false;
+
+    if (issues == 1 || issues == 3) {
+        _stats->_warningHighCurrentDischarge = true;
+        _stats->_warningHighCurrentCharge = true;
+        _stats->_warningLowTemperature = true;
+        _stats->_warningHighTemperature = true;
+        _stats->_warningLowVoltage = true;
+        _stats->_warningHighVoltage = true;
+        _stats->_warningBmsInternal = true;
+    }
+
+    if (issues == 2 || issues == 3) {
+        _stats->_alarmOverCurrentDischarge = true;
+        _stats->_alarmOverCurrentCharge = true;
+        _stats->_alarmUnderTemperature = true;
+        _stats->_alarmOverTemperature = true;
+        _stats->_alarmUnderVoltage = true;
+        _stats->_alarmOverVoltage = true;
+        _stats->_alarmBmsInternal = true;
+    }
+
+    if (issues == 4) {
+        _stats->_warningHighCurrentCharge = true;
+        _stats->_warningLowTemperature = true;
+        _stats->_alarmUnderVoltage = true;
+        _stats->_dischargeEnabled = false;
+        _stats->_chargeImmediately = true;
+    }
+
+    issues = (issues + 1) % 5;
+}
+#endif
diff --git a/src/WebApi.cpp b/src/WebApi.cpp
index 47a41f726..9ae6fb534 100644
--- a/src/WebApi.cpp
+++ b/src/WebApi.cpp
@@ -43,8 +43,7 @@ void WebApiClass::init()
     _webApiVedirect.init(&_server);
     _webApiWsHuaweiLive.init(&_server);
     _webApiHuaweiClass.init(&_server);
-    _webApiWsPylontechLive.init(&_server);
-    _webApiPylontechClass.init(&_server);
+    _webApiWsBatteryLive.init(&_server);
 
     _server.begin();
 }
@@ -76,8 +75,7 @@ void WebApiClass::loop()
     _webApiVedirect.loop();
     _webApiWsHuaweiLive.loop();
     _webApiHuaweiClass.loop();
-    _webApiWsPylontechLive.loop();
-    _webApiPylontechClass.loop();
+    _webApiWsBatteryLive.loop();
 }
 
 bool WebApiClass::checkCredentials(AsyncWebServerRequest* request)
diff --git a/src/WebApi_Pylontech.cpp b/src/WebApi_Pylontech.cpp
deleted file mode 100644
index d5338e57d..000000000
--- a/src/WebApi_Pylontech.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Copyright (C) 2022 Thomas Basler and others
- */
-#include "WebApi_Pylontech.h"
-#include "Battery.h"
-#include "Configuration.h"
-#include "MessageOutput.h"
-#include "WebApi.h"
-#include "WebApi_errors.h"
-#include <AsyncJson.h>
-#include <Hoymiles.h>
-
-void WebApiPylontechClass::init(AsyncWebServer* server)
-{
-    using std::placeholders::_1;
-
-    _server = server;
-
-    _server->on("/api/battery/livedata", HTTP_GET, std::bind(&WebApiPylontechClass::onStatus, this, _1));
-}
-
-void WebApiPylontechClass::loop()
-{
-}
-
-void WebApiPylontechClass::getJsonData(JsonObject& root) {
-
-    root["data_age"] = (millis() - Battery.lastUpdate) / 1000;
-
-    root[F("chargeVoltage")]["v"] = Battery.chargeVoltage ;
-    root[F("chargeVoltage")]["u"] = "V";
-    root[F("chargeCurrentLimitation")]["v"] = Battery.chargeCurrentLimitation ;
-    root[F("chargeCurrentLimitation")]["u"] = "A";
-    root[F("dischargeCurrentLimitation")]["v"] = Battery.dischargeCurrentLimitation ;
-    root[F("dischargeCurrentLimitation")]["u"] = "A";
-    root[F("stateOfCharge")]["v"] = Battery.stateOfCharge ;
-    root[F("stateOfCharge")]["u"] = "%";
-    root[F("stateOfHealth")]["v"] = Battery.stateOfHealth ;
-    root[F("stateOfHealth")]["u"] = "%";
-    root[F("voltage")]["v"] = Battery.voltage;
-    root[F("voltage")]["u"] = "V";
-    root[F("current")]["v"] = Battery.current ;
-    root[F("current")]["u"] = "A";
-    root[F("temperature")]["v"] = Battery.temperature ;
-    root[F("temperature")]["u"] = "°C";
-
-    // Alarms
-    root["alarms"][F("dischargeCurrent")] = Battery.alarmOverCurrentDischarge ;
-    root["alarms"][F("chargeCurrent")] = Battery.alarmOverCurrentCharge ;
-    root["alarms"][F("lowTemperature")] = Battery.alarmUnderTemperature ;
-    root["alarms"][F("highTemperature")] = Battery.alarmOverTemperature ;
-    root["alarms"][F("lowVoltage")] = Battery.alarmUnderVoltage ;
-    root["alarms"][F("highVoltage")] = Battery.alarmOverVoltage ;
-    root["alarms"][F("bmsInternal")] = Battery.alarmBmsInternal ;
-
-    // Warnings
-    root["warnings"][F("dischargeCurrent")] = Battery.warningHighCurrentDischarge ;
-    root["warnings"][F("chargeCurrent")] = Battery.warningHighCurrentCharge ;
-    root["warnings"][F("lowTemperature")] = Battery.warningLowTemperature ;
-    root["warnings"][F("highTemperature")] = Battery.warningHighTemperature ;
-    root["warnings"][F("lowVoltage")] = Battery.warningLowVoltage ;
-    root["warnings"][F("highVoltage")] = Battery.warningHighVoltage ;
-    root["warnings"][F("bmsInternal")] = Battery.warningBmsInternal ;
-
-    // Misc
-    root[F("manufacturer")] = Battery.manufacturer ;
-    root[F("chargeEnabled")] = Battery.chargeEnabled ;
-    root[F("dischargeEnabled")] = Battery.dischargeEnabled ;
-    root[F("chargeImmediately")] = Battery.chargeImmediately ;
-
-}
-
-void WebApiPylontechClass::onStatus(AsyncWebServerRequest* request)
-{
-    if (!WebApi.checkCredentialsReadonly(request)) {
-        return;
-    }
-
-    AsyncJsonResponse* response = new AsyncJsonResponse();
-    JsonObject root = response->getRoot();
-    getJsonData(root);
-
-    response->setLength();
-    request->send(response);
-}
-
diff --git a/src/WebApi_battery.cpp b/src/WebApi_battery.cpp
index c9589df4a..a21f09a4f 100644
--- a/src/WebApi_battery.cpp
+++ b/src/WebApi_battery.cpp
@@ -39,6 +39,10 @@ void WebApiBatteryClass::onStatus(AsyncWebServerRequest* request)
     const CONFIG_T& config = Configuration.get();
 
     root[F("enabled")] = config.Battery_Enabled;
+    root[F("verbose_logging")] = config.Battery_VerboseLogging;
+    root[F("provider")] = config.Battery_Provider;
+    root[F("jkbms_interface")] = config.Battery_JkBmsInterface;
+    root[F("jkbms_polling_interval")] = config.Battery_JkBmsPollingInterval;
 
     response->setLength();
     request->send(response);
@@ -88,7 +92,7 @@ void WebApiBatteryClass::onAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    if (!(root.containsKey("enabled"))) {
+    if (!root.containsKey(F("enabled")) || !root.containsKey(F("provider"))) {
         retMsg[F("message")] = F("Values are missing!");
         retMsg[F("code")] = WebApiError::GenericValueMissing;
         response->setLength();
@@ -98,6 +102,10 @@ void WebApiBatteryClass::onAdminPost(AsyncWebServerRequest* request)
 
     CONFIG_T& config = Configuration.get();
     config.Battery_Enabled = root[F("enabled")].as<bool>();
+    config.Battery_VerboseLogging = root[F("verbose_logging")].as<bool>();
+    config.Battery_Provider = root[F("provider")].as<uint8_t>();
+    config.Battery_JkBmsInterface = root[F("jkbms_interface")].as<uint8_t>();
+    config.Battery_JkBmsPollingInterval = root[F("jkbms_polling_interval")].as<uint8_t>();
     Configuration.write();
 
     retMsg[F("type")] = F("success");
@@ -107,9 +115,5 @@ void WebApiBatteryClass::onAdminPost(AsyncWebServerRequest* request)
     response->setLength();
     request->send(response);
 
-    if (config.Battery_Enabled) {
-        PylontechCanReceiver.enable();
-    } else {
-        PylontechCanReceiver.disable();
-    }
+    Battery.init();
 }
diff --git a/src/WebApi_device.cpp b/src/WebApi_device.cpp
index 521e799ea..f3d3b3427 100644
--- a/src/WebApi_device.cpp
+++ b/src/WebApi_device.cpp
@@ -89,7 +89,9 @@ void WebApiDeviceClass::onDeviceAdminGet(AsyncWebServerRequest* request)
 
     JsonObject batteryPinObj = curPin.createNestedObject("battery");
     batteryPinObj[F("rx")] = pin.battery_rx;
+    batteryPinObj[F("rxen")] = pin.battery_rxen;
     batteryPinObj[F("tx")] = pin.battery_tx;
+    batteryPinObj[F("txen")] = pin.battery_txen;
 
     JsonObject huaweiPinObj = curPin.createNestedObject("huawei");
     huaweiPinObj[F("miso")] = pin.huawei_miso;
diff --git a/src/WebApi_vedirect.cpp b/src/WebApi_vedirect.cpp
index 4b7e8e959..651e9e406 100644
--- a/src/WebApi_vedirect.cpp
+++ b/src/WebApi_vedirect.cpp
@@ -37,6 +37,7 @@ void WebApiVedirectClass::onVedirectStatus(AsyncWebServerRequest* request)
     const CONFIG_T& config = Configuration.get();
 
     root[F("vedirect_enabled")] = config.Vedirect_Enabled;
+    root[F("verbose_logging")] = config.Vedirect_VerboseLogging;
     root[F("vedirect_updatesonly")] = config.Vedirect_UpdatesOnly;
 
     response->setLength();
@@ -54,6 +55,7 @@ void WebApiVedirectClass::onVedirectAdminGet(AsyncWebServerRequest* request)
     const CONFIG_T& config = Configuration.get();
 
     root[F("vedirect_enabled")] = config.Vedirect_Enabled;
+    root[F("verbose_logging")] = config.Vedirect_VerboseLogging;
     root[F("vedirect_updatesonly")] = config.Vedirect_UpdatesOnly;
 
     response->setLength();
@@ -99,7 +101,9 @@ void WebApiVedirectClass::onVedirectAdminPost(AsyncWebServerRequest* request)
         return;
     }
 
-    if (!(root.containsKey("vedirect_enabled") && root.containsKey("vedirect_updatesonly")) ) {
+    if (!root.containsKey("vedirect_enabled") ||
+            !root.containsKey("verbose_logging") ||
+            !root.containsKey("vedirect_updatesonly") ) {
         retMsg[F("message")] = F("Values are missing!");
         retMsg[F("code")] = WebApiError::GenericValueMissing;
         response->setLength();
@@ -109,9 +113,12 @@ void WebApiVedirectClass::onVedirectAdminPost(AsyncWebServerRequest* request)
 
     CONFIG_T& config = Configuration.get();
     config.Vedirect_Enabled = root[F("vedirect_enabled")].as<bool>();
+    config.Vedirect_VerboseLogging = root[F("verbose_logging")].as<bool>();
     config.Vedirect_UpdatesOnly = root[F("vedirect_updatesonly")].as<bool>();
     Configuration.write();
 
+    VeDirect.setVerboseLogging(config.Vedirect_VerboseLogging);
+
     retMsg[F("type")] = F("success");
     retMsg[F("message")] = F("Settings saved!");
     retMsg[F("code")] = WebApiError::GenericSuccess;
diff --git a/src/WebApi_ws_Pylontech.cpp b/src/WebApi_ws_Pylontech.cpp
deleted file mode 100644
index d29a6187b..000000000
--- a/src/WebApi_ws_Pylontech.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Copyright (C) 2022 Thomas Basler and others
- */
-#include "WebApi_ws_Pylontech.h"
-#include "AsyncJson.h"
-#include "Configuration.h"
-#include "Battery.h"
-#include "MessageOutput.h"
-#include "WebApi.h"
-#include "defaults.h"
-
-WebApiWsPylontechLiveClass::WebApiWsPylontechLiveClass()
-    : _ws("/batterylivedata")
-{
-}
-
-void WebApiWsPylontechLiveClass::init(AsyncWebServer* server)
-{
-    using std::placeholders::_1;
-    using std::placeholders::_2;
-    using std::placeholders::_3;
-    using std::placeholders::_4;
-    using std::placeholders::_5;
-    using std::placeholders::_6;
-
-    _server = server;
-    _server->on("/api/batterylivedata/status", HTTP_GET, std::bind(&WebApiWsPylontechLiveClass::onLivedataStatus, this, _1));
-
-    _server->addHandler(&_ws);
-    _ws.onEvent(std::bind(&WebApiWsPylontechLiveClass::onWebsocketEvent, this, _1, _2, _3, _4, _5, _6));
-}
-
-void WebApiWsPylontechLiveClass::loop()
-{
-    // see: https://github.com/me-no-dev/ESPAsyncWebServer#limiting-the-number-of-web-socket-clients
-    if (millis() - _lastWsCleanup > 1000) {
-        _ws.cleanupClients();
-        _lastWsCleanup = millis();
-    }
-
-    // do nothing if no WS client is connected
-    if (_ws.count() == 0) {
-        return;
-    }
-
-    if (millis() - _lastUpdateCheck < 1000) {
-        return;
-    }
-    _lastUpdateCheck = millis();
-
-    try {
-        String buffer;
-        // free JsonDocument as soon as possible
-        {
-            DynamicJsonDocument root(1024);
-            JsonVariant var = root;
-            generateJsonResponse(var);
-            serializeJson(root, buffer);
-        }
-
-        if (buffer) {
-            if (Configuration.get().Security_AllowReadonly) {
-                _ws.setAuthentication("", "");
-            } else {
-                _ws.setAuthentication(AUTH_USERNAME, Configuration.get().Security_Password);
-            }
-
-            _ws.textAll(buffer);
-        }
-            } catch (std::bad_alloc& bad_alloc) {
-            MessageOutput.printf("Calling /api/livedata/status has temporarily run out of resources. Reason: \"%s\".\r\n", bad_alloc.what());
-        }
-}
-
-void WebApiWsPylontechLiveClass::generateJsonResponse(JsonVariant& root)
-{
-    root["data_age"] = (millis() - Battery.lastUpdate) / 1000;
-
-    root[F("chargeVoltage")]["v"] = Battery.chargeVoltage ;
-    root[F("chargeVoltage")]["u"] = "V";
-    root[F("chargeCurrentLimitation")]["v"] = Battery.chargeCurrentLimitation ;
-    root[F("chargeCurrentLimitation")]["u"] = "A";
-    root[F("dischargeCurrentLimitation")]["v"] = Battery.dischargeCurrentLimitation ;
-    root[F("dischargeCurrentLimitation")]["u"] = "A";
-    root[F("stateOfCharge")]["v"] = Battery.stateOfCharge ;
-    root[F("stateOfCharge")]["u"] = "%";
-    root[F("stateOfHealth")]["v"] = Battery.stateOfHealth ;
-    root[F("stateOfHealth")]["u"] = "%";
-    root[F("voltage")]["v"] = Battery.voltage;
-    root[F("voltage")]["u"] = "V";
-    root[F("current")]["v"] = Battery.current ;
-    root[F("current")]["u"] = "A";
-    root[F("temperature")]["v"] = Battery.temperature ;
-    root[F("temperature")]["u"] = "°C";
-
-    // Alarms
-    root["alarms"][F("dischargeCurrent")] = Battery.alarmOverCurrentDischarge ;
-    root["alarms"][F("chargeCurrent")] = Battery.alarmOverCurrentCharge ;
-    root["alarms"][F("lowTemperature")] = Battery.alarmUnderTemperature ;
-    root["alarms"][F("highTemperature")] = Battery.alarmOverTemperature ;
-    root["alarms"][F("lowVoltage")] = Battery.alarmUnderVoltage ;
-    root["alarms"][F("highVoltage")] = Battery.alarmOverVoltage ;
-    root["alarms"][F("bmsInternal")] = Battery.alarmBmsInternal ;
-
-    // Warnings
-    root["warnings"][F("dischargeCurrent")] = Battery.warningHighCurrentDischarge ;
-    root["warnings"][F("chargeCurrent")] = Battery.warningHighCurrentCharge ;
-    root["warnings"][F("lowTemperature")] = Battery.warningLowTemperature ;
-    root["warnings"][F("highTemperature")] = Battery.warningHighTemperature ;
-    root["warnings"][F("lowVoltage")] = Battery.warningLowVoltage ;
-    root["warnings"][F("highVoltage")] = Battery.warningHighVoltage ;
-    root["warnings"][F("bmsInternal")] = Battery.warningBmsInternal ;
-
-    // Misc
-    root[F("manufacturer")] = Battery.manufacturer ;
-    root[F("chargeEnabled")] = Battery.chargeEnabled ;
-    root[F("dischargeEnabled")] = Battery.dischargeEnabled ;
-    root[F("chargeImmediately")] = Battery.chargeImmediately ;
-
-
-}
-
-void WebApiWsPylontechLiveClass::onWebsocketEvent(AsyncWebSocket* server, AsyncWebSocketClient* client, AwsEventType type, void* arg, uint8_t* data, size_t len)
-{
-    if (type == WS_EVT_CONNECT) {
-        char str[64];
-        snprintf(str, sizeof(str), "Websocket: [%s][%u] connect", server->url(), client->id());
-        Serial.println(str);
-        MessageOutput.println(str);
-    } else if (type == WS_EVT_DISCONNECT) {
-        char str[64];
-        snprintf(str, sizeof(str), "Websocket: [%s][%u] disconnect", server->url(), client->id());
-        Serial.println(str);
-        MessageOutput.println(str);
-    }
-}
-
-void WebApiWsPylontechLiveClass::onLivedataStatus(AsyncWebServerRequest* request)
-{
-    if (!WebApi.checkCredentialsReadonly(request)) {
-        return;
-    }
-    try {
-        AsyncJsonResponse* response = new AsyncJsonResponse(false, 1024U);
-        JsonVariant root = response->getRoot().as<JsonVariant>();
-        generateJsonResponse(root);
-
-        response->setLength();
-        request->send(response);
-    } catch (std::bad_alloc& bad_alloc) {
-        MessageOutput.printf("Calling /api/livedata/status has temporarily run out of resources. Reason: \"%s\".\r\n", bad_alloc.what());
-
-        WebApi.sendTooManyRequests(request);
-    }
-}
\ No newline at end of file
diff --git a/src/WebApi_ws_battery.cpp b/src/WebApi_ws_battery.cpp
new file mode 100644
index 000000000..a2a74525d
--- /dev/null
+++ b/src/WebApi_ws_battery.cpp
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2022 Thomas Basler and others
+ */
+#include "WebApi_ws_battery.h"
+#include "AsyncJson.h"
+#include "Configuration.h"
+#include "Battery.h"
+#include "MessageOutput.h"
+#include "WebApi.h"
+#include "defaults.h"
+
+WebApiWsBatteryLiveClass::WebApiWsBatteryLiveClass()
+    : _ws("/batterylivedata")
+{
+}
+
+void WebApiWsBatteryLiveClass::init(AsyncWebServer* server)
+{
+    using std::placeholders::_1;
+    using std::placeholders::_2;
+    using std::placeholders::_3;
+    using std::placeholders::_4;
+    using std::placeholders::_5;
+    using std::placeholders::_6;
+
+    _server = server;
+    _server->on("/api/batterylivedata/status", HTTP_GET, std::bind(&WebApiWsBatteryLiveClass::onLivedataStatus, this, _1));
+
+    _server->addHandler(&_ws);
+    _ws.onEvent(std::bind(&WebApiWsBatteryLiveClass::onWebsocketEvent, this, _1, _2, _3, _4, _5, _6));
+}
+
+void WebApiWsBatteryLiveClass::loop()
+{
+    // see: https://github.com/me-no-dev/ESPAsyncWebServer#limiting-the-number-of-web-socket-clients
+    if (millis() - _lastWsCleanup > 1000) {
+        _ws.cleanupClients();
+        _lastWsCleanup = millis();
+    }
+
+    // do nothing if no WS client is connected
+    if (_ws.count() == 0) {
+        return;
+    }
+
+    if (!Battery.getStats()->updateAvailable(_lastUpdateCheck)) { return; }
+    _lastUpdateCheck = millis();
+
+    try {
+        String buffer;
+        // free JsonDocument as soon as possible
+        {
+            DynamicJsonDocument root(_responseSize);
+            JsonVariant var = root;
+            generateJsonResponse(var);
+            serializeJson(root, buffer);
+        }
+
+        if (buffer) {
+            if (Configuration.get().Security_AllowReadonly) {
+                _ws.setAuthentication("", "");
+            } else {
+                _ws.setAuthentication(AUTH_USERNAME, Configuration.get().Security_Password);
+            }
+
+            _ws.textAll(buffer);
+        }
+    } catch (std::bad_alloc& bad_alloc) {
+        MessageOutput.printf("Calling /api/batterylivedata/status has temporarily run out of resources. Reason: \"%s\".\r\n", bad_alloc.what());
+    }
+}
+
+void WebApiWsBatteryLiveClass::generateJsonResponse(JsonVariant& root)
+{
+    Battery.getStats()->getLiveViewData(root);
+}
+
+void WebApiWsBatteryLiveClass::onWebsocketEvent(AsyncWebSocket* server, AsyncWebSocketClient* client, AwsEventType type, void* arg, uint8_t* data, size_t len)
+{
+    if (type == WS_EVT_CONNECT) {
+        MessageOutput.printf("Websocket: [%s][%u] connect\r\n", server->url(), client->id());
+    } else if (type == WS_EVT_DISCONNECT) {
+        MessageOutput.printf("Websocket: [%s][%u] disconnect\r\n", server->url(), client->id());
+    }
+}
+
+void WebApiWsBatteryLiveClass::onLivedataStatus(AsyncWebServerRequest* request)
+{
+    if (!WebApi.checkCredentialsReadonly(request)) {
+        return;
+    }
+    try {
+        AsyncJsonResponse* response = new AsyncJsonResponse(false, _responseSize);
+        JsonVariant root = response->getRoot().as<JsonVariant>();
+        generateJsonResponse(root);
+
+        response->setLength();
+        request->send(response);
+    } catch (std::bad_alloc& bad_alloc) {
+        MessageOutput.printf("Calling /api/batterylivedata/status has temporarily run out of resources. Reason: \"%s\".\r\n", bad_alloc.what());
+
+        WebApi.sendTooManyRequests(request);
+    }
+}
\ No newline at end of file
diff --git a/src/WebApi_ws_live.cpp b/src/WebApi_ws_live.cpp
index 8488e6991..154e5e88b 100644
--- a/src/WebApi_ws_live.cpp
+++ b/src/WebApi_ws_live.cpp
@@ -196,7 +196,7 @@ void WebApiWsLiveClass::generateJsonResponse(JsonVariant& root)
     
     JsonObject batteryObj = root.createNestedObject("battery");
     batteryObj[F("enabled")] = Configuration.get().Battery_Enabled;
-    addTotalField(batteryObj, "soc", Battery.stateOfCharge, "%", 0);
+    addTotalField(batteryObj, "soc", Battery.getStats()->getSoC(), "%", 0);
 
     JsonObject powerMeterObj = root.createNestedObject("power_meter");
     powerMeterObj[F("enabled")] = Configuration.get().PowerMeter_Enabled;
diff --git a/src/main.cpp b/src/main.cpp
index 51a17b33e..50e1437f3 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -9,7 +9,7 @@
 #include "Led_Single.h"
 #include "MessageOutput.h"
 #include "VeDirectFrameHandler.h"
-#include "PylontechCanReceiver.h"
+#include "Battery.h"
 #include "Huawei_can.h"
 #include "MqttHandleDtu.h"
 #include "MqttHandleHass.h"
@@ -165,7 +165,8 @@ void setup()
     MessageOutput.println(F("Initialize ve.direct interface... "));
     if (PinMapping.isValidVictronConfig()) {
         MessageOutput.printf("ve.direct rx = %d, tx = %d\r\n", pin.victron_rx, pin.victron_tx);
-        VeDirect.init(pin.victron_rx, pin.victron_tx);
+        VeDirect.init(pin.victron_rx, pin.victron_tx,
+                &MessageOutput, config.Vedirect_VerboseLogging);
         MessageOutput.println(F("done"));
     } else {
         MessageOutput.println(F("Invalid pin config"));
@@ -176,16 +177,6 @@ void setup()
     // Dynamic power limiter
     PowerLimiter.init();
 
-    // Initialize Pylontech Battery / CAN bus
-    MessageOutput.println(F("Initialize Pylontech battery interface... "));
-    if (PinMapping.isValidBatteryConfig()) {
-        MessageOutput.printf("Pylontech Battery rx = %d, tx = %d\r\n", pin.battery_rx, pin.battery_tx);
-        PylontechCanReceiver.init(pin.battery_rx, pin.battery_tx);
-        MessageOutput.println(F("done"));
-    } else {
-        MessageOutput.println(F("Invalid pin config"));
-    }
-
     // Initialize Huawei AC-charger PSU / CAN bus
     MessageOutput.println(F("Initialize Huawei AC charger interface... "));
     if (PinMapping.isValidHuaweiConfig()) {
@@ -196,6 +187,7 @@ void setup()
         MessageOutput.println(F("Invalid pin config"));
     }
 
+    Battery.init();
 }
 
 void loop()
@@ -212,9 +204,9 @@ void loop()
     yield();
     // Vedirect_Enabled is unknown to lib. Therefor check has to be done here
     if (Configuration.get().Vedirect_Enabled) {
-		VeDirect.loop();
+        VeDirect.loop();
         yield();
-	}
+    }
     MqttSettings.loop();
     yield();
     MqttHandleDtu.loop();
@@ -241,7 +233,7 @@ void loop()
     yield();
     MessageOutput.loop();
     yield();
-    PylontechCanReceiver.loop();
+    Battery.loop();
     yield();
     MqttHandlePylontechHass.loop();
     yield();
diff --git a/webapp/src/components/BatteryView.vue b/webapp/src/components/BatteryView.vue
index d8f22ac97..2c3bf11a9 100644
--- a/webapp/src/components/BatteryView.vue
+++ b/webapp/src/components/BatteryView.vue
@@ -5,12 +5,12 @@
     </div>
   </div>
 
-  <template v-else>
+  <div v-else>
     <div class="row gy-3">
       <div class="tab-content col-sm-12 col-md-12" id="v-pills-tabContent">
         <div class="card">
           <div class="card-header d-flex justify-content-between align-items-center" :class="{
-            'text-bg-danger': batteryData.data_age > 20,
+            'text-bg-danger': batteryData.data_age >= 20,
             'text-bg-primary': batteryData.data_age < 20,
           }">
             <div class="p-1 flex-grow-1">
@@ -29,7 +29,7 @@
             <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-header bg-info">{{ $t('battery.Status') }}</div>
+                  <div class="card-header text-bg-info">{{ $t('battery.Status') }}</div>
                   <div class="card-body">
                     <table class="table table-striped table-hover">
                       <thead>
@@ -40,210 +40,57 @@
                         </tr>
                       </thead>
                       <tbody>
-                        <tr>
-                          <th scope="row">{{ $t('battery.stateOfCharge') }}</th>
-                          <td style="text-align: right">{{ batteryData.stateOfCharge.v.toFixed(1) }}</td>
-                          <td>{{ batteryData.stateOfCharge.u }}</td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.stateOfHealth') }}</th>
-                          <td style="text-align: right">{{ batteryData.stateOfHealth.v.toFixed(1) }}</td>
-                          <td>{{ batteryData.stateOfHealth.u }}</td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.voltage') }}</th>
-                          <td style="text-align: right">{{ batteryData.voltage.v.toFixed(1) }}</td>
-                          <td>{{ batteryData.voltage.u }}</td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.current') }}</th>
-                          <td style="text-align: right">{{ batteryData.current.v.toFixed(1) }}</td>
-                          <td>{{ batteryData.current.u }}</td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.temperature') }}</th>
-                          <td style="text-align: right">{{ batteryData.temperature.v.toFixed(1) }}</td>
-                          <td>{{ batteryData.temperature.u }}</td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.chargeVoltage') }}</th>
-                          <td style="text-align: right">{{ batteryData.chargeVoltage.v.toFixed(1) }}</td>
-                          <td>{{ batteryData.chargeVoltage.u }}</td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.chargeCurrentLimitation') }}</th>
-                          <td style="text-align: right">{{ batteryData.chargeCurrentLimitation.v }}</td>
-                          <td>{{ batteryData.chargeCurrentLimitation.u }}</td>
+                        <tr v-for="(prop, key) in batteryData.values" v-bind:key="key">
+                          <th scope="row">{{ $t('battery.' + key) }}</th>
+                          <td style="text-align: right">
+                            <template v-if="typeof prop === 'string'">
+                              {{ $t('battery.' + prop) }}
+                            </template>
+                            <template v-else>
+                            {{ $n(prop.v, 'decimal', {
+                                 minimumFractionDigits: prop.d,
+                                 maximumFractionDigits: prop.d})
+                            }}
+                            </template>
+                          </td>
+                          <td v-if="typeof prop === 'string'"></td>
+                          <td v-else>{{prop.u}}</td>
                         </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.dischargeCurrentLimitation') }}</th>
-                          <td style="text-align: right">{{ batteryData.dischargeCurrentLimitation.v }}</td>
-                          <td>{{ batteryData.dischargeCurrentLimitation.u }}</td>
-                        </tr> 
                       </tbody>
                     </table>
                   </div>
                 </div>
               </div>
               <div class="col order-1">
-                <div class="card" :class="{ 'border-info': false }">
-                  <div class="card-header bg-info">{{ $t('battery.warn_alarm') }}</div>
-                  <div class="card-body">
+                <div class="card">
+                  <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') }}
+                      <div v-if="maxIssueValue === 0" class="badge text-bg-success">{{ $t('battery.noIssues') }}</div>
+                      <div v-else-if="maxIssueValue === 1" class="badge text-bg-warning text-dark">{{ $t('battery.warning') }}</div>
+                      <div v-else-if="maxIssueValue === 2" class="badge text-bg-danger">{{ $t('battery.alarm') }}</div>
+                    </div>
+                  </div>
+                  <div class="card-body" v-if="'issues' in batteryData">
                     <table class="table table-striped table-hover">
                       <thead>
                         <tr>
-                          <th scope="col">{{ $t('battery.Property') }}</th>
-                          <th scope="col">{{ $t('battery.alarm') }}</th>
-                          <th scope="col">{{ $t('battery.warning') }}</th>
+                          <th scope="col">{{ $t('battery.issueName') }}</th>
+                          <th scope="col">{{ $t('battery.issueType') }}</th>
                         </tr>
                       </thead>
                       <tbody>
-                        <tr>
-                          <th scope="row">{{ $t('battery.dischargeCurrent') }}</th>
-                          <td>
-                            <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.dischargeCurrent,
-                                'text-bg-success': !batteryData.alarms.dischargeCurrent
-                            }">
-                                <template v-if="!batteryData.alarms.dischargeCurrent">{{ $t('battery.ok') }}</template>
-                                <template v-else>{{ $t('battery.alarm') }}</template>
-                            </span>
-                          </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.dischargeCurrent,
-                                  'text-bg-success': !batteryData.warnings.dischargeCurrent
-                              }">
-                                  <template v-if="!batteryData.warnings.dischargeCurrent">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.chargeCurrent') }}</th>
-                          <td>
-                            <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.chargeCurrent,
-                                'text-bg-success': !batteryData.alarms.chargeCurrent
-                            }">
-                                <template v-if="!batteryData.alarms.chargeCurrent">{{ $t('battery.ok') }}</template>
-                                <template v-else>{{ $t('battery.alarm') }}</template>
-                            </span>
-                          </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.chargeCurrent,
-                                  'text-bg-success': !batteryData.warnings.chargeCurrent
-                              }">
-                                  <template v-if="!batteryData.warnings.chargeCurrent">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.lowTemperature') }}</th>
-                          <td>
-                            <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.lowTemperature,
-                                'text-bg-success': !batteryData.alarms.lowTemperature
-                            }">
-                                <template v-if="!batteryData.alarms.lowTemperature">{{ $t('battery.ok') }}</template>
-                                <template v-else>{{ $t('battery.alarm') }}</template>
-                            </span>
-                          </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.lowTemperature,
-                                  'text-bg-success': !batteryData.warnings.lowTemperature
-                              }">
-                                  <template v-if="!batteryData.warnings.lowTemperature">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.highTemperature') }}</th>
-                          <td>
-                            <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.highTemperature,
-                                'text-bg-success': !batteryData.alarms.highTemperature
-                            }">
-                                <template v-if="!batteryData.alarms.highTemperature">{{ $t('battery.ok') }}</template>
-                                <template v-else>{{ $t('battery.alarm') }}</template>
-                            </span>
-                          </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.highTemperature,
-                                  'text-bg-success': !batteryData.warnings.highTemperature
-                              }">
-                                  <template v-if="!batteryData.warnings.highTemperature">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.lowVoltage') }}</th>
-                          <td>
-                            <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.lowVoltage,
-                                'text-bg-success': !batteryData.alarms.lowVoltage
-                            }">
-                                <template v-if="!batteryData.alarms.lowVoltage">{{ $t('battery.ok') }}</template>
-                                <template v-else>{{ $t('battery.alarm') }}</template>
-                            </span>
-                          </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.lowVoltage,
-                                  'text-bg-success': !batteryData.warnings.lowVoltage
-                              }">
-                                  <template v-if="!batteryData.warnings.lowVoltage">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.highVoltage') }}</th>
+                        <tr v-for="(prop, key) in batteryData.issues" v-bind:key="key">
+                          <th scope="row">{{ $t('battery.' + key) }}</th>
                           <td>
                             <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.highVoltage,
-                                'text-bg-success': !batteryData.alarms.highVoltage
+                                'text-bg-warning text-dark': prop === 1,
+                                'text-bg-danger': prop === 2
                             }">
-                                <template v-if="!batteryData.alarms.highVoltage">{{ $t('battery.ok') }}</template>
+                                <template v-if="prop === 1">{{ $t('battery.warning') }}</template>
                                 <template v-else>{{ $t('battery.alarm') }}</template>
                             </span>
                           </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.highVoltage,
-                                  'text-bg-success': !batteryData.warnings.highVoltage
-                              }">
-                                  <template v-if="!batteryData.warnings.highVoltage">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
-                        </tr>
-                        <tr>
-                          <th scope="row">{{ $t('battery.bmsInternal') }}</th>
-                          <td>
-                            <span class="badge" :class="{
-                                'text-bg-danger': batteryData.alarms.bmsInternal,
-                                'text-bg-success': !batteryData.alarms.bmsInternal
-                            }">
-                                <template v-if="!batteryData.alarms.bmsInternal">{{ $t('battery.ok') }}</template>
-                                <template v-else>{{ $t('battery.alarm') }}</template>
-                            </span>
-                          </td>
-                          <td>
-                              <span class="badge" :class="{
-                                  'text-bg-warning text-dark': batteryData.warnings.bmsInternal,
-                                  'text-bg-success': !batteryData.warnings.bmsInternal
-                              }">
-                                  <template v-if="!batteryData.warnings.bmsInternal">{{ $t('battery.ok') }}</template>
-                                  <template v-else>{{ $t('battery.warning') }}</template>
-                              </span>
-                          </td>
                         </tr>
                       </tbody>
                     </table>
@@ -256,7 +103,7 @@
       </div>
     </div>
 
-  </template>
+  </div>
 </template>
 
 <script lang="ts">
@@ -295,7 +142,7 @@ export default defineComponent({
       console.log("Get initalData for Battery");
       this.dataLoading = true;
 
-      fetch("/api/battery/livedata", { headers: authHeader() })
+      fetch("/api/batterylivedata/status", { headers: authHeader() })
         .then((response) => handleResponse(response, this.$emitter, this.$router))
         .then((data) => {
           this.batteryData = data;
@@ -355,5 +202,10 @@ export default defineComponent({
       this.isFirstFetchAfterConnect = true;
     }
   },
+  computed: {
+    maxIssueValue() {
+      return ('issues' in this.batteryData)?Math.max(...Object.values(this.batteryData.issues)):0;
+    },
+  },
 });
 </script>
\ No newline at end of file
diff --git a/webapp/src/locales/de.json b/webapp/src/locales/de.json
index 49bfa89bd..458fd55c2 100644
--- a/webapp/src/locales/de.json
+++ b/webapp/src/locales/de.json
@@ -28,6 +28,8 @@
         "Login": "Anmelden"
     },
     "base": {
+        "Yes": "Ja",
+        "No": "Nein",
         "VerboseLogging": "Ausführliche Protokollierung",
         "Loading": "Lade...",
         "Reload": "Aktualisieren"
@@ -325,6 +327,7 @@
         "Status": "@:ntpinfo.Status",
         "Enabled": "@:mqttinfo.Enabled",
         "Disabled": "@:mqttinfo.Disabled",
+        "VerboseLogging": "@:base.VerboseLogging",
         "UpdatesOnly": "@:vedirectadmin.UpdatesOnly",
         "UpdatesEnabled": "@:mqttinfo.Enabled",
         "UpdatesDisabled": "@:mqttinfo.Disabled"
@@ -497,7 +500,7 @@
         "VedirectConfiguration": "VE.Direct Konfiguration",
         "EnableVedirect": "Aktiviere VE.Direct",
         "VedirectParameter": "VE.Direct Parameter",
-        "Seconds": "Sekunden",
+        "VerboseLogging": "@:base.VerboseLogging",
         "UpdatesOnly": "Werte nur bei Änderung an MQTT broker senden",
         "Save": "@:dtuadmin.Save"
     },
@@ -559,9 +562,9 @@
         "LowerPowerLimit": "Unteres Leistungslimit",
         "UpperPowerLimit": "Oberes Leistungslimit",
         "PowerMeters": "Leistungsmesser",
-        "BatterySocStartThreshold": "Akku SOC - Start",
-        "BatterySocStopThreshold": "Akku SOC - Stop",
-        "BatterySocSolarPassthroughStartThreshold": "Akku SOC - Start solar passthrough",
+        "BatterySocStartThreshold": "Akku SoC - Start",
+        "BatterySocStopThreshold": "Akku SoC - Stop",
+        "BatterySocSolarPassthroughStartThreshold": "Akku SoC - Start solar passthrough",
         "BatterySocSolarPassthroughStartThresholdHint": "Wenn der Batterie SOC über diesem Limit ist wird die Inverter Leistung entsprechend der Victron MPPT Leistung gesetzt (abzüglich Effizienzkorrekturfaktor). Kann verwendet werden um überschüssige Solarleistung an das Netz zu liefern wenn die Batterie voll ist.",
         "VoltageStartThreshold": "DC Spannung - Start",
         "VoltageStopThreshold": "DC Spannung - Stop",
@@ -569,7 +572,7 @@
         "VoltageSolarPassthroughStopThreshold": "DC Spannung - Stop Solar-Passthrough",
         "VoltageSolarPassthroughStartThresholdHint": "Wenn der Batteriespannung über diesem Limit ist wird die Inverter Leistung entsprechend der Victron MPPT Leistung gesetzt (abzüglich Effizienzkorrekturfaktor). Kann verwendet werden um überschüssige Solarleistung an das Netz zu liefern wenn die Batterie voll ist. Dieser Mode wird aktiv wenn das Start Spannungslimit überschritten wird und inaktiv wenn das Stop Spannungslimit unterschritten wird.",
         "VoltageLoadCorrectionFactor": "DC Spannung - Lastkorrekturfaktor",
-        "BatterySocInfo": "<b>Hinweis:</b> Der Battery SOC (State of charge) -Wert kann nur benutzt werden wenn das Battery CAN Bus Interface aktiviert ist. Wenn die Batterie innerhalb der letzten Minute keine Werte geschickt hat, werden als Fallback-Option die Spannungseinstellungen verwendet.",
+        "BatterySocInfo": "<b>Hinweis:</b> Die Akku SoC (State of Charge) Werte können nur benutzt werden, wenn die Batterie-Kommunikationsschnittstelle aktiviert ist. Wenn die Batterie innerhalb der letzten Minute keine Werte geschickt hat, werden als Fallback-Option die Spannungseinstellungen verwendet.",
         "InverterIsBehindPowerMeter": "Welchselrichter ist hinter Leistungsmesser",
         "Battery": "DC / Akku",
         "VoltageLoadCorrectionInfo": "<b>Hinweis:</b> Wenn Leistung von der Batterie abgegeben wird, bricht normalerweise die Spannung etwas ein. Damit nicht vorzeitig der Wechelrichter ausgeschaltet wird sobald der \"Stop\"-Schwellenwert erreicht wird, wird der hier angegebene Korrekturfaktor mit einberechnet. Korrigierte Spannung = DC Spannung + (Aktuelle Leistung (W) * Korrekturfaktor).",
@@ -580,8 +583,17 @@
     },
     "batteryadmin": {
         "BatterySettings": "Batterie Einstellungen",
-        "BatteryConfiguration": "Batterie Konfiguration",
-        "EnableBatteryCanBus": "Aktiviere Batterie CAN Bus Schnittstelle",
+        "BatteryConfiguration": "Generelle Schnittstelleneinstellungen",
+        "EnableBattery": "Aktiviere Schnittstelle",
+        "VerboseLogging": "@:base.VerboseLogging",
+        "Provider": "Datenanbieter",
+        "ProviderPylontechCan": "Pylontech per CAN-Bus",
+        "ProviderJkBmsSerial": "Jikong (JK) BMS per serieller Verbindung",
+        "JkBmsConfiguration": "JK BMS Einstellungen",
+        "JkBmsInterface": "Schnittstellentyp",
+        "JkBmsInterfaceUart": "TTL-UART an der MCU",
+        "JkBmsInterfaceTransceiver": "RS-485 Transceiver an der MCU",
+        "PollingInterval": "Abfrageintervall",
         "Seconds": "@:dtuadmin.Seconds",
         "Save": "@:dtuadmin.Save"
     },
@@ -761,9 +773,11 @@
         "Seconds": "vor {val} Sekunden",
         "Status": "Status",
         "Property": "Eigenschaft",
+        "yes": "@:base.Yes",
+        "no": "@:base.No",
         "Value": "Wert",
         "Unit": "Einheit",
-        "stateOfCharge": "Ladezustand (SoC)",
+        "SoC": "Ladezustand (SoC)",
         "stateOfHealth": "Batteriezustand (SoH)",
         "voltage": "Spannung",
         "current": "Strom",
@@ -771,16 +785,27 @@
         "chargeVoltage": "Gewünschte Ladespannung (BMS)",
         "chargeCurrentLimitation": "Ladestromlimit",
         "dischargeCurrentLimitation": "Entladestromlimit",
-        "warn_alarm": "Warnungen und Alarme",
-        "ok": "OK",
+        "chargeEnabled": "Laden ermöglicht",
+        "dischargeEnabled": "Entladen ermöglicht",
+        "chargeImmediately": "Sofortiges Laden angefordert",
+        "issues": "Meldungen",
+        "noIssues": "Keine Meldungen",
+        "issueName": "Bezeichnung",
+        "issueType": "Art",
         "alarm": "Alarm",
         "warning": "Warnung",
-        "dischargeCurrent": "Entladestrom",
-        "chargeCurrent": "Ladestrom",
-        "lowTemperature": "Temperatur niedrig",
-        "highTemperature": "Temperatur hoch",
-        "lowVoltage": "Spannung niedrig",
-        "highVoltage": "Spannung hoch",
+        "highCurrentDischarge": "Hoher Entladestrom",
+        "overCurrentDischarge": "Überstrom (Entladen)",
+        "highCurrentCharge": "Hoher Ladestrom",
+        "overCurrentCharge": "Überstrom (Laden)",
+        "lowTemperature": "Geringe Temperatur",
+        "underTemperature": "Untertemperatur",
+        "highTemperature": "Hohe Temperatur",
+        "overTemperature": "Übertemperatur",
+        "lowVoltage": "Niedrige Spannung",
+        "underVoltage": "Unterspannung",
+        "highVoltage": "Hohe Spannung",
+        "overVoltage": "Überspannung",
         "bmsInternal": "BMS intern"
       }
 }
diff --git a/webapp/src/locales/en.json b/webapp/src/locales/en.json
index c6e289c6b..72296e43a 100644
--- a/webapp/src/locales/en.json
+++ b/webapp/src/locales/en.json
@@ -28,6 +28,8 @@
         "Login": "Login"
     },
     "base": {
+        "Yes": "Yes",
+        "No": "No",
         "VerboseLogging": "Verbose Logging",
         "Loading": "Loading...",
         "Reload": "Reload"
@@ -327,6 +329,7 @@
         "Status": "@:ntpinfo.Status",
         "Enabled": "@:mqttinfo.Enabled",
         "Disabled": "@:mqttinfo.Disabled",
+        "VerboseLogging": "@:base.VerboseLogging",
         "UpdatesOnly": "@:vedirectadmin.UpdatesOnly",
         "UpdatesEnabled": "@:mqttinfo.Enabled",
         "UpdatesDisabled": "@:mqttinfo.Disabled"
@@ -499,7 +502,7 @@
         "VedirectConfiguration": "VE.Direct Configuration",
         "EnableVedirect": "Enable VE.Direct",
         "VedirectParameter": "VE.Direct Parameter",
-        "Seconds": "seconds",
+        "VerboseLogging": "@:base.VerboseLogging",
         "UpdatesOnly": "Publish values to MQTT only when they change",
         "Save": "@:dtuadmin.Save"
     },
@@ -568,9 +571,9 @@
         "MqttTopicPowerMeter1": "MQTT topic - Power meter #1",
         "MqttTopicPowerMeter2": "MQTT topic - Power meter #2 (optional)",
         "MqttTopicPowerMeter3": "MQTT topic - Power meter #3 (optional)",
-        "BatterySocStartThreshold": "Battery SOC - Start threshold",
-        "BatterySocStopThreshold": "Battery SOC - Stop threshold",
-        "BatterySocSolarPassthroughStartThreshold": "Battery SOC - Start threshold for full solar passthrough",
+        "BatterySocStartThreshold": "Battery SoC - Start threshold",
+        "BatterySocStopThreshold": "Battery SoC - Stop threshold",
+        "BatterySocSolarPassthroughStartThreshold": "Battery SoC - Start threshold for full solar passthrough",
         "BatterySocSolarPassthroughStartThresholdHint": "Inverter power is set according to Victron MPPT power (minus efficiency factors) if battery SoC is over this limit. Use this if you like to supply excess power to the grid when battery is full",
         "VoltageStartThreshold": "DC Voltage - Start threshold",
         "VoltageStopThreshold": "DC Voltage - Stop threshold",
@@ -578,7 +581,7 @@
         "VoltageSolarPassthroughStopThreshold": "DC Voltage - Stop threshold for full solar passthrough",
         "VoltageSolarPassthroughStartThresholdHint": "Inverter power is set according to Victron MPPT power (minus efficiency factors) when full solar passthrough is active. Use this if you like to supply excess power to the grid when battery is full. This is started when battery voltage goes over this limit and stopped if voltage drops below stop limit.",
         "VoltageLoadCorrectionFactor": "DC Voltage - Load correction factor",
-        "BatterySocInfo": "<b>Hint:</b> The battery SOC (State of charge) values can only be used when the Battery CAN Bus interface is enabled. If the battery has not reported any updates of SOC in the last minute, the voltage thresholds will be used as fallback.",
+        "BatterySocInfo": "<b>Hint:</b> The battery SoC (State of Charge) values can only be used if the battery communication interface is enabled. If the battery has not reported any SoC updates in the last minute, the voltage thresholds will be used as fallback.",
         "InverterIsBehindPowerMeter": "Inverter is behind Power meter",
         "Battery": "DC / Battery",
         "VoltageLoadCorrectionInfo": "<b>Hint:</b> When the power output is higher, the voltage is usually decreasing. In order to not stop the inverter too early (Stop treshold), a power factor can be specified here to correct this. Corrected voltage = DC Voltage + (Current power * correction factor).",
@@ -589,8 +592,17 @@
     },
     "batteryadmin": {
         "BatterySettings": "Battery Settings",
-        "BatteryConfiguration": "Battery Configuration",
-        "EnableBatteryCanBus": "Enable Battery CAN Bus Interface",
+        "BatteryConfiguration": "General Interface Settings",
+        "EnableBattery": "Enable Interface",
+        "VerboseLogging": "@:base.VerboseLogging",
+        "Provider": "Data Provider",
+        "ProviderPylontechCan": "Pylontech using CAN bus",
+        "ProviderJkBmsSerial": "Jikong (JK) BMS using serial connection",
+        "JkBmsConfiguration": "JK BMS Settings",
+        "JkBmsInterface": "Interface Type",
+        "JkBmsInterfaceUart": "TTL-UART on MCU",
+        "JkBmsInterfaceTransceiver": "RS-485 Transceiver on MCU",
+        "PollingInterval": "Polling Interval",
         "Seconds": "@:dtuadmin.Seconds",
         "Save": "@:dtuadmin.Save"
     },
@@ -766,31 +778,44 @@
         "Save": "@:dtuadmin.Save"
       },
       "battery": {
-        "battery": "battery",
+        "battery": "Battery",
         "DataAge": "Data Age: ",
         "Seconds": " {val} seconds",
         "Status": "Status",
         "Property": "Property",
+        "yes": "@:base.Yes",
+        "no": "@:base.No",
         "Value": "Value",
         "Unit": "Unit",
-        "stateOfCharge": "State of charge",
-        "stateOfHealth": "State of health",
+        "SoC": "State of Charge",
+        "stateOfHealth": "State of Health",
         "voltage": "Voltage",
         "current": "Current",
         "temperature": "Temperature",
         "chargeVoltage": "Requested charge voltage",
         "chargeCurrentLimitation": "Charge current limit",
         "dischargeCurrentLimitation": "Discharge current limit",
-        "warn_alarm": "Alarms and warnings",
-        "ok": "OK",
+        "chargeEnabled": "Charging possible",
+        "dischargeEnabled": "Discharging possible",
+        "chargeImmediately": "Immediate charging requested",
+        "issues": "Issues",
+        "noIssues": "No Issues",
+        "issueName": "Name",
+        "issueType": "Type",
         "alarm": "Alarm",
         "warning": "Warning",
-        "dischargeCurrent": "Discharge current",
-        "chargeCurrent": "Charge current",
+        "highCurrentDischarge": "High current (discharge)",
+        "overCurrentDischarge": "Overcurrent (discharge)",
+        "highCurrentCharge": "High current (charge)",
+        "overCurrentCharge": "Overcurrent (charge)",
         "lowTemperature": "Low temperature",
+        "underTemperature": "Undertemperature",
         "highTemperature": "High temperature",
+        "overTemperature": "Overtemperature",
         "lowVoltage": "Low voltage",
+        "underVoltage": "Undervoltage",
         "highVoltage": "High voltage",
+        "overVoltage": "Overvoltage",
         "bmsInternal": "BMS internal"
       }
 }
diff --git a/webapp/src/locales/fr.json b/webapp/src/locales/fr.json
index 861dc35fc..a4088ea87 100644
--- a/webapp/src/locales/fr.json
+++ b/webapp/src/locales/fr.json
@@ -28,6 +28,8 @@
         "Login": "Connexion"
     },
     "base": {
+        "Yes": "Oui",
+        "No": "Non",
         "VerboseLogging": "Journalisation Détaillée",
         "Loading": "Chargement...",
         "Reload": "Reload"
@@ -325,6 +327,7 @@
         "Status": "@:ntpinfo.Status",
         "Enabled": "@:mqttinfo.Enabled",
         "Disabled": "@:mqttinfo.Disabled",
+        "VerboseLogging": "@:base.VerboseLogging",
         "UpdatesOnly": "@:vedirectadmin.UpdatesOnly",
         "UpdatesEnabled": "@:mqttinfo.Enabled",
         "UpdatesDisabled": "@:mqttinfo.Disabled"
@@ -497,7 +500,7 @@
         "VedirectConfiguration": "VE.Direct Configuration",
         "EnableVedirect": "Enable VE.Direct",
         "VedirectParameter": "VE.Direct Parameter",
-        "Seconds": "seconds",
+        "VerboseLogging": "@:base.VerboseLogging",
         "UpdatesOnly": "Publish values to MQTT only when they change",
         "Save": "@:dtuadmin.Save"
     },
@@ -584,9 +587,9 @@
       "MqttTopicPowerMeter1": "MQTT topic - Power meter #1",
       "MqttTopicPowerMeter2": "MQTT topic - Power meter #2 (optional)",
       "MqttTopicPowerMeter3": "MQTT topic - Power meter #3 (optional)",
-      "BatterySocStartThreshold": "Battery SOC - Start threshold",
-      "BatterySocStopThreshold": "Battery SOC - Stop threshold",
-      "BatterySocSolarPassthroughStartThreshold": "Battery SOC - Start threshold for full solar passthrough",
+      "BatterySocStartThreshold": "Battery SoC - Start threshold",
+      "BatterySocStopThreshold": "Battery SoC - Stop threshold",
+      "BatterySocSolarPassthroughStartThreshold": "Battery SoC - Start threshold for full solar passthrough",
       "BatterySocSolarPassthroughStartThresholdHint": "Inverter power is set according to Victron MPPT power (minus efficiency factors) if battery SOC is over this limit. Use this if you like to supply excess power to the grid when battery is full",
       "VoltageStartThreshold": "DC Voltage - Start threshold",
       "VoltageStopThreshold": "DC Voltage - Stop threshold",
@@ -594,7 +597,7 @@
       "VoltageSolarPassthroughStopThreshold": "DC Voltage - Stop threshold for full solar passthrough",
       "VoltageSolarPassthroughStartThresholdHint": "Inverter power is set according to Victron MPPT power (minus efficiency factors) when full solar passthrough is active. Use this if you like to supply excess power to the grid when battery is full. This is started when battery voltage goes over this limit and stopped if voltage drops below stop limit.",
       "VoltageLoadCorrectionFactor": "DC Voltage - Load correction factor",
-      "BatterySocInfo": "<b>Hint:</b> The battery SOC (State of charge) values can only be used when the Battery CAN Bus interface is enabled. If the battery has not reported any updates of SOC in the last minute, the voltage thresholds will be used as fallback.",
+      "BatterySocInfo": "<b>Hint:</b> The battery SoC (State of Charge) values can only be used if the battery communication interface is enabled. If the battery has not reported any SoC updates in the last minute, the voltage thresholds will be used as fallback.",
       "InverterIsBehindPowerMeter": "Inverter is behind Power meter",
       "Battery": "DC / Battery",
       "VoltageLoadCorrectionInfo": "<b>Hint:</b> When the power output is higher, the voltage is usually decreasing. In order to not stop the inverter too early (Stop treshold), a power factor can be specified here to correct this. Corrected voltage = DC Voltage + (Current power * correction factor).",
@@ -720,9 +723,11 @@
         "Seconds": " {val} seconds",
         "Status": "Status",
         "Property": "Property",
+        "yes": "@:base.Yes",
+        "no": "@:base.No",
         "Value": "Value",
         "Unit": "Unit",
-        "stateOfCharge": "State of charge",
+        "SoC": "State of charge",
         "stateOfHealth": "State of health",
         "voltage": "Voltage",
         "current": "Current",
@@ -730,16 +735,24 @@
         "chargeVoltage": "Requested charge voltage",
         "chargeCurrentLimitation": "Charge current limit",
         "dischargeCurrentLimitation": "Discharge current limit",
-        "warn_alarm": "Alarms and warnings",
-        "ok": "OK",
+        "issues": "Issues",
+        "noIssues": "No Issues",
+        "issueName": "Name",
+        "issueType": "Type",
         "alarm": "Alarm",
         "warning": "Warning",
-        "dischargeCurrent": "Discharge current",
-        "chargeCurrent": "Charge current",
+        "highCurrentDischarge": "High current (discharge)",
+        "overCurrentDischarge": "Overcurrent (discharge)",
+        "highCurrentCharge": "High current (charge)",
+        "overCurrentCharge": "Overcurrent (charge)",
         "lowTemperature": "Low temperature",
+        "underTemperature": "Undertemperature",
         "highTemperature": "High temperature",
+        "overTemperature": "Overtemperature",
         "lowVoltage": "Low voltage",
+        "underVoltage": "Undervoltage",
         "highVoltage": "High voltage",
+        "overVoltage": "Overvoltage",
         "bmsInternal": "BMS internal"
       }
 }
diff --git a/webapp/src/types/BatteryConfig.ts b/webapp/src/types/BatteryConfig.ts
index 2b80df5ca..8bd05000a 100644
--- a/webapp/src/types/BatteryConfig.ts
+++ b/webapp/src/types/BatteryConfig.ts
@@ -1,3 +1,7 @@
 export interface BatteryConfig {
     enabled: boolean;
+    verbose_logging: boolean;
+    provider: number;
+    jkbms_interface: number;
+    jkbms_polling_interval: number;
 }
diff --git a/webapp/src/types/BatteryDataStatus.ts b/webapp/src/types/BatteryDataStatus.ts
index 7427cfb8e..612f35cf0 100644
--- a/webapp/src/types/BatteryDataStatus.ts
+++ b/webapp/src/types/BatteryDataStatus.ts
@@ -1,32 +1,8 @@
 import type { ValueObject } from '@/types/LiveDataStatus';
 
-interface BatteryFlags {
-    dischargeCurrent: boolean;
-    chargeCurrent: boolean;
-    lowTemperature: boolean;
-    highTemperature: boolean;
-    lowVoltage: boolean;
-    highVoltage: boolean;
-    bmsInternal: boolean;
-}
-
-
-// Battery
 export interface Battery {
-    data_age: 0;
-    chargeVoltage: ValueObject;
-    chargeCurrentLimitation: ValueObject;
-    dischargeCurrentLimitation: ValueObject;
-    stateOfCharge: ValueObject;
-    stateOfChargeLastUpdate: ValueObject;
-    stateOfHealth: ValueObject;
-    voltage: ValueObject;
-    current: ValueObject;
-    temperature: ValueObject;
-    warnings: BatteryFlags;
-    alarms: BatteryFlags;
     manufacturer: string;
-    chargeEnabled: boolean;
-    dischargeEnabled: boolean;
-    chargeImmediately: boolean;
+    data_age: number;
+    values: (ValueObject | string)[];
+    issues: number[];
 }
\ No newline at end of file
diff --git a/webapp/src/types/VedirectConfig.ts b/webapp/src/types/VedirectConfig.ts
index 59a875221..8b2e356cf 100644
--- a/webapp/src/types/VedirectConfig.ts
+++ b/webapp/src/types/VedirectConfig.ts
@@ -1,4 +1,5 @@
 export interface VedirectConfig {
     vedirect_enabled: boolean;
+    verbose_logging: boolean;
     vedirect_updatesonly: boolean;
 }
diff --git a/webapp/src/types/VedirectStatus.ts b/webapp/src/types/VedirectStatus.ts
index 574e4a68f..a3dbed83b 100644
--- a/webapp/src/types/VedirectStatus.ts
+++ b/webapp/src/types/VedirectStatus.ts
@@ -1,4 +1,5 @@
 export interface VedirectStatus {
     vedirect_enabled: boolean;
+    verbose_logging: boolean;
     vedirect_updatesonly: boolean;
 }
\ No newline at end of file
diff --git a/webapp/src/views/BatteryAdminView.vue b/webapp/src/views/BatteryAdminView.vue
index 18f9698d5..b1475c164 100644
--- a/webapp/src/views/BatteryAdminView.vue
+++ b/webapp/src/views/BatteryAdminView.vue
@@ -6,9 +6,47 @@
 
         <form @submit="saveBatteryConfig">
             <CardElement :text="$t('batteryadmin.BatteryConfiguration')" textVariant="text-bg-primary">
-                <InputElement :label="$t('batteryadmin.EnableBatteryCanBus')"
+                <InputElement :label="$t('batteryadmin.EnableBattery')"
                               v-model="batteryConfigList.enabled"
-                              type="checkbox" wide/>
+                              type="checkbox" />
+
+                <InputElement v-show="batteryConfigList.enabled"
+                                :label="$t('batteryadmin.VerboseLogging')"
+                                v-model="batteryConfigList.verbose_logging"
+                                type="checkbox"/>
+
+                <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>
+                </div>
+            </CardElement>
+
+            <CardElement v-show="batteryConfigList.enabled && batteryConfigList.provider == 1"
+                         :text="$t('batteryadmin.JkBmsConfiguration')" textVariant="text-bg-primary" addSpace>
+                <div class="row mb-3">
+                    <label class="col-sm-2 col-form-label">
+                        {{ $t('batteryadmin.JkBmsInterface') }}
+                    </label>
+                    <div class="col-sm-10">
+                        <select class="form-select" v-model="batteryConfigList.jkbms_interface">
+                            <option v-for="jkBmsInterface in jkBmsInterfaceTypeList" :key="jkBmsInterface.key" :value="jkBmsInterface.key">
+                                {{ $t(`batteryadmin.JkBmsInterface` + jkBmsInterface.value) }}
+                            </option>
+                        </select>
+                    </div>
+                </div>
+
+                <InputElement :label="$t('batteryadmin.PollingInterval')"
+                              v-model="batteryConfigList.jkbms_polling_interval"
+                              type="number" min="2" max="90" step="1" :postfix="$t('batteryadmin.Seconds')"/>
             </CardElement>
 
             <button type="submit" class="btn btn-primary mb-3">{{ $t('batteryadmin.Save') }}</button>
@@ -39,6 +77,14 @@ export default defineComponent({
             alertMessage: "",
             alertType: "info",
             showAlert: false,
+            providerTypeList: [
+                { key: 0, value: 'PylontechCan' },
+                { key: 1, value: 'JkBmsSerial' },
+            ],
+            jkBmsInterfaceTypeList: [
+                { key: 0, value: 'Uart' },
+                { key: 1, value: 'Transceiver' },
+            ],
         };
     },
     created() {
diff --git a/webapp/src/views/VedirectAdminView.vue b/webapp/src/views/VedirectAdminView.vue
index 1431ee1b8..02aa48b8b 100644
--- a/webapp/src/views/VedirectAdminView.vue
+++ b/webapp/src/views/VedirectAdminView.vue
@@ -12,8 +12,12 @@
             </CardElement>
 
             <CardElement :text="$t('vedirectadmin.VedirectParameter')" textVariant="text-bg-primary" add-space
-                         v-show="vedirectConfigList.vedirect_enabled"
-            >
+                         v-show="vedirectConfigList.vedirect_enabled">
+
+                <InputElement :label="$t('vedirectadmin.VerboseLogging')"
+                              v-model="vedirectConfigList.verbose_logging"
+                              type="checkbox" wide/>
+
                 <InputElement :label="$t('vedirectadmin.UpdatesOnly')"
                               v-model="vedirectConfigList.vedirect_updatesonly"
                               type="checkbox" wide/>
diff --git a/webapp/src/views/VedirectInfoView.vue b/webapp/src/views/VedirectInfoView.vue
index 39a109cb7..14b7efa61 100644
--- a/webapp/src/views/VedirectInfoView.vue
+++ b/webapp/src/views/VedirectInfoView.vue
@@ -10,6 +10,12 @@
                                 <StatusBadge :status="vedirectDataList.vedirect_enabled" true_text="vedirectinfo.Enabled" false_text="vedirectinfo.Disabled" />
                             </td>
                         </tr>
+                        <tr>
+                            <th>{{ $t('vedirectinfo.VerboseLogging') }}</th>
+                            <td>
+                                <StatusBadge :status="vedirectDataList.verbose_logging" true_text="vedirectinfo.Enabled" false_text="vedirectinfo.Disabled" />
+                            </td>
+                        </tr>
                         <tr>
                             <th>{{ $t('vedirectinfo.UpdatesOnly') }}</th>
                             <td>
diff --git a/webapp_dist/js/app.js.gz b/webapp_dist/js/app.js.gz
index 7e0989bc9..7889962a1 100644
Binary files a/webapp_dist/js/app.js.gz and b/webapp_dist/js/app.js.gz differ