diff --git a/include/Battery.h b/include/Battery.h
deleted file mode 100644
index 1265a8bb2..000000000
--- a/include/Battery.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include <memory>
-#include <mutex>
-#include <TaskSchedulerDeclarations.h>
-
-#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:
-    void init(Scheduler&);
-    void updateSettings();
-
-    float getDischargeCurrentLimit();
-
-    std::shared_ptr<BatteryStats const> getStats() const;
-
-private:
-    void loop();
-
-    Task _loopTask;
-    mutable std::mutex _mutex;
-    std::unique_ptr<BatteryProvider> _upProvider = nullptr;
-};
-
-extern BatteryClass Battery;
diff --git a/include/BatteryStats.h b/include/BatteryStats.h
deleted file mode 100644
index cfce8ea88..000000000
--- a/include/BatteryStats.h
+++ /dev/null
@@ -1,354 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include <stdint.h>
-
-#include "AsyncJson.h"
-#include "Arduino.h"
-#include "JkBmsDataPoints.h"
-#include "JbdBmsDataPoints.h"
-#include "VeDirectShuntController.h"
-#include <cfloat>
-
-// mandatory interface for all kinds of batteries
-class BatteryStats {
-    public:
-        String const& getManufacturer() const { return _manufacturer; }
-
-        // the last time *any* data was updated
-        uint32_t getAgeSeconds() const { return (millis() - _lastUpdate) / 1000; }
-        bool updateAvailable(uint32_t since) const;
-
-        float getSoC() const { return _soc; }
-        uint32_t getSoCAgeSeconds() const { return (millis() - _lastUpdateSoC) / 1000; }
-        uint8_t getSoCPrecision() const { return _socPrecision; }
-
-        float getVoltage() const { return _voltage; }
-        uint32_t getVoltageAgeSeconds() const { return (millis() - _lastUpdateVoltage) / 1000; }
-
-        float getChargeCurrent() const { return _current; };
-        uint8_t getChargeCurrentPrecision() const { return _currentPrecision; }
-
-        float getDischargeCurrentLimit() const { return _dischargeCurrentLimit; };
-        uint32_t getDischargeCurrentLimitAgeSeconds() const { return (millis() - _lastUpdateDischargeCurrentLimit) / 1000; }
-
-        // convert stats to JSON for web application live view
-        virtual void getLiveViewData(JsonVariant& root) const;
-
-        void mqttLoop();
-
-        // the interval at which all battery data will be re-published, even
-        // if they did not change. used to calculate Home Assistent expiration.
-        virtual uint32_t getMqttFullPublishIntervalMs() const;
-
-        bool isSoCValid() const { return _lastUpdateSoC > 0; }
-        bool isVoltageValid() const { return _lastUpdateVoltage > 0; }
-        bool isCurrentValid() const { return _lastUpdateCurrent > 0; }
-        bool isDischargeCurrentLimitValid() const { return _lastUpdateDischargeCurrentLimit > 0; }
-
-        // returns true if the battery reached a critically low voltage/SoC,
-        // such that it is in need of charging to prevent degredation.
-        virtual bool getImmediateChargingRequest() const { return false; };
-
-        virtual float getChargeCurrentLimitation() const { return FLT_MAX; };
-
-        virtual bool supportsAlarmsAndWarnings() const { return true; };
-
-    protected:
-        virtual void mqttPublish() const;
-
-        void setSoC(float soc, uint8_t precision, uint32_t timestamp) {
-            _soc = soc;
-            _socPrecision = precision;
-            _lastUpdateSoC = _lastUpdate = timestamp;
-        }
-
-        void setVoltage(float voltage, uint32_t timestamp) {
-            _voltage = voltage;
-            _lastUpdateVoltage = _lastUpdate = timestamp;
-        }
-
-        void setCurrent(float current, uint8_t precision, uint32_t timestamp) {
-            _current = current;
-            _currentPrecision = precision;
-            _lastUpdateCurrent = _lastUpdate = timestamp;
-        }
-
-        void setDischargeCurrentLimit(float dischargeCurrentLimit, uint32_t timestamp) {
-            _dischargeCurrentLimit = dischargeCurrentLimit;
-            _lastUpdateDischargeCurrentLimit = _lastUpdate = timestamp;
-        }
-
-        void setManufacturer(const String& m);
-
-        String _hwversion = "";
-        String _fwversion = "";
-        String _serial = "";
-        uint32_t _lastUpdate = 0;
-
-    private:
-        String _manufacturer = "unknown";
-        uint32_t _lastMqttPublish = 0;
-        float _soc = 0;
-        uint8_t _socPrecision = 0; // decimal places
-        uint32_t _lastUpdateSoC = 0;
-        float _voltage = 0; // total battery pack voltage
-        uint32_t _lastUpdateVoltage = 0;
-
-        // total current into (positive) or from (negative)
-        // the battery, i.e., the charging current
-        float _current = 0;
-        uint8_t _currentPrecision = 0; // decimal places
-        uint32_t _lastUpdateCurrent = 0;
-
-        float _dischargeCurrentLimit = 0;
-        uint32_t _lastUpdateDischargeCurrentLimit = 0;
-};
-
-class PylontechBatteryStats : public BatteryStats {
-    friend class PylontechCanReceiver;
-
-    public:
-        void getLiveViewData(JsonVariant& root) const final;
-        void mqttPublish() const final;
-        bool getImmediateChargingRequest() const { return _chargeImmediately; } ;
-        float getChargeCurrentLimitation() const { return _chargeCurrentLimitation; } ;
-
-    private:
-        void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
-
-        float _chargeVoltage;
-        float _chargeCurrentLimitation;
-        float _dischargeVoltageLimitation;
-        uint16_t _stateOfHealth;
-        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;
-
-        uint8_t _moduleCount;
-};
-
-class SBSBatteryStats : public BatteryStats {
-    friend class SBSCanReceiver;
-
-    public:
-        void getLiveViewData(JsonVariant& root) const final;
-        void mqttPublish() const final;
-        float getChargeCurrent() const { return _current; } ;
-        float getChargeCurrentLimitation() const { return _chargeCurrentLimitation; } ;
-
-    private:
-        void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
-
-        float _chargeVoltage;
-        float _chargeCurrentLimitation;
-        uint16_t _stateOfHealth;
-        float _current;
-        float _temperature;
-
-        bool _alarmUnderTemperature;
-        bool _alarmOverTemperature;
-        bool _alarmUnderVoltage;
-        bool _alarmOverVoltage;
-        bool _alarmBmsInternal;
-
-        bool _warningHighCurrentDischarge;
-        bool _warningHighCurrentCharge;
-
-        bool _chargeEnabled;
-        bool _dischargeEnabled;
-};
-
-class PytesBatteryStats : public BatteryStats {
-    friend class PytesCanReceiver;
-
-    public:
-        void getLiveViewData(JsonVariant& root) const final;
-        void mqttPublish() const final;
-        bool getImmediateChargingRequest() const { return _chargeImmediately; };
-        float getChargeCurrentLimitation() const { return _chargeCurrentLimit; };
-
-    private:
-        void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
-        void updateSerial() {
-            if (!_serialPart1.isEmpty() && !_serialPart2.isEmpty()) {
-                _serial = _serialPart1 + _serialPart2;
-            }
-        }
-
-        String _serialPart1 = "";
-        String _serialPart2 = "";
-
-        float _chargeVoltageLimit;
-        float _chargeCurrentLimit;
-        float _dischargeVoltageLimit;
-
-        uint16_t _stateOfHealth;
-        int _chargeCycles = -1;
-        int _balance = -1;
-
-        float _temperature;
-
-        uint16_t _cellMinMilliVolt;
-        uint16_t _cellMaxMilliVolt;
-        float _cellMinTemperature;
-        float _cellMaxTemperature;
-
-        String _cellMinVoltageName;
-        String _cellMaxVoltageName;
-        String _cellMinTemperatureName;
-        String _cellMaxTemperatureName;
-
-        uint8_t _moduleCountOnline;
-        uint8_t _moduleCountOffline;
-
-        uint8_t _moduleCountBlockingCharge;
-        uint8_t _moduleCountBlockingDischarge;
-
-        float _totalCapacity;
-        float _availableCapacity;
-        uint8_t _capacityPrecision = 0; // decimal places
-
-        float _chargedEnergy = -1;
-        float _dischargedEnergy = -1;
-
-        bool _alarmUnderVoltage;
-        bool _alarmOverVoltage;
-        bool _alarmOverCurrentCharge;
-        bool _alarmOverCurrentDischarge;
-        bool _alarmUnderTemperature;
-        bool _alarmOverTemperature;
-        bool _alarmUnderTemperatureCharge;
-        bool _alarmOverTemperatureCharge;
-        bool _alarmInternalFailure;
-        bool _alarmCellImbalance;
-
-        bool _warningLowVoltage;
-        bool _warningHighVoltage;
-        bool _warningHighChargeCurrent;
-        bool _warningHighDischargeCurrent;
-        bool _warningLowTemperature;
-        bool _warningHighTemperature;
-        bool _warningLowTemperatureCharge;
-        bool _warningHighTemperatureCharge;
-        bool _warningInternalFailure;
-        bool _warningCellImbalance;
-
-        bool _chargeImmediately;
-};
-
-class JkBmsBatteryStats : public BatteryStats {
-    public:
-        void getLiveViewData(JsonVariant& root) const final {
-            getJsonData(root, false);
-        }
-
-        void getInfoViewData(JsonVariant& root) const {
-            getJsonData(root, true);
-        }
-
-        void mqttPublish() const final;
-
-        uint32_t getMqttFullPublishIntervalMs() const final { return 60 * 1000; }
-
-        void updateFrom(JkBms::DataPointContainer const& dp);
-
-    private:
-        void getJsonData(JsonVariant& root, bool verbose) const;
-
-        JkBms::DataPointContainer _dataPoints;
-        mutable uint32_t _lastMqttPublish = 0;
-        mutable uint32_t _lastFullMqttPublish = 0;
-
-        uint16_t _cellMinMilliVolt = 0;
-        uint16_t _cellAvgMilliVolt = 0;
-        uint16_t _cellMaxMilliVolt = 0;
-        uint32_t _cellVoltageTimestamp = 0;
-};
-
-class JbdBmsBatteryStats : public BatteryStats {
-    public:
-        void getLiveViewData(JsonVariant& root) const final {
-            getJsonData(root, false);
-        }
-
-        void getInfoViewData(JsonVariant& root) const {
-            getJsonData(root, true);
-        }
-
-        void mqttPublish() const final;
-
-        uint32_t getMqttFullPublishIntervalMs() const final { return 60 * 1000; }
-
-        void updateFrom(JbdBms::DataPointContainer const& dp);
-
-    private:
-        void getJsonData(JsonVariant& root, bool verbose) const;
-
-        JbdBms::DataPointContainer _dataPoints;
-        mutable uint32_t _lastMqttPublish = 0;
-        mutable uint32_t _lastFullMqttPublish = 0;
-
-        uint16_t _cellMinMilliVolt = 0;
-        uint16_t _cellAvgMilliVolt = 0;
-        uint16_t _cellMaxMilliVolt = 0;
-        uint32_t _cellVoltageTimestamp = 0;
-};
-
-class VictronSmartShuntStats : public BatteryStats {
-    public:
-        void getLiveViewData(JsonVariant& root) const final;
-        void mqttPublish() const final;
-
-        void updateFrom(VeDirectShuntController::data_t const& shuntData);
-
-    private:
-        float _temperature;
-        bool _tempPresent;
-        uint8_t _chargeCycles;
-        uint32_t _timeToGo;
-        float _chargedEnergy;
-        float _dischargedEnergy;
-        int32_t _instantaneousPower;
-        float _midpointVoltage;
-        float _midpointDeviation;
-        float _consumedAmpHours;
-        int32_t _lastFullCharge;
-
-        bool _alarmLowVoltage;
-        bool _alarmHighVoltage;
-        bool _alarmLowSOC;
-        bool _alarmLowTemperature;
-        bool _alarmHighTemperature;
-};
-
-class MqttBatteryStats : public BatteryStats {
-    friend class MqttBattery;
-
-    public:
-        // since the source of information was MQTT in the first place,
-        // we do NOT publish the same data under a different topic.
-        void mqttPublish() const final { }
-
-        void getLiveViewData(JsonVariant& root) const final;
-
-        bool supportsAlarmsAndWarnings() const final { return false; }
-};
diff --git a/include/JbdBmsController.h b/include/JbdBmsController.h
deleted file mode 100644
index 98764771d..000000000
--- a/include/JbdBmsController.h
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-#include <frozen/string.h>
-
-#include "Battery.h"
-#include "JbdBmsDataPoints.h"
-#include "JbdBmsSerialMessage.h"
-#include "JbdBmsController.h"
-
-namespace JbdBms {
-
-class Controller : public BatteryProvider {
-    public:
-        Controller() = default;
-
-        bool init(bool verboseLogging) final;
-        void deinit() final;
-        void loop() final;
-        std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
-
-    private:
-        static char constexpr _serialPortOwner[] = "JBD BMS";
-
-#ifdef JBDBMS_DUMMY_SERIAL
-        std::unique_ptr<DummySerial> _upSerial;
-#else
-        std::unique_ptr<HardwareSerial> _upSerial;
-#endif
-
-        enum class Status : unsigned {
-            Initializing,
-            Timeout,
-            WaitingForPollInterval,
-            HwSerialNotAvailableForWrite,
-            BusyReading,
-            RequestSent,
-            FrameCompleted
-        };
-
-        frozen::string const& getStatusText(Status status);
-        void announceStatus(Status status);
-        void sendRequest(uint8_t pollInterval);
-        void rxData(uint8_t inbyte);
-        void reset();
-        void frameComplete();
-        void processDataPoints(DataPointContainer const& dataPoints);
-
-        enum class Interface : unsigned {
-            Invalid,
-            Uart,
-            Transceiver
-        };
-
-        Interface getInterface() const;
-
-        enum class ReadState : unsigned {
-            Idle,
-            WaitingForFrameStart,
-            FrameStartReceived, // 1 Byte: 0xDD
-            StateReceived,
-            CommandCodeReceived,
-            ReadingDataContent,
-            DataContentReceived,
-            ReadingCheckSum,
-            CheckSumReceived,
-        };
-
-        ReadState _readState;
-        void setReadState(ReadState state) {
-            _readState = state;
-        }
-
-        bool _verboseLogging = true;
-        int8_t _rxEnablePin = -1;
-        int8_t _txEnablePin = -1;
-        Status _lastStatus = Status::Initializing;
-        uint32_t _lastStatusPrinted = 0;
-        uint32_t _lastRequest = 0;
-        uint8_t _dataLength = 0;
-        JbdBms::SerialResponse::tData _buffer = {};
-        std::shared_ptr<JbdBmsBatteryStats> _stats =
-            std::make_shared<JbdBmsBatteryStats>();
-};
-
-} /* namespace JbdBms */
diff --git a/include/JkBmsController.h b/include/JkBmsController.h
deleted file mode 100644
index b2c71c454..000000000
--- a/include/JkBmsController.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-#include <frozen/string.h>
-
-#include "Battery.h"
-#include "JkBmsDataPoints.h"
-#include "JkBmsSerialMessage.h"
-#include "JkBmsDummy.h"
-
-//#define JKBMS_DUMMY_SERIAL
-
-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:
-        static char constexpr _serialPortOwner[] = "JK BMS";
-
-#ifdef JKBMS_DUMMY_SERIAL
-        std::unique_ptr<DummySerial> _upSerial;
-#else
-        std::unique_ptr<HardwareSerial> _upSerial;
-#endif
-
-        enum class Status : unsigned {
-            Initializing,
-            Timeout,
-            WaitingForPollInterval,
-            HwSerialNotAvailableForWrite,
-            BusyReading,
-            RequestSent,
-            FrameCompleted
-        };
-
-        frozen::string const& getStatusText(Status status);
-        void announceStatus(Status status);
-        void sendRequest(uint8_t pollInterval);
-        void rxData(uint8_t inbyte);
-        void reset();
-        void frameComplete();
-        void processDataPoints(DataPointContainer const& dataPoints);
-
-        enum class Interface : unsigned {
-            Invalid,
-            Uart,
-            Transceiver
-        };
-
-        Interface getInterface() const;
-
-        enum class ReadState : unsigned {
-            Idle,
-            WaitingForFrameStart,
-            FrameStartReceived,
-            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/MqttHandleBatteryHass.h b/include/MqttHandleBatteryHass.h
deleted file mode 100644
index f328a6f88..000000000
--- a/include/MqttHandleBatteryHass.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include <ArduinoJson.h>
-#include <TaskSchedulerDeclarations.h>
-
-class MqttHandleBatteryHassClass {
-public:
-    void init(Scheduler& scheduler);
-    void forceUpdate() { _doPublish = true; }
-
-private:
-    void loop();
-    void publish(const String& subtopic, const String& payload);
-    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);
-
-    Task _loopTask;
-
-    bool _doPublish = true;
-    String serial = "0001"; // pseudo-serial, can be replaced in future with real serialnumber
-};
-
-extern MqttHandleBatteryHassClass MqttHandleBatteryHass;
diff --git a/include/PylontechCanReceiver.h b/include/PylontechCanReceiver.h
deleted file mode 100644
index 24bae8c06..000000000
--- a/include/PylontechCanReceiver.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include "Configuration.h"
-#include "Battery.h"
-#include "BatteryCanReceiver.h"
-#include <driver/twai.h>
-#include <Arduino.h>
-
-class PylontechCanReceiver : public BatteryCanReceiver {
-public:
-    bool init(bool verboseLogging) final;
-    void onMessage(twai_message_t rx_message) final;
-
-    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
-
-private:
-    void dummyData();
-
-    std::shared_ptr<PylontechBatteryStats> _stats =
-        std::make_shared<PylontechBatteryStats>();
-};
diff --git a/include/PytesCanReceiver.h b/include/PytesCanReceiver.h
deleted file mode 100644
index aaeb9d66d..000000000
--- a/include/PytesCanReceiver.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include "Configuration.h"
-#include "Battery.h"
-#include "BatteryCanReceiver.h"
-#include <driver/twai.h>
-
-class PytesCanReceiver : public BatteryCanReceiver {
-public:
-    bool init(bool verboseLogging) final;
-    void onMessage(twai_message_t rx_message) final;
-
-    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
-
-private:
-    std::shared_ptr<PytesBatteryStats> _stats =
-        std::make_shared<PytesBatteryStats>();
-};
diff --git a/include/SBSCanReceiver.h b/include/SBSCanReceiver.h
deleted file mode 100644
index 0cec94196..000000000
--- a/include/SBSCanReceiver.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include "BatteryCanReceiver.h"
-#include <driver/twai.h>
-#include <Arduino.h>
-
-class SBSCanReceiver : public BatteryCanReceiver {
-public:
-    bool init(bool verboseLogging) final;
-    void onMessage(twai_message_t rx_message) final;
-
-    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
-
-private:
-    void dummyData();
-    std::shared_ptr<SBSBatteryStats> _stats =
-        std::make_shared<SBSBatteryStats>();
-};
diff --git a/include/VictronSmartShunt.h b/include/VictronSmartShunt.h
deleted file mode 100644
index 10bf1c523..000000000
--- a/include/VictronSmartShunt.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#include "Battery.h"
-
-class VictronSmartShunt : public BatteryProvider {
-public:
-    bool init(bool verboseLogging) final;
-    void deinit() final;
-    void loop() final;
-    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
-
-private:
-    static char constexpr _serialPortOwner[] = "SmartShunt";
-
-    uint32_t _lastUpdate = 0;
-    std::shared_ptr<VictronSmartShuntStats> _stats =
-        std::make_shared<VictronSmartShuntStats>();
-};
diff --git a/include/BatteryCanReceiver.h b/include/battery/CanReceiver.h
similarity index 83%
rename from include/BatteryCanReceiver.h
rename to include/battery/CanReceiver.h
index 225cceed8..fc82fdc88 100644
--- a/include/BatteryCanReceiver.h
+++ b/include/battery/CanReceiver.h
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #pragma once
 
-#include "Battery.h"
+#include <stdint.h>
 #include <driver/twai.h>
-#include <Arduino.h>
+#include <battery/Provider.h>
 
-class BatteryCanReceiver : public BatteryProvider {
+namespace BatteryNs {
+
+class CanReceiver : public Provider {
 public:
     bool init(bool verboseLogging, char const* providerName);
     void deinit() final;
@@ -27,3 +29,5 @@ class BatteryCanReceiver : public BatteryProvider {
 private:
     char const* _providerName = "Battery CAN";
 };
+
+} // namespace BatteryNs
diff --git a/include/battery/Controller.h b/include/battery/Controller.h
new file mode 100644
index 000000000..6d53e6486
--- /dev/null
+++ b/include/battery/Controller.h
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <TaskSchedulerDeclarations.h>
+#include <battery/Provider.h>
+#include <battery/Stats.h>
+
+namespace BatteryNs {
+
+class Controller {
+public:
+    void init(Scheduler&);
+    void updateSettings();
+
+    float getDischargeCurrentLimit();
+
+    std::shared_ptr<Stats const> getStats() const;
+
+private:
+    void loop();
+
+    Task _loopTask;
+    mutable std::mutex _mutex;
+    std::unique_ptr<Provider> _upProvider = nullptr;
+    bool _publishSensors = false;
+};
+
+} // namespace BatteryNs
+
+extern BatteryNs::Controller Battery;
diff --git a/include/battery/HassIntegration.h b/include/battery/HassIntegration.h
new file mode 100644
index 000000000..0c681d6a5
--- /dev/null
+++ b/include/battery/HassIntegration.h
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <Arduino.h>
+#include <ArduinoJson.h>
+
+namespace BatteryNs {
+
+class HassIntegration {
+public:
+    virtual void publishSensors() const;
+
+protected:
+    void publish(const String& subtopic, const String& payload) const;
+    void publishBinarySensor(const char* caption,
+            const char* icon, const char* subTopic,
+            const char* payload_on, const char* payload_off) const;
+    void publishSensor(const char* caption, const char* icon,
+            const char* subTopic, const char* deviceClass = nullptr,
+            const char* stateClass = nullptr,
+            const char* unitOfMeasurement = nullptr) const;
+    void createDeviceInfo(JsonObject& object) const;
+
+    String _serial = "0001"; // pseudo-serial, can be replaced in future with real serialnumber
+};
+
+} // namespace BatteryNs
diff --git a/include/battery/Provider.h b/include/battery/Provider.h
new file mode 100644
index 000000000..f7cca634b
--- /dev/null
+++ b/include/battery/Provider.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <memory>
+
+namespace BatteryNs {
+
+class Stats;
+class HassIntegration;
+
+class Provider {
+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<Stats> getStats() const = 0;
+    virtual HassIntegration const& getHassIntegration() const = 0;
+};
+
+} // namespace BatteryNs
diff --git a/include/battery/Stats.h b/include/battery/Stats.h
new file mode 100644
index 000000000..aae869511
--- /dev/null
+++ b/include/battery/Stats.h
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <Arduino.h>
+#include <stdint.h>
+#include <AsyncJson.h>
+#include <cfloat>
+#include <string>
+
+namespace BatteryNs {
+
+// mandatory interface for all kinds of batteries
+class Stats {
+public:
+    String const& getManufacturer() const { return _manufacturer; }
+
+    // the last time *any* data was updated
+    uint32_t getAgeSeconds() const { return (millis() - _lastUpdate) / 1000; }
+    bool updateAvailable(uint32_t since) const;
+
+    float getSoC() const { return _soc; }
+    uint32_t getSoCAgeSeconds() const { return (millis() - _lastUpdateSoC) / 1000; }
+    uint8_t getSoCPrecision() const { return _socPrecision; }
+
+    float getVoltage() const { return _voltage; }
+    uint32_t getVoltageAgeSeconds() const { return (millis() - _lastUpdateVoltage) / 1000; }
+
+    float getChargeCurrent() const { return _current; };
+    uint8_t getChargeCurrentPrecision() const { return _currentPrecision; }
+
+    float getDischargeCurrentLimit() const { return _dischargeCurrentLimit; };
+    uint32_t getDischargeCurrentLimitAgeSeconds() const { return (millis() - _lastUpdateDischargeCurrentLimit) / 1000; }
+
+    // convert stats to JSON for web application live view
+    virtual void getLiveViewData(JsonVariant& root) const;
+
+    void mqttLoop();
+
+    // the interval at which all battery data will be re-published, even
+    // if they did not change. used to calculate Home Assistent expiration.
+    virtual uint32_t getMqttFullPublishIntervalMs() const;
+
+    bool isSoCValid() const { return _lastUpdateSoC > 0; }
+    bool isVoltageValid() const { return _lastUpdateVoltage > 0; }
+    bool isCurrentValid() const { return _lastUpdateCurrent > 0; }
+    bool isDischargeCurrentLimitValid() const { return _lastUpdateDischargeCurrentLimit > 0; }
+
+    // returns true if the battery reached a critically low voltage/SoC,
+    // such that it is in need of charging to prevent degredation.
+    virtual bool getImmediateChargingRequest() const { return false; };
+
+    virtual float getChargeCurrentLimitation() const { return FLT_MAX; };
+
+    virtual bool supportsAlarmsAndWarnings() const { return true; };
+
+protected:
+    virtual void mqttPublish() const;
+
+    void setSoC(float soc, uint8_t precision, uint32_t timestamp) {
+        _soc = soc;
+        _socPrecision = precision;
+        _lastUpdateSoC = _lastUpdate = timestamp;
+    }
+
+    void setVoltage(float voltage, uint32_t timestamp) {
+        _voltage = voltage;
+        _lastUpdateVoltage = _lastUpdate = timestamp;
+    }
+
+    void setCurrent(float current, uint8_t precision, uint32_t timestamp) {
+        _current = current;
+        _currentPrecision = precision;
+        _lastUpdateCurrent = _lastUpdate = timestamp;
+    }
+
+    void setDischargeCurrentLimit(float dischargeCurrentLimit, uint32_t timestamp) {
+        _dischargeCurrentLimit = dischargeCurrentLimit;
+        _lastUpdateDischargeCurrentLimit = _lastUpdate = timestamp;
+    }
+
+    void setManufacturer(const String& m);
+
+    template<typename T>
+    static void addLiveViewInSection(JsonVariant& root,
+        std::string const& section, std::string const& name,
+        T&& value, std::string const& unit, uint8_t precision)
+    {
+        auto jsonValue = root["values"][section][name];
+        jsonValue["v"] = value;
+        jsonValue["u"] = unit;
+        jsonValue["d"] = precision;
+    }
+
+    template<typename T>
+    static void addLiveViewValue(JsonVariant& root, std::string const& name,
+        T&& value, std::string const& unit, uint8_t precision)
+    {
+        addLiveViewInSection(root, "status", name, value, unit, precision);
+    }
+
+    static void addLiveViewTextInSection(JsonVariant& root,
+        std::string const& section, std::string const& name,
+        std::string const& text, bool translate = true)
+    {
+        auto jsonValue = root["values"][section][name];
+        jsonValue["value"] = text;
+        jsonValue["translate"] = translate;
+    }
+
+    static void addLiveViewTextValue(JsonVariant& root, std::string const& name,
+        std::string const& text)
+    {
+        addLiveViewTextInSection(root, "status", name, text);
+    }
+
+    static void addLiveViewWarning(JsonVariant& root, std::string const& name,
+        bool warning)
+    {
+        if (!warning) { return; }
+        root["issues"][name] = 1;
+    }
+
+    static void addLiveViewAlarm(JsonVariant& root, std::string const& name,
+        bool alarm)
+    {
+        if (!alarm) { return; }
+        root["issues"][name] = 2;
+    }
+
+    String _hwversion = "";
+    String _fwversion = "";
+    String _serial = "";
+    uint32_t _lastUpdate = 0;
+
+private:
+    String _manufacturer = "unknown";
+    uint32_t _lastMqttPublish = 0;
+    float _soc = 0;
+    uint8_t _socPrecision = 0; // decimal places
+    uint32_t _lastUpdateSoC = 0;
+    float _voltage = 0; // total battery pack voltage
+    uint32_t _lastUpdateVoltage = 0;
+
+    // total current into (positive) or from (negative)
+    // the battery, i.e., the charging current
+    float _current = 0;
+    uint8_t _currentPrecision = 0; // decimal places
+    uint32_t _lastUpdateCurrent = 0;
+
+    float _dischargeCurrentLimit = 0;
+    uint32_t _lastUpdateDischargeCurrentLimit = 0;
+};
+
+} // namespace BatteryNs
diff --git a/include/JbdBmsDataPoints.h b/include/battery/jbdbms/DataPoints.h
similarity index 91%
rename from include/JbdBmsDataPoints.h
rename to include/battery/jbdbms/DataPoints.h
index 009558af2..f7b620ffc 100644
--- a/include/JbdBmsDataPoints.h
+++ b/include/battery/jbdbms/DataPoints.h
@@ -4,10 +4,9 @@
 #include <map>
 #include <frozen/map.h>
 #include <frozen/string.h>
+#include <DataPoints.h>
 
-#include "DataPoints.h"
-
-namespace JbdBms {
+namespace BatteryNs::JbdBms {
 
 #define JBD_PROTECTION_STATUS(fnc) \
     fnc(CellOverVoltage, (1<<0)) \
@@ -61,7 +60,7 @@ enum class DataPointLabel : uint8_t {
     ActualBatteryCapacityAmpHours
 };
 
-using tCells = tCellVoltages;
+using tCells = ::tCellVoltages;
 
 template<DataPointLabel> struct DataPointLabelTraits;
 
@@ -106,13 +105,13 @@ LABEL_TRAIT(BmsHardwareVersion,                     std::string, "");
 LABEL_TRAIT(ActualBatteryCapacityAmpHours,          uint32_t,    "Ah");
 #undef LABEL_TRAIT
 
-} /* namespace JbdBms */
+} // namespace BatteryNs::JbdBms
 
 using JbdBmsDataPoint = DataPoint<bool, uint8_t, uint16_t, uint32_t,
-              int16_t, int32_t, std::string, JbdBms::tCells>;
+              int16_t, int32_t, std::string, BatteryNs::JbdBms::tCells>;
 
-template class DataPointContainer<JbdBmsDataPoint, JbdBms::DataPointLabel, JbdBms::DataPointLabelTraits>;
+template class DataPointContainer<JbdBmsDataPoint, BatteryNs::JbdBms::DataPointLabel, BatteryNs::JbdBms::DataPointLabelTraits>;
 
-namespace JbdBms {
+namespace BatteryNs::JbdBms {
     using DataPointContainer = DataPointContainer<JbdBmsDataPoint, DataPointLabel, DataPointLabelTraits>;
-} /* namespace JbdBms */
+} // namespace BatteryNs::JbdBms
diff --git a/include/battery/jbdbms/HassIntegration.h b/include/battery/jbdbms/HassIntegration.h
new file mode 100644
index 000000000..9157c5f71
--- /dev/null
+++ b/include/battery/jbdbms/HassIntegration.h
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::JbdBms {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final;
+};
+
+} // namespace BatteryNs::JbdBms
diff --git a/include/battery/jbdbms/Provider.h b/include/battery/jbdbms/Provider.h
new file mode 100644
index 000000000..8a8a4cd77
--- /dev/null
+++ b/include/battery/jbdbms/Provider.h
@@ -0,0 +1,90 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <frozen/string.h>
+
+#include <battery/Provider.h>
+#include <battery/jbdbms/Stats.h>
+#include <battery/jbdbms/DataPoints.h>
+#include <battery/jbdbms/SerialMessage.h>
+#include <battery/jbdbms/HassIntegration.h>
+
+namespace BatteryNs::JbdBms {
+
+class Provider : public ::BatteryNs::Provider {
+public:
+    Provider() = default;
+
+    bool init(bool verboseLogging) final;
+    void deinit() final;
+    void loop() final;
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
+
+private:
+    static char constexpr _serialPortOwner[] = "JBD BMS";
+
+#ifdef JBDBMS_DUMMY_SERIAL
+    std::unique_ptr<DummySerial> _upSerial;
+#else
+    std::unique_ptr<HardwareSerial> _upSerial;
+#endif
+
+    enum class Status : unsigned {
+        Initializing,
+        Timeout,
+        WaitingForPollInterval,
+        HwSerialNotAvailableForWrite,
+        BusyReading,
+        RequestSent,
+        FrameCompleted
+    };
+
+    frozen::string const& getStatusText(Status status);
+    void announceStatus(Status status);
+    void sendRequest(uint8_t pollInterval);
+    void rxData(uint8_t inbyte);
+    void reset();
+    void frameComplete();
+    void processDataPoints(DataPointContainer const& dataPoints);
+
+    enum class Interface : unsigned {
+        Invalid,
+        Uart,
+        Transceiver
+    };
+
+    Interface getInterface() const;
+
+    enum class ReadState : unsigned {
+        Idle,
+        WaitingForFrameStart,
+        FrameStartReceived, // 1 Byte: 0xDD
+        StateReceived,
+        CommandCodeReceived,
+        ReadingDataContent,
+        DataContentReceived,
+        ReadingCheckSum,
+        CheckSumReceived,
+    };
+
+    ReadState _readState;
+    void setReadState(ReadState state) {
+        _readState = state;
+    }
+
+    bool _verboseLogging = true;
+    int8_t _rxEnablePin = -1;
+    int8_t _txEnablePin = -1;
+    Status _lastStatus = Status::Initializing;
+    uint32_t _lastStatusPrinted = 0;
+    uint32_t _lastRequest = 0;
+    uint8_t _dataLength = 0;
+    JbdBms::SerialResponse::tData _buffer = {};
+    std::shared_ptr<Stats> _stats =
+        std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
+};
+
+} // namespace BatteryNs::JbdBms
diff --git a/include/JbdBmsSerialMessage.h b/include/battery/jbdbms/SerialMessage.h
similarity index 95%
rename from include/JbdBmsSerialMessage.h
rename to include/battery/jbdbms/SerialMessage.h
index 6376ca317..f7b36483a 100644
--- a/include/JbdBmsSerialMessage.h
+++ b/include/battery/jbdbms/SerialMessage.h
@@ -4,9 +4,9 @@
 #include <vector>
 #include <Arduino.h>
 
-#include "JbdBmsDataPoints.h"
+#include <battery/jbdbms/DataPoints.h>
 
-namespace JbdBms {
+namespace BatteryNs::JbdBms {
 
 // Only valid for receiving messages
 class SerialMessage {
@@ -52,7 +52,7 @@ class SerialMessage {
         void updateChecksum();
 
         tData _raw;
-        JbdBms::DataPointContainer _dp;
+        DataPointContainer _dp;
 };
 
 class SerialResponse : public SerialMessage {
@@ -92,5 +92,4 @@ class SerialCommand : public SerialMessage {
         static Command _lastCmd;
 };
 
-
-} /* namespace JbdBms */
+} // namespace BatteryNs::JbdBms
diff --git a/include/battery/jbdbms/Stats.h b/include/battery/jbdbms/Stats.h
new file mode 100644
index 000000000..fd9c21720
--- /dev/null
+++ b/include/battery/jbdbms/Stats.h
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/Stats.h>
+#include <battery/jbdbms/DataPoints.h>
+
+namespace BatteryNs::JbdBms {
+
+class Stats : public ::BatteryNs::Stats {
+public:
+    void getLiveViewData(JsonVariant& root) const final {
+        getJsonData(root, false);
+    }
+
+    void getInfoViewData(JsonVariant& root) const {
+        getJsonData(root, true);
+    }
+
+    void mqttPublish() const final;
+
+    uint32_t getMqttFullPublishIntervalMs() const final { return 60 * 1000; }
+
+    void updateFrom(DataPointContainer const& dp);
+
+private:
+    void getJsonData(JsonVariant& root, bool verbose) const;
+
+    DataPointContainer _dataPoints;
+    mutable uint32_t _lastMqttPublish = 0;
+    mutable uint32_t _lastFullMqttPublish = 0;
+
+    uint16_t _cellMinMilliVolt = 0;
+    uint16_t _cellAvgMilliVolt = 0;
+    uint16_t _cellMaxMilliVolt = 0;
+    uint32_t _cellVoltageTimestamp = 0;
+};
+
+} // namespace BatteryNs::JbdBms
diff --git a/include/JkBmsDataPoints.h b/include/battery/jkbms/DataPoints.h
similarity index 96%
rename from include/JkBmsDataPoints.h
rename to include/battery/jkbms/DataPoints.h
index cd9923b5d..444aae92b 100644
--- a/include/JkBmsDataPoints.h
+++ b/include/battery/jkbms/DataPoints.h
@@ -4,10 +4,9 @@
 #include <map>
 #include <frozen/map.h>
 #include <frozen/string.h>
+#include <DataPoints.h>
 
-#include "DataPoints.h"
-
-namespace JkBms {
+namespace BatteryNs::JkBms {
 
 #define ALARM_BITS(fnc) \
     fnc(LowCapacity, (1<<0)) \
@@ -204,13 +203,13 @@ LABEL_TRAIT(ProductId,                              std::string, "");
 LABEL_TRAIT(ProtocolVersion,                        uint8_t,     "");
 #undef LABEL_TRAIT
 
-} /* namespace JkBms */
+} // namespace BatteryNs::JkBms
 
 using JkBmsDataPoint = DataPoint<bool, uint8_t, uint16_t, uint32_t,
-              int16_t, int32_t, std::string, JkBms::tCells>;
+              int16_t, int32_t, std::string, BatteryNs::JkBms::tCells>;
 
-template class DataPointContainer<JkBmsDataPoint, JkBms::DataPointLabel, JkBms::DataPointLabelTraits>;
+template class DataPointContainer<JkBmsDataPoint, BatteryNs::JkBms::DataPointLabel, BatteryNs::JkBms::DataPointLabelTraits>;
 
-namespace JkBms {
+namespace BatteryNs::JkBms {
     using DataPointContainer = DataPointContainer<JkBmsDataPoint, DataPointLabel, DataPointLabelTraits>;
-} /* namespace JkBms */
+} // namespace BatteryNs::JkBms
diff --git a/include/JkBmsDummy.h b/include/battery/jkbms/Dummy.h
similarity index 99%
rename from include/JkBmsDummy.h
rename to include/battery/jkbms/Dummy.h
index 1524023ae..b3c2cd592 100644
--- a/include/JkBmsDummy.h
+++ b/include/battery/jkbms/Dummy.h
@@ -2,9 +2,9 @@
 
 #include <Arduino.h>
 #include <vector>
-#include "MessageOutput.h"
+#include <MessageOutput.h>
 
-namespace JkBms {
+namespace BatteryNs::JkBms {
 
 class DummySerial {
     public:
@@ -193,4 +193,4 @@ class DummySerial {
         size_t _byte_idx = 0;
 };
 
-} /* namespace JkBms */
+} // namespace BatteryNs::JkBms
diff --git a/include/battery/jkbms/HassIntegration.h b/include/battery/jkbms/HassIntegration.h
new file mode 100644
index 000000000..fdea4bc5c
--- /dev/null
+++ b/include/battery/jkbms/HassIntegration.h
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::JkBms {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final;
+};
+
+} // namespace BatteryNs::JkBms
diff --git a/include/battery/jkbms/Provider.h b/include/battery/jkbms/Provider.h
new file mode 100644
index 000000000..762f9f9aa
--- /dev/null
+++ b/include/battery/jkbms/Provider.h
@@ -0,0 +1,90 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <frozen/string.h>
+
+#include <battery/Provider.h>
+#include <battery/jkbms/Stats.h>
+#include <battery/jkbms/DataPoints.h>
+#include <battery/jkbms/SerialMessage.h>
+#include <battery/jkbms/Dummy.h>
+#include <battery/jkbms/HassIntegration.h>
+
+//#define JKBMS_DUMMY_SERIAL
+
+namespace BatteryNs::JkBms {
+
+class Provider : public ::BatteryNs::Provider {
+public:
+    Provider() = default;
+
+    bool init(bool verboseLogging) final;
+    void deinit() final;
+    void loop() final;
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
+
+private:
+    static char constexpr _serialPortOwner[] = "JK BMS";
+
+#ifdef JKBMS_DUMMY_SERIAL
+    std::unique_ptr<DummySerial> _upSerial;
+#else
+    std::unique_ptr<HardwareSerial> _upSerial;
+#endif
+
+    enum class Status : unsigned {
+        Initializing,
+        Timeout,
+        WaitingForPollInterval,
+        HwSerialNotAvailableForWrite,
+        BusyReading,
+        RequestSent,
+        FrameCompleted
+    };
+
+    frozen::string const& getStatusText(Status status);
+    void announceStatus(Status status);
+    void sendRequest(uint8_t pollInterval);
+    void rxData(uint8_t inbyte);
+    void reset();
+    void frameComplete();
+    void processDataPoints(DataPointContainer const& dataPoints);
+
+    enum class Interface : unsigned {
+        Invalid,
+        Uart,
+        Transceiver
+    };
+
+    Interface getInterface() const;
+
+    enum class ReadState : unsigned {
+        Idle,
+        WaitingForFrameStart,
+        FrameStartReceived,
+        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<Stats> _stats =
+        std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
+};
+
+} // namespace BatteryNs::JkBms
diff --git a/include/JkBmsSerialMessage.h b/include/battery/jkbms/SerialMessage.h
similarity index 95%
rename from include/JkBmsSerialMessage.h
rename to include/battery/jkbms/SerialMessage.h
index 6f869d70a..e36216eb6 100644
--- a/include/JkBmsSerialMessage.h
+++ b/include/battery/jkbms/SerialMessage.h
@@ -4,9 +4,9 @@
 #include <vector>
 #include <Arduino.h>
 
-#include "JkBmsDataPoints.h"
+#include <battery/jkbms/DataPoints.h>
 
-namespace JkBms {
+namespace BatteryNs::JkBms {
 
 class SerialMessage {
     public:
@@ -70,7 +70,7 @@ class SerialMessage {
         void updateChecksum();
 
         tData _raw;
-        JkBms::DataPointContainer _dp;
+        DataPointContainer _dp;
 
         static constexpr uint16_t startMarker = 0x4e57;
         static constexpr uint8_t endMarker = 0x68;
@@ -90,4 +90,4 @@ class SerialCommand : public SerialMessage {
         explicit SerialCommand(Command cmd);
 };
 
-} /* namespace JkBms */
+} // namespace BatteryNs::JkBms
diff --git a/include/battery/jkbms/Stats.h b/include/battery/jkbms/Stats.h
new file mode 100644
index 000000000..9c640b769
--- /dev/null
+++ b/include/battery/jkbms/Stats.h
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/Stats.h>
+#include <battery/jkbms/DataPoints.h>
+
+namespace BatteryNs::JkBms {
+
+class Stats : public ::BatteryNs::Stats {
+public:
+    void getLiveViewData(JsonVariant& root) const final {
+        getJsonData(root, false);
+    }
+
+    void getInfoViewData(JsonVariant& root) const {
+        getJsonData(root, true);
+    }
+
+    void mqttPublish() const final;
+
+    uint32_t getMqttFullPublishIntervalMs() const final { return 60 * 1000; }
+
+    void updateFrom(DataPointContainer const& dp);
+
+private:
+    void getJsonData(JsonVariant& root, bool verbose) const;
+
+    DataPointContainer _dataPoints;
+    mutable uint32_t _lastMqttPublish = 0;
+    mutable uint32_t _lastFullMqttPublish = 0;
+
+    uint16_t _cellMinMilliVolt = 0;
+    uint16_t _cellAvgMilliVolt = 0;
+    uint16_t _cellMaxMilliVolt = 0;
+    uint32_t _cellVoltageTimestamp = 0;
+};
+
+} // namespace BatteryNs::JkBms
diff --git a/include/battery/mqtt/HassIntegration.h b/include/battery/mqtt/HassIntegration.h
new file mode 100644
index 000000000..dce0b1785
--- /dev/null
+++ b/include/battery/mqtt/HassIntegration.h
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::Mqtt {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final
+    {
+        ::BatteryNs::HassIntegration::publishSensors();
+    }
+};
+
+} // namespace BatteryNs::Mqtt
diff --git a/include/MqttBattery.h b/include/battery/mqtt/Provider.h
similarity index 65%
rename from include/MqttBattery.h
rename to include/battery/mqtt/Provider.h
index 04d4a6ab4..4779f7f44 100644
--- a/include/MqttBattery.h
+++ b/include/battery/mqtt/Provider.h
@@ -1,24 +1,30 @@
 #pragma once
 
-#include <optional>
-#include "Battery.h"
+#include <memory>
 #include <espMqttClient.h>
+#include <battery/Provider.h>
+#include <battery/mqtt/Stats.h>
+#include <battery/mqtt/HassIntegration.h>
 
-class MqttBattery : public BatteryProvider {
+namespace BatteryNs::Mqtt {
+
+class Provider : public ::BatteryNs::Provider {
 public:
-    MqttBattery() = default;
+    Provider() = default;
 
     bool init(bool verboseLogging) final;
     void deinit() final;
     void loop() final { return; } // this class is event-driven
-    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
 
 private:
     bool _verboseLogging = false;
     String _socTopic;
     String _voltageTopic;
     String _dischargeCurrentLimitTopic;
-    std::shared_ptr<MqttBatteryStats> _stats = std::make_shared<MqttBatteryStats>();
+    std::shared_ptr<Stats> _stats = std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
     uint8_t _socPrecision = 0;
 
     void onMqttMessageSoC(espMqttClientTypes::MessageProperties const& properties,
@@ -31,3 +37,5 @@ class MqttBattery : public BatteryProvider {
             char const* topic, uint8_t const* payload, size_t len, size_t index, size_t total,
             char const* jsonPath);
 };
+
+} // namespace BatteryNs::Mqtt
diff --git a/include/battery/mqtt/Stats.h b/include/battery/mqtt/Stats.h
new file mode 100644
index 000000000..55275b5aa
--- /dev/null
+++ b/include/battery/mqtt/Stats.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/Stats.h>
+
+namespace BatteryNs::Mqtt {
+
+class Stats : public ::BatteryNs::Stats {
+friend class Provider;
+
+public:
+    // since the source of information was MQTT in the first place,
+    // we do NOT publish the same data under a different topic.
+    void mqttPublish() const final { }
+
+    void getLiveViewData(JsonVariant& root) const final;
+
+    bool supportsAlarmsAndWarnings() const final { return false; }
+};
+
+} // namespace BatteryNs::Mqtt
diff --git a/include/battery/pylontech/HassIntegration.h b/include/battery/pylontech/HassIntegration.h
new file mode 100644
index 000000000..000ebbeb3
--- /dev/null
+++ b/include/battery/pylontech/HassIntegration.h
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::Pylontech {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final;
+};
+
+} // namespace BatteryNs::Pylontech
diff --git a/include/battery/pylontech/Provider.h b/include/battery/pylontech/Provider.h
new file mode 100644
index 000000000..32844f1e3
--- /dev/null
+++ b/include/battery/pylontech/Provider.h
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <memory>
+#include <driver/twai.h>
+#include <battery/CanReceiver.h>
+#include <battery/pylontech/Stats.h>
+#include <battery/pylontech/HassIntegration.h>
+
+namespace BatteryNs::Pylontech {
+
+class Provider : public ::BatteryNs::CanReceiver {
+public:
+    bool init(bool verboseLogging) final;
+    void onMessage(twai_message_t rx_message) final;
+
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
+
+private:
+    void dummyData();
+
+    std::shared_ptr<Stats> _stats =
+        std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
+};
+
+} // namespace BatteryNs::Pylontech
diff --git a/include/battery/pylontech/Stats.h b/include/battery/pylontech/Stats.h
new file mode 100644
index 000000000..f3015babe
--- /dev/null
+++ b/include/battery/pylontech/Stats.h
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/Stats.h>
+
+namespace BatteryNs::Pylontech {
+
+class Stats : public ::BatteryNs::Stats {
+friend class Provider;
+
+public:
+    void getLiveViewData(JsonVariant& root) const final;
+    void mqttPublish() const final;
+    bool getImmediateChargingRequest() const { return _chargeImmediately; } ;
+    float getChargeCurrentLimitation() const { return _chargeCurrentLimitation; } ;
+
+private:
+    void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
+
+    float _chargeVoltage;
+    float _chargeCurrentLimitation;
+    float _dischargeVoltageLimitation;
+    uint16_t _stateOfHealth;
+    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;
+
+    uint8_t _moduleCount;
+};
+
+} // namespace BatteryNs::Pylontech
diff --git a/include/battery/pytes/HassIntegration.h b/include/battery/pytes/HassIntegration.h
new file mode 100644
index 000000000..81e7cef08
--- /dev/null
+++ b/include/battery/pytes/HassIntegration.h
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::Pytes {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final;
+};
+
+} // namespace BatteryNs::Pytes
diff --git a/include/battery/pytes/Provider.h b/include/battery/pytes/Provider.h
new file mode 100644
index 000000000..59042bf35
--- /dev/null
+++ b/include/battery/pytes/Provider.h
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <memory>
+#include <driver/twai.h>
+#include <battery/CanReceiver.h>
+#include <battery/pytes/Stats.h>
+#include <battery/pytes/HassIntegration.h>
+
+namespace BatteryNs::Pytes {
+
+class Provider : public ::BatteryNs::CanReceiver {
+public:
+    bool init(bool verboseLogging) final;
+    void onMessage(twai_message_t rx_message) final;
+
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
+
+private:
+    std::shared_ptr<Stats> _stats =
+        std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
+};
+
+} // namespace BatteryNs::Pytes
diff --git a/include/battery/pytes/Stats.h b/include/battery/pytes/Stats.h
new file mode 100644
index 000000000..8bae900ea
--- /dev/null
+++ b/include/battery/pytes/Stats.h
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/Stats.h>
+
+namespace BatteryNs::Pytes {
+
+class Stats : public ::BatteryNs::Stats {
+friend class Provider;
+
+public:
+    void getLiveViewData(JsonVariant& root) const final;
+    void mqttPublish() const final;
+    bool getImmediateChargingRequest() const { return _chargeImmediately; };
+    float getChargeCurrentLimitation() const { return _chargeCurrentLimit; };
+
+private:
+    void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
+    void updateSerial() {
+        if (!_serialPart1.isEmpty() && !_serialPart2.isEmpty()) {
+            _serial = _serialPart1 + _serialPart2;
+        }
+    }
+
+    String _serialPart1 = "";
+    String _serialPart2 = "";
+
+    float _chargeVoltageLimit;
+    float _chargeCurrentLimit;
+    float _dischargeVoltageLimit;
+
+    uint16_t _stateOfHealth;
+    int _chargeCycles = -1;
+    int _balance = -1;
+
+    float _temperature;
+
+    uint16_t _cellMinMilliVolt;
+    uint16_t _cellMaxMilliVolt;
+    float _cellMinTemperature;
+    float _cellMaxTemperature;
+
+    String _cellMinVoltageName;
+    String _cellMaxVoltageName;
+    String _cellMinTemperatureName;
+    String _cellMaxTemperatureName;
+
+    uint8_t _moduleCountOnline;
+    uint8_t _moduleCountOffline;
+
+    uint8_t _moduleCountBlockingCharge;
+    uint8_t _moduleCountBlockingDischarge;
+
+    float _totalCapacity;
+    float _availableCapacity;
+    uint8_t _capacityPrecision = 0; // decimal places
+
+    float _chargedEnergy = -1;
+    float _dischargedEnergy = -1;
+
+    bool _alarmUnderVoltage;
+    bool _alarmOverVoltage;
+    bool _alarmOverCurrentCharge;
+    bool _alarmOverCurrentDischarge;
+    bool _alarmUnderTemperature;
+    bool _alarmOverTemperature;
+    bool _alarmUnderTemperatureCharge;
+    bool _alarmOverTemperatureCharge;
+    bool _alarmInternalFailure;
+    bool _alarmCellImbalance;
+
+    bool _warningLowVoltage;
+    bool _warningHighVoltage;
+    bool _warningHighChargeCurrent;
+    bool _warningHighDischargeCurrent;
+    bool _warningLowTemperature;
+    bool _warningHighTemperature;
+    bool _warningLowTemperatureCharge;
+    bool _warningHighTemperatureCharge;
+    bool _warningInternalFailure;
+    bool _warningCellImbalance;
+
+    bool _chargeImmediately;
+};
+
+} // namespace BatteryNs::Pytes
diff --git a/include/battery/sbs/HassIntegration.h b/include/battery/sbs/HassIntegration.h
new file mode 100644
index 000000000..6afafd8f8
--- /dev/null
+++ b/include/battery/sbs/HassIntegration.h
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::SBS {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final;
+};
+
+} // namespace BatteryNs::SBS
diff --git a/include/battery/sbs/Provider.h b/include/battery/sbs/Provider.h
new file mode 100644
index 000000000..7839ee69c
--- /dev/null
+++ b/include/battery/sbs/Provider.h
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <memory>
+#include <driver/twai.h>
+#include <battery/CanReceiver.h>
+#include <battery/sbs/Stats.h>
+#include <battery/sbs/HassIntegration.h>
+
+namespace BatteryNs::SBS {
+
+class Provider : public ::BatteryNs::CanReceiver {
+public:
+    bool init(bool verboseLogging) final;
+    void onMessage(twai_message_t rx_message) final;
+
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
+
+private:
+    void dummyData();
+    std::shared_ptr<Stats> _stats =
+        std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
+};
+
+} // namespace BatteryNs::SBS
diff --git a/include/battery/sbs/Stats.h b/include/battery/sbs/Stats.h
new file mode 100644
index 000000000..c82fe6912
--- /dev/null
+++ b/include/battery/sbs/Stats.h
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/Stats.h>
+
+namespace BatteryNs::SBS {
+
+class Stats : public ::BatteryNs::Stats {
+friend class Provider;
+
+public:
+    void getLiveViewData(JsonVariant& root) const final;
+    void mqttPublish() const final;
+    float getChargeCurrent() const { return _current; } ;
+    float getChargeCurrentLimitation() const { return _chargeCurrentLimitation; } ;
+
+private:
+    void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
+
+    float _chargeVoltage;
+    float _chargeCurrentLimitation;
+    uint16_t _stateOfHealth;
+    float _current;
+    float _temperature;
+
+    bool _alarmUnderTemperature;
+    bool _alarmOverTemperature;
+    bool _alarmUnderVoltage;
+    bool _alarmOverVoltage;
+    bool _alarmBmsInternal;
+
+    bool _warningHighCurrentDischarge;
+    bool _warningHighCurrentCharge;
+
+    bool _chargeEnabled;
+    bool _dischargeEnabled;
+};
+
+} // namespace BatteryNs::SBS
diff --git a/include/battery/victronsmartshunt/HassIntegration.h b/include/battery/victronsmartshunt/HassIntegration.h
new file mode 100644
index 000000000..41aa11411
--- /dev/null
+++ b/include/battery/victronsmartshunt/HassIntegration.h
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <battery/HassIntegration.h>
+
+namespace BatteryNs::VictronSmartShunt {
+
+class HassIntegration : public ::BatteryNs::HassIntegration {
+public:
+    void publishSensors() const final;
+};
+
+} // namespace BatteryNs::VictronSmartShunt
diff --git a/include/battery/victronsmartshunt/Provider.h b/include/battery/victronsmartshunt/Provider.h
new file mode 100644
index 000000000..5c70c9348
--- /dev/null
+++ b/include/battery/victronsmartshunt/Provider.h
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <memory>
+#include <battery/Provider.h>
+#include <battery/victronsmartshunt/Stats.h>
+#include <battery/victronsmartshunt/HassIntegration.h>
+
+namespace BatteryNs::VictronSmartShunt {
+
+class Provider : public ::BatteryNs::Provider {
+public:
+    bool init(bool verboseLogging) final;
+    void deinit() final;
+    void loop() final;
+    std::shared_ptr<::BatteryNs::Stats> getStats() const final { return _stats; }
+    ::BatteryNs::HassIntegration const& getHassIntegration() const final { return _hassIntegration; }
+
+private:
+    static char constexpr _serialPortOwner[] = "SmartShunt";
+
+    uint32_t _lastUpdate = 0;
+    std::shared_ptr<Stats> _stats =
+        std::make_shared<Stats>();
+    HassIntegration _hassIntegration;
+};
+
+} // namespace BatteryNs::VictronSmartShunt
diff --git a/include/battery/victronsmartshunt/Stats.h b/include/battery/victronsmartshunt/Stats.h
new file mode 100644
index 000000000..8b14dee13
--- /dev/null
+++ b/include/battery/victronsmartshunt/Stats.h
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+#include <VeDirectShuntController.h>
+#include <battery/Stats.h>
+
+namespace BatteryNs::VictronSmartShunt {
+
+class Stats : public ::BatteryNs::Stats {
+public:
+    void getLiveViewData(JsonVariant& root) const final;
+    void mqttPublish() const final;
+
+    void updateFrom(VeDirectShuntController::data_t const& shuntData);
+
+private:
+    float _temperature;
+    bool _tempPresent;
+    uint8_t _chargeCycles;
+    uint32_t _timeToGo;
+    float _chargedEnergy;
+    float _dischargedEnergy;
+    int32_t _instantaneousPower;
+    float _midpointVoltage;
+    float _midpointDeviation;
+    float _consumedAmpHours;
+    int32_t _lastFullCharge;
+
+    bool _alarmLowVoltage;
+    bool _alarmHighVoltage;
+    bool _alarmLowSOC;
+    bool _alarmLowTemperature;
+    bool _alarmHighTemperature;
+};
+
+} // namespace BatteryNs::VictronSmartShunt
diff --git a/src/BatteryStats.cpp b/src/BatteryStats.cpp
deleted file mode 100644
index f4e383b29..000000000
--- a/src/BatteryStats.cpp
+++ /dev/null
@@ -1,903 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#include <vector>
-#include <algorithm>
-#include "BatteryStats.h"
-#include "Configuration.h"
-#include "MqttSettings.h"
-#include "JkBmsDataPoints.h"
-#include "JbdBmsDataPoints.h"
-#include "MqttSettings.h"
-
-template<typename T>
-static void addLiveViewInSection(JsonVariant& root,
-    std::string const& section, std::string const& name,
-    T&& value, std::string const& unit, uint8_t precision)
-{
-    auto jsonValue = root["values"][section][name];
-    jsonValue["v"] = value;
-    jsonValue["u"] = unit;
-    jsonValue["d"] = precision;
-}
-
-template<typename T>
-static void addLiveViewValue(JsonVariant& root, std::string const& name,
-    T&& value, std::string const& unit, uint8_t precision)
-{
-    addLiveViewInSection(root, "status", name, value, unit, precision);
-}
-
-static void addLiveViewTextInSection(JsonVariant& root,
-    std::string const& section, std::string const& name,
-    std::string const& text, bool translate = true)
-{
-    auto jsonValue = root["values"][section][name];
-    jsonValue["value"] = text;
-    jsonValue["translate"] = translate;
-}
-
-static void addLiveViewTextValue(JsonVariant& root, std::string const& name,
-    std::string const& text)
-{
-    addLiveViewTextInSection(root, "status", name, text);
-}
-
-static void addLiveViewWarning(JsonVariant& root, std::string const& name,
-    bool warning)
-{
-    if (!warning) { return; }
-    root["issues"][name] = 1;
-}
-
-static void addLiveViewAlarm(JsonVariant& root, std::string const& name,
-    bool alarm)
-{
-    if (!alarm) { return; }
-    root["issues"][name] = 2;
-}
-
-void BatteryStats::setManufacturer(const String& m)
-{
-    String sanitized(m);
-    for (int i = 0; i < sanitized.length(); i++) {
-        char c = sanitized[i];
-        if (c < 0x20 || c >= 0x80) {
-            sanitized.remove(i); // Truncate string
-            break;
-        }
-    }
-    _manufacturer = std::move(sanitized);
-}
-
-bool BatteryStats::updateAvailable(uint32_t since) const
-{
-    if (_lastUpdate == 0) { return false; } // no data at all processed yet
-
-    auto constexpr halfOfAllMillis = std::numeric_limits<uint32_t>::max() / 2;
-    return (_lastUpdate - since) < halfOfAllMillis;
-}
-
-void BatteryStats::getLiveViewData(JsonVariant& root) const
-{
-    root["manufacturer"] = _manufacturer;
-    if (!_serial.isEmpty()) {
-        root["serial"] = _serial;
-    }
-    if (!_fwversion.isEmpty()) {
-        root["fwversion"] = _fwversion;
-    }
-    if (!_hwversion.isEmpty()) {
-        root["hwversion"] = _hwversion;
-    }
-    root["data_age"] = getAgeSeconds();
-
-    if (isSoCValid()) {
-        addLiveViewValue(root, "SoC", _soc, "%", _socPrecision);
-    }
-
-    if (isVoltageValid()) {
-        addLiveViewValue(root, "voltage", _voltage, "V", 2);
-    }
-
-    if (isCurrentValid()) {
-        addLiveViewValue(root, "current", _current, "A", _currentPrecision);
-    }
-
-    if (isDischargeCurrentLimitValid()) {
-        addLiveViewValue(root, "dischargeCurrentLimitation", _dischargeCurrentLimit, "A", 1);
-    }
-
-    root["showIssues"] = supportsAlarmsAndWarnings();
-}
-
-void MqttBatteryStats::getLiveViewData(JsonVariant& root) const
-{
-    // as we don't want to repeat the data that is already shown in the live data card
-    // we only add the live view data here when the discharge current limit can be shown
-    if (isDischargeCurrentLimitValid()) {
-        BatteryStats::getLiveViewData(root);
-    }
-}
-
-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, "dischargeVoltageLimitation", _dischargeVoltageLimitation, "V", 1);
-    addLiveViewValue(root, "stateOfHealth", _stateOfHealth, "%", 0);
-    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
-    addLiveViewValue(root, "modules", _moduleCount, "", 0);
-
-    addLiveViewTextValue(root, "chargeEnabled", (_chargeEnabled?"yes":"no"));
-    addLiveViewTextValue(root, "dischargeEnabled", (_dischargeEnabled?"yes":"no"));
-    addLiveViewTextValue(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 SBSBatteryStats::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, "stateOfHealth", _stateOfHealth, "%", 0);
-    addLiveViewValue(root, "current", _current, "A", 1);
-    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
-    addLiveViewTextValue(root, "chargeEnabled", (_chargeEnabled?"yes":"no"));
-    addLiveViewTextValue(root, "dischargeEnabled", (_dischargeEnabled?"yes":"no"));
-
-    // alarms and warnings go into the "Issues" card of the web application
-    addLiveViewWarning(root, "highCurrentDischarge", _warningHighCurrentDischarge);
-    addLiveViewWarning(root, "highCurrentCharge", _warningHighCurrentCharge);
-    addLiveViewAlarm(root, "underVoltage", _alarmUnderVoltage);
-    addLiveViewAlarm(root, "overVoltage", _alarmOverVoltage);
-    addLiveViewAlarm(root, "bmsInternal", _alarmBmsInternal);
-    addLiveViewAlarm(root, "underTemperature", _alarmUnderTemperature);
-    addLiveViewAlarm(root, "overTemperature", _alarmOverTemperature);
-}
-
-void PytesBatteryStats::getLiveViewData(JsonVariant& root) const
-{
-    BatteryStats::getLiveViewData(root);
-
-    // values go into the "Status" card of the web application
-    addLiveViewValue(root, "chargeVoltage", _chargeVoltageLimit, "V", 1);
-    addLiveViewValue(root, "chargeCurrentLimitation", _chargeCurrentLimit, "A", 1);
-    addLiveViewValue(root, "dischargeVoltageLimitation", _dischargeVoltageLimit, "V", 1);
-    addLiveViewValue(root, "stateOfHealth", _stateOfHealth, "%", 0);
-    if (_chargeCycles != -1) {
-        addLiveViewValue(root, "chargeCycles", _chargeCycles, "", 0);
-    }
-    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
-
-    addLiveViewValue(root, "capacity", _totalCapacity, "Ah", _capacityPrecision);
-    addLiveViewValue(root, "availableCapacity", _availableCapacity, "Ah", _capacityPrecision);
-
-    if (_chargedEnergy != -1) {
-        addLiveViewValue(root, "chargedEnergy", _chargedEnergy, "kWh", 1);
-    }
-
-    if (_dischargedEnergy != -1) {
-        addLiveViewValue(root, "dischargedEnergy", _dischargedEnergy, "kWh", 1);
-    }
-    addLiveViewTextValue(root, "chargeImmediately", (_chargeImmediately?"yes":"no"));
-
-    if (_balance != -1) {
-        addLiveViewTextValue(root, "balancingActive", (_balance?"yes":"no"));
-    }
-
-    addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
-    addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
-    addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
-    addLiveViewInSection(root, "cells", "cellMinTemperature", _cellMinTemperature, "°C", 0);
-    addLiveViewInSection(root, "cells", "cellMaxTemperature", _cellMaxTemperature, "°C", 0);
-
-    addLiveViewTextInSection(root, "cells", "cellMinVoltageName", _cellMinVoltageName.c_str(), false);
-    addLiveViewTextInSection(root, "cells", "cellMaxVoltageName", _cellMaxVoltageName.c_str(), false);
-    addLiveViewTextInSection(root, "cells", "cellMinTemperatureName", _cellMinTemperatureName.c_str(), false);
-    addLiveViewTextInSection(root, "cells", "cellMaxTemperatureName", _cellMaxTemperatureName.c_str(), false);
-
-    addLiveViewInSection(root, "modules", "online", _moduleCountOnline, "", 0);
-    addLiveViewInSection(root, "modules", "offline", _moduleCountOffline, "", 0);
-    addLiveViewInSection(root, "modules", "blockingCharge", _moduleCountBlockingCharge, "", 0);
-    addLiveViewInSection(root, "modules", "blockingDischarge", _moduleCountBlockingDischarge, "", 0);
-
-    // alarms and warnings go into the "Issues" card of the web application
-    addLiveViewWarning(root, "highCurrentDischarge", _warningHighDischargeCurrent);
-    addLiveViewAlarm(root, "overCurrentDischarge", _alarmOverCurrentDischarge);
-
-    addLiveViewWarning(root, "highCurrentCharge", _warningHighChargeCurrent);
-    addLiveViewAlarm(root, "overCurrentCharge", _alarmOverCurrentCharge);
-
-    addLiveViewWarning(root, "lowVoltage", _warningLowVoltage);
-    addLiveViewAlarm(root, "underVoltage", _alarmUnderVoltage);
-
-    addLiveViewWarning(root, "highVoltage", _warningHighVoltage);
-    addLiveViewAlarm(root, "overVoltage", _alarmOverVoltage);
-
-    addLiveViewWarning(root, "lowTemperature", _warningLowTemperature);
-    addLiveViewAlarm(root, "underTemperature", _alarmUnderTemperature);
-
-    addLiveViewWarning(root, "highTemperature", _warningHighTemperature);
-    addLiveViewAlarm(root, "overTemperature", _alarmOverTemperature);
-
-    addLiveViewWarning(root, "lowTemperatureCharge", _warningLowTemperatureCharge);
-    addLiveViewAlarm(root, "underTemperatureCharge", _alarmUnderTemperatureCharge);
-
-    addLiveViewWarning(root, "highTemperatureCharge", _warningHighTemperatureCharge);
-    addLiveViewAlarm(root, "overTemperatureCharge", _alarmOverTemperatureCharge);
-
-    addLiveViewWarning(root, "bmsInternal", _warningInternalFailure);
-    addLiveViewAlarm(root, "bmsInternal", _alarmInternalFailure);
-
-    addLiveViewWarning(root, "cellDiffVoltage", _warningCellImbalance);
-    addLiveViewAlarm(root, "cellDiffVoltage", _alarmCellImbalance);
-}
-
-void JkBmsBatteryStats::getJsonData(JsonVariant& root, bool verbose) const
-{
-    BatteryStats::getLiveViewData(root);
-
-    using Label = JkBms::DataPointLabel;
-
-    auto oCurrent = _dataPoints.get<Label::BatteryCurrentMilliAmps>();
-    auto oVoltage = _dataPoints.get<Label::BatteryVoltageMilliVolt>();
-    if (oVoltage.has_value() && oCurrent.has_value()) {
-        auto current = static_cast<float>(*oCurrent) / 1000;
-        auto voltage = static_cast<float>(*oVoltage) / 1000;
-        addLiveViewValue(root, "power", current * voltage , "W", 2);
-    }
-
-    auto oTemperatureBms = _dataPoints.get<Label::BmsTempCelsius>();
-    if (oTemperatureBms.has_value()) {
-        addLiveViewValue(root, "bmsTemp", *oTemperatureBms, "°C", 0);
-    }
-
-    // labels BatteryChargeEnabled, BatteryDischargeEnabled, and
-    // BalancingEnabled refer to the user setting. we want to show the
-    // actual MOSFETs' state which control whether charging and discharging
-    // is possible and whether the BMS is currently balancing cells.
-    auto oStatus = _dataPoints.get<Label::StatusBitmask>();
-    if (oStatus.has_value()) {
-        using Bits = JkBms::StatusBits;
-        auto chargeEnabled = *oStatus & static_cast<uint16_t>(Bits::ChargingActive);
-        addLiveViewTextValue(root, "chargeEnabled", (chargeEnabled?"yes":"no"));
-        auto dischargeEnabled = *oStatus & static_cast<uint16_t>(Bits::DischargingActive);
-        addLiveViewTextValue(root, "dischargeEnabled", (dischargeEnabled?"yes":"no"));
-    }
-
-    auto oTemperatureOne = _dataPoints.get<Label::BatteryTempOneCelsius>();
-    if (oTemperatureOne.has_value()) {
-        addLiveViewInSection(root, "cells", "batOneTemp", *oTemperatureOne, "°C", 0);
-    }
-
-    auto oTemperatureTwo = _dataPoints.get<Label::BatteryTempTwoCelsius>();
-    if (oTemperatureTwo.has_value()) {
-        addLiveViewInSection(root, "cells", "batTwoTemp", *oTemperatureTwo, "°C", 0);
-    }
-
-    if (_cellVoltageTimestamp > 0) {
-        addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
-        addLiveViewInSection(root, "cells", "cellAvgVoltage", static_cast<float>(_cellAvgMilliVolt)/1000, "V", 3);
-        addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
-        addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
-    }
-
-    if (oStatus.has_value()) {
-        using Bits = JkBms::StatusBits;
-        auto balancingActive = *oStatus & static_cast<uint16_t>(Bits::BalancingActive);
-        addLiveViewTextInSection(root, "cells", "balancingActive", (balancingActive?"yes":"no"));
-    }
-
-    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
-    if (oAlarms.has_value()) {
-#define ISSUE(t, x) \
-        auto x = *oAlarms & static_cast<uint16_t>(JkBms::AlarmBits::x); \
-        addLiveView##t(root, "JkBmsIssue"#x, x > 0);
-
-        ISSUE(Warning, LowCapacity);
-        ISSUE(Alarm, BmsOvertemperature);
-        ISSUE(Alarm, ChargingOvervoltage);
-        ISSUE(Alarm, DischargeUndervoltage);
-        ISSUE(Alarm, BatteryOvertemperature);
-        ISSUE(Alarm, ChargingOvercurrent);
-        ISSUE(Alarm, DischargeOvercurrent);
-        ISSUE(Alarm, CellVoltageDifference);
-        ISSUE(Alarm, BatteryBoxOvertemperature);
-        ISSUE(Alarm, BatteryUndertemperature);
-        ISSUE(Alarm, CellOvervoltage);
-        ISSUE(Alarm, CellUndervoltage);
-        ISSUE(Alarm, AProtect);
-        ISSUE(Alarm, BProtect);
-#undef ISSUE
-    }
-}
-
-void JbdBmsBatteryStats::getJsonData(JsonVariant& root, bool verbose) const
-{
-    BatteryStats::getLiveViewData(root);
-
-    using Label = JbdBms::DataPointLabel;
-
-    auto oCurrent = _dataPoints.get<Label::BatteryCurrentMilliAmps>();
-    auto oVoltage = _dataPoints.get<Label::BatteryVoltageMilliVolt>();
-    if (oVoltage.has_value() && oCurrent.has_value()) {
-        auto current = static_cast<float>(*oCurrent) / 1000;
-        auto voltage = static_cast<float>(*oVoltage) / 1000;
-        addLiveViewValue(root, "power", current * voltage , "W", 2);
-    }
-
-    auto oBatteryChargeEnabled = _dataPoints.get<Label::BatteryChargeEnabled>();
-    if (oBatteryChargeEnabled.has_value()) {
-        addLiveViewTextValue(root, "chargeEnabled", (*oBatteryChargeEnabled?"yes":"no"));
-    }
-
-    auto oBatteryDischargeEnabled = _dataPoints.get<Label::BatteryDischargeEnabled>();
-    if (oBatteryDischargeEnabled.has_value()) {
-        addLiveViewTextValue(root, "dischargeEnabled", (*oBatteryDischargeEnabled?"yes":"no"));
-    }
-
-    auto oTemperatureOne = _dataPoints.get<Label::BatteryTempOneCelsius>();
-    if (oTemperatureOne.has_value()) {
-        addLiveViewInSection(root, "cells", "batOneTemp", *oTemperatureOne, "°C", 0);
-    }
-
-    auto oTemperatureTwo = _dataPoints.get<Label::BatteryTempTwoCelsius>();
-    if (oTemperatureTwo.has_value()) {
-        addLiveViewInSection(root, "cells", "batTwoTemp", *oTemperatureTwo, "°C", 0);
-    }
-
-    if (_cellVoltageTimestamp > 0) {
-        addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
-        addLiveViewInSection(root, "cells", "cellAvgVoltage", static_cast<float>(_cellAvgMilliVolt)/1000, "V", 3);
-        addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
-        addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
-    }
-
-    auto oBalancingEnabled = _dataPoints.get<Label::BalancingEnabled>();
-    if (oBalancingEnabled.has_value()) {
-        addLiveViewTextInSection(root, "cells", "balancingActive", (*oBalancingEnabled?"yes":"no"));
-    }
-
-    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
-    if (oAlarms.has_value()) {
-#define ISSUE(t, x) \
-        auto x = *oAlarms & static_cast<uint16_t>(JbdBms::AlarmBits::x); \
-        addLiveView##t(root, "JbdBmsIssue"#x, x > 0);
-
-        //ISSUE(Warning, LowCapacity);
-        ISSUE(Alarm, CellOverVoltage);
-        ISSUE(Alarm, CellUnderVoltage);
-        ISSUE(Alarm, PackOverVoltage);
-        ISSUE(Alarm, PackUnderVoltage);
-        ISSUE(Alarm, ChargingOverTemperature);
-        ISSUE(Alarm, ChargingLowTemperature);
-        ISSUE(Alarm, DischargingOverTemperature);
-        ISSUE(Alarm, DischargingLowTemperature);
-        ISSUE(Alarm, ChargingOverCurrent);
-        ISSUE(Alarm, DischargeOverCurrent);
-        ISSUE(Alarm, ShortCircuit);
-        ISSUE(Alarm, IcFrontEndError);
-        ISSUE(Alarm, MosSotwareLock);
-        ISSUE(Alarm, Reserved1);
-        ISSUE(Alarm, Reserved2);
-        ISSUE(Alarm, Reserved3);
-#undef ISSUE
-    }
-}
-
-void BatteryStats::mqttLoop()
-{
-    auto& config = Configuration.get();
-
-    if (!MqttSettings.getConnected()
-            || (millis() - _lastMqttPublish) < (config.Mqtt.PublishInterval * 1000)) {
-        return;
-    }
-
-    mqttPublish();
-
-    _lastMqttPublish = millis();
-}
-
-uint32_t BatteryStats::getMqttFullPublishIntervalMs() const
-{
-    auto& config = Configuration.get();
-
-    // this is the default interval, see mqttLoop(). mqttPublish()
-    // implementations in derived classes may choose to publish some values
-    // with a lower frequency and hence implement this method with a different
-    // return value.
-    return config.Mqtt.PublishInterval * 1000;
-}
-
-void BatteryStats::mqttPublish() const
-{
-    MqttSettings.publish("battery/manufacturer", _manufacturer);
-    MqttSettings.publish("battery/dataAge", String(getAgeSeconds()));
-
-    if (isSoCValid()) {
-        MqttSettings.publish("battery/stateOfCharge", String(_soc));
-    }
-
-    if (isVoltageValid()) {
-        MqttSettings.publish("battery/voltage", String(_voltage));
-    }
-
-    if (isCurrentValid()) {
-        MqttSettings.publish("battery/current", String(_current));
-    }
-
-    if (isDischargeCurrentLimitValid()) {
-        MqttSettings.publish("battery/settings/dischargeCurrentLimitation", String(_dischargeCurrentLimit));
-    }
-}
-
-void PylontechBatteryStats::mqttPublish() const
-{
-    BatteryStats::mqttPublish();
-
-    MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltage));
-    MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimitation));
-    MqttSettings.publish("battery/settings/dischargeVoltageLimitation", String(_dischargeVoltageLimitation));
-    MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
-    MqttSettings.publish("battery/temperature", String(_temperature));
-    MqttSettings.publish("battery/alarm/overCurrentDischarge", String(_alarmOverCurrentDischarge));
-    MqttSettings.publish("battery/alarm/overCurrentCharge", String(_alarmOverCurrentCharge));
-    MqttSettings.publish("battery/alarm/underTemperature", String(_alarmUnderTemperature));
-    MqttSettings.publish("battery/alarm/overTemperature", String(_alarmOverTemperature));
-    MqttSettings.publish("battery/alarm/underVoltage", String(_alarmUnderVoltage));
-    MqttSettings.publish("battery/alarm/overVoltage", String(_alarmOverVoltage));
-    MqttSettings.publish("battery/alarm/bmsInternal", String(_alarmBmsInternal));
-    MqttSettings.publish("battery/warning/highCurrentDischarge", String(_warningHighCurrentDischarge));
-    MqttSettings.publish("battery/warning/highCurrentCharge", String(_warningHighCurrentCharge));
-    MqttSettings.publish("battery/warning/lowTemperature", String(_warningLowTemperature));
-    MqttSettings.publish("battery/warning/highTemperature", String(_warningHighTemperature));
-    MqttSettings.publish("battery/warning/lowVoltage", String(_warningLowVoltage));
-    MqttSettings.publish("battery/warning/highVoltage", String(_warningHighVoltage));
-    MqttSettings.publish("battery/warning/bmsInternal", String(_warningBmsInternal));
-    MqttSettings.publish("battery/charging/chargeEnabled", String(_chargeEnabled));
-    MqttSettings.publish("battery/charging/dischargeEnabled", String(_dischargeEnabled));
-    MqttSettings.publish("battery/charging/chargeImmediately", String(_chargeImmediately));
-    MqttSettings.publish("battery/modulesTotal", String(_moduleCount));
-}
-
-void SBSBatteryStats::mqttPublish() const
-{
-    BatteryStats::mqttPublish();
-
-    MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltage));
-    MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimitation));
-    MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
-    MqttSettings.publish("battery/current", String(_current));
-    MqttSettings.publish("battery/temperature", String(_temperature));
-    MqttSettings.publish("battery/alarm/underVoltage", String(_alarmUnderVoltage));
-    MqttSettings.publish("battery/alarm/overVoltage", String(_alarmOverVoltage));
-    MqttSettings.publish("battery/alarm/bmsInternal", String(_alarmBmsInternal));
-    MqttSettings.publish("battery/warning/highCurrentDischarge", String(_warningHighCurrentDischarge));
-    MqttSettings.publish("battery/warning/highCurrentCharge", String(_warningHighCurrentCharge));
-    MqttSettings.publish("battery/charging/chargeEnabled", String(_chargeEnabled));
-    MqttSettings.publish("battery/charging/dischargeEnabled", String(_dischargeEnabled));
-}
-
-void PytesBatteryStats::mqttPublish() const
-{
-    BatteryStats::mqttPublish();
-
-    MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltageLimit));
-    MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimit));
-    MqttSettings.publish("battery/settings/dischargeVoltageLimitation", String(_dischargeVoltageLimit));
-
-    MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
-    if (_chargeCycles != -1) {
-        MqttSettings.publish("battery/chargeCycles", String(_chargeCycles));
-    }
-    if (_balance != -1) {
-        MqttSettings.publish("battery/balancingActive", String(_balance ? 1 : 0));
-    }
-    MqttSettings.publish("battery/temperature", String(_temperature));
-
-    if (_chargedEnergy != -1) {
-        MqttSettings.publish("battery/chargedEnergy", String(_chargedEnergy));
-    }
-
-    if (_dischargedEnergy != -1) {
-        MqttSettings.publish("battery/dischargedEnergy", String(_dischargedEnergy));
-    }
-
-    MqttSettings.publish("battery/capacity", String(_totalCapacity));
-    MqttSettings.publish("battery/availableCapacity", String(_availableCapacity));
-
-    MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
-    MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
-    MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
-    MqttSettings.publish("battery/CellMinTemperature", String(_cellMinTemperature));
-    MqttSettings.publish("battery/CellMaxTemperature", String(_cellMaxTemperature));
-    MqttSettings.publish("battery/CellMinVoltageName", String(_cellMinVoltageName));
-    MqttSettings.publish("battery/CellMaxVoltageName", String(_cellMaxVoltageName));
-    MqttSettings.publish("battery/CellMinTemperatureName", String(_cellMinTemperatureName));
-    MqttSettings.publish("battery/CellMaxTemperatureName", String(_cellMaxTemperatureName));
-
-    MqttSettings.publish("battery/modulesOnline", String(_moduleCountOnline));
-    MqttSettings.publish("battery/modulesOffline", String(_moduleCountOffline));
-    MqttSettings.publish("battery/modulesBlockingCharge", String(_moduleCountBlockingCharge));
-    MqttSettings.publish("battery/modulesBlockingDischarge", String(_moduleCountBlockingDischarge));
-
-    MqttSettings.publish("battery/alarm/overCurrentDischarge", String(_alarmOverCurrentDischarge));
-    MqttSettings.publish("battery/alarm/overCurrentCharge", String(_alarmOverCurrentCharge));
-    MqttSettings.publish("battery/alarm/underVoltage", String(_alarmUnderVoltage));
-    MqttSettings.publish("battery/alarm/overVoltage", String(_alarmOverVoltage));
-    MqttSettings.publish("battery/alarm/underTemperature", String(_alarmUnderTemperature));
-    MqttSettings.publish("battery/alarm/overTemperature", String(_alarmOverTemperature));
-    MqttSettings.publish("battery/alarm/underTemperatureCharge", String(_alarmUnderTemperatureCharge));
-    MqttSettings.publish("battery/alarm/overTemperatureCharge", String(_alarmOverTemperatureCharge));
-    MqttSettings.publish("battery/alarm/bmsInternal", String(_alarmInternalFailure));
-    MqttSettings.publish("battery/alarm/cellImbalance", String(_alarmCellImbalance));
-
-    MqttSettings.publish("battery/warning/highCurrentDischarge", String(_warningHighDischargeCurrent));
-    MqttSettings.publish("battery/warning/highCurrentCharge", String(_warningHighChargeCurrent));
-    MqttSettings.publish("battery/warning/lowVoltage", String(_warningLowVoltage));
-    MqttSettings.publish("battery/warning/highVoltage", String(_warningHighVoltage));
-    MqttSettings.publish("battery/warning/lowTemperature", String(_warningLowTemperature));
-    MqttSettings.publish("battery/warning/highTemperature", String(_warningHighTemperature));
-    MqttSettings.publish("battery/warning/lowTemperatureCharge", String(_warningLowTemperatureCharge));
-    MqttSettings.publish("battery/warning/highTemperatureCharge", String(_warningHighTemperatureCharge));
-    MqttSettings.publish("battery/warning/bmsInternal", String(_warningInternalFailure));
-    MqttSettings.publish("battery/warning/cellImbalance", String(_warningCellImbalance));
-
-    MqttSettings.publish("battery/charging/chargeImmediately", String(_chargeImmediately));
-}
-
-void JkBmsBatteryStats::mqttPublish() const
-{
-    BatteryStats::mqttPublish();
-
-    using Label = JkBms::DataPointLabel;
-
-    static std::vector<Label> mqttSkip = {
-        Label::CellsMilliVolt, // complex data format
-        Label::ModificationPassword, // sensitive data
-        Label::BatterySoCPercent // already published by base class
-        // NOTE that voltage is also published by the base class, however, we
-        // previously published it only from here using the respective topic.
-        // to avoid a breaking change, we publish the value again using the
-        // "old" topic.
-    };
-
-    // regularly publish all topics regardless of whether or not their value changed
-    bool neverFullyPublished = _lastFullMqttPublish == 0;
-    bool intervalElapsed = _lastFullMqttPublish + getMqttFullPublishIntervalMs() < millis();
-    bool fullPublish = neverFullyPublished || intervalElapsed;
-
-    for (auto iter = _dataPoints.cbegin(); iter != _dataPoints.cend(); ++iter) {
-        // skip data points that did not change since last published
-        if (!fullPublish && iter->second.getTimestamp() < _lastMqttPublish) { continue; }
-
-        auto skipMatch = std::find(mqttSkip.begin(), mqttSkip.end(), iter->first);
-        if (skipMatch != mqttSkip.end()) { continue; }
-
-        String topic((std::string("battery/") + iter->second.getLabelText()).c_str());
-        MqttSettings.publish(topic, iter->second.getValueText().c_str());
-    }
-
-    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
-    if (oCellVoltages.has_value() && (fullPublish || _cellVoltageTimestamp > _lastMqttPublish)) {
-        unsigned idx = 1;
-        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
-            String topic("battery/Cell");
-            topic += String(idx);
-            topic += "MilliVolt";
-
-            MqttSettings.publish(topic, String(iter->second));
-
-            ++idx;
-        }
-
-        MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
-        MqttSettings.publish("battery/CellAvgMilliVolt", String(_cellAvgMilliVolt));
-        MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
-        MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
-    }
-
-    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
-    if (oAlarms.has_value()) {
-        for (auto iter = JkBms::AlarmBitTexts.begin(); iter != JkBms::AlarmBitTexts.end(); ++iter) {
-            auto bit = iter->first;
-            String value = (*oAlarms & static_cast<uint16_t>(bit))?"1":"0";
-            MqttSettings.publish(String("battery/alarms/") + iter->second.data(), value);
-        }
-    }
-
-    auto oStatus = _dataPoints.get<Label::StatusBitmask>();
-    if (oStatus.has_value()) {
-        for (auto iter = JkBms::StatusBitTexts.begin(); iter != JkBms::StatusBitTexts.end(); ++iter) {
-            auto bit = iter->first;
-            String value = (*oStatus & static_cast<uint16_t>(bit))?"1":"0";
-            MqttSettings.publish(String("battery/status/") + iter->second.data(), value);
-        }
-    }
-
-    _lastMqttPublish = millis();
-    if (fullPublish) { _lastFullMqttPublish = _lastMqttPublish; }
-}
-
-void JbdBmsBatteryStats::mqttPublish() const
-{
-    BatteryStats::mqttPublish();
-
-    using Label = JbdBms::DataPointLabel;
-
-    static std::vector<Label> mqttSkip = {
-        Label::CellsMilliVolt, // complex data format
-        Label::BatteryVoltageMilliVolt, // already published by base class
-        Label::BatterySoCPercent // already published by base class
-    };
-
-    // regularly publish all topics regardless of whether or not their value changed
-    bool neverFullyPublished = _lastFullMqttPublish == 0;
-    bool intervalElapsed = _lastFullMqttPublish + getMqttFullPublishIntervalMs() < millis();
-    bool fullPublish = neverFullyPublished || intervalElapsed;
-
-    for (auto iter = _dataPoints.cbegin(); iter != _dataPoints.cend(); ++iter) {
-        // skip data points that did not change since last published
-        if (!fullPublish && iter->second.getTimestamp() < _lastMqttPublish) { continue; }
-
-        auto skipMatch = std::find(mqttSkip.begin(), mqttSkip.end(), iter->first);
-        if (skipMatch != mqttSkip.end()) { continue; }
-
-        String topic((std::string("battery/") + iter->second.getLabelText()).c_str());
-        MqttSettings.publish(topic, iter->second.getValueText().c_str());
-    }
-
-    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
-    if (oCellVoltages.has_value() && (fullPublish || _cellVoltageTimestamp > _lastMqttPublish)) {
-        unsigned idx = 1;
-        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
-            String topic("battery/Cell");
-            topic += String(idx);
-            topic += "MilliVolt";
-
-            MqttSettings.publish(topic, String(iter->second));
-
-            ++idx;
-        }
-
-        MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
-        MqttSettings.publish("battery/CellAvgMilliVolt", String(_cellAvgMilliVolt));
-        MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
-        MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
-    }
-
-    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
-    if (oAlarms.has_value()) {
-        for (auto iter = JbdBms::AlarmBitTexts.begin(); iter != JbdBms::AlarmBitTexts.end(); ++iter) {
-            auto bit = iter->first;
-            String value = (*oAlarms & static_cast<uint16_t>(bit))?"1":"0";
-            MqttSettings.publish(String("battery/alarms/") + iter->second.data(), value);
-        }
-    }
-
-    _lastMqttPublish = millis();
-    if (fullPublish) { _lastFullMqttPublish = _lastMqttPublish; }
-}
-
-void JkBmsBatteryStats::updateFrom(JkBms::DataPointContainer const& dp)
-{
-    using Label = JkBms::DataPointLabel;
-
-    setManufacturer("JKBMS");
-    auto oProductId = dp.get<Label::ProductId>();
-    if (oProductId.has_value()) {
-        // the first twelve chars are expected to be the "User Private Data"
-        // setting (see smartphone app). the remainder is expected be the BMS
-        // name, which can be changed at will using the smartphone app. so
-        // there is not always a "JK" in this string. if there is, we still cut
-        // the string there to avoid possible regressions.
-        setManufacturer(String(oProductId->substr(12).c_str()));
-        auto pos = oProductId->rfind("JK");
-        if (pos != std::string::npos) {
-            setManufacturer(String(oProductId->substr(pos).c_str()));
-        }
-    }
-
-    auto oSoCValue = dp.get<Label::BatterySoCPercent>();
-    if (oSoCValue.has_value()) {
-        auto oSoCDataPoint = dp.getDataPointFor<Label::BatterySoCPercent>();
-        BatteryStats::setSoC(*oSoCValue, 0/*precision*/,
-                oSoCDataPoint->getTimestamp());
-    }
-
-    auto oVoltage = dp.get<Label::BatteryVoltageMilliVolt>();
-    if (oVoltage.has_value()) {
-        auto oVoltageDataPoint = dp.getDataPointFor<Label::BatteryVoltageMilliVolt>();
-        BatteryStats::setVoltage(static_cast<float>(*oVoltage) / 1000,
-                oVoltageDataPoint->getTimestamp());
-    }
-
-    auto oCurrent = dp.get<Label::BatteryCurrentMilliAmps>();
-    if (oCurrent.has_value()) {
-        auto oCurrentDataPoint = dp.getDataPointFor<Label::BatteryCurrentMilliAmps>();
-        BatteryStats::setCurrent(static_cast<float>(*oCurrent) / 1000, 2/*precision*/,
-                oCurrentDataPoint->getTimestamp());
-    }
-
-    _dataPoints.updateFrom(dp);
-
-    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
-    if (oCellVoltages.has_value()) {
-        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
-            if (iter == oCellVoltages->cbegin()) {
-                _cellMinMilliVolt = _cellAvgMilliVolt = _cellMaxMilliVolt = iter->second;
-                continue;
-            }
-            _cellMinMilliVolt = std::min(_cellMinMilliVolt, iter->second);
-            _cellAvgMilliVolt = (_cellAvgMilliVolt + iter->second) / 2;
-            _cellMaxMilliVolt = std::max(_cellMaxMilliVolt, iter->second);
-        }
-        _cellVoltageTimestamp = millis();
-    }
-
-    auto oVersion = _dataPoints.get<Label::BmsSoftwareVersion>();
-    if (oVersion.has_value()) {
-        // raw: "11.XW_S11.262H_"
-        //   => Hardware "V11.XW" (displayed in Android app)
-        //   => Software "V11.262H" (displayed in Android app)
-        auto first = oVersion->find('_');
-        if (first != std::string::npos) {
-            _hwversion = oVersion->substr(0, first).c_str();
-
-            auto second = oVersion->find('_', first + 1);
-
-            // the 'S' seems to be merely an indicator for "software"?
-            if (oVersion->at(first + 1) == 'S') { first++; }
-
-            _fwversion = oVersion->substr(first + 1, second - first - 1).c_str();
-        }
-    }
-
-    _lastUpdate = millis();
-}
-
-void JbdBmsBatteryStats::updateFrom(JbdBms::DataPointContainer const& dp)
-{
-    using Label = JbdBms::DataPointLabel;
-
-    setManufacturer("JBDBMS");
-
-    auto oSoCValue = dp.get<Label::BatterySoCPercent>();
-    if (oSoCValue.has_value()) {
-        auto oSoCDataPoint = dp.getDataPointFor<Label::BatterySoCPercent>();
-        BatteryStats::setSoC(*oSoCValue, 0/*precision*/,
-                oSoCDataPoint->getTimestamp());
-    }
-
-    auto oVoltage = dp.get<Label::BatteryVoltageMilliVolt>();
-    if (oVoltage.has_value()) {
-        auto oVoltageDataPoint = dp.getDataPointFor<Label::BatteryVoltageMilliVolt>();
-        BatteryStats::setVoltage(static_cast<float>(*oVoltage) / 1000,
-                oVoltageDataPoint->getTimestamp());
-    }
-
-    auto oCurrent = dp.get<Label::BatteryCurrentMilliAmps>();
-    if (oCurrent.has_value()) {
-        auto oCurrentDataPoint = dp.getDataPointFor<Label::BatteryCurrentMilliAmps>();
-        BatteryStats::setCurrent(static_cast<float>(*oCurrent) / 1000, 2/*precision*/,
-                oCurrentDataPoint->getTimestamp());
-    }
-
-    _dataPoints.updateFrom(dp);
-
-    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
-    if (oCellVoltages.has_value()) {
-        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
-            if (iter == oCellVoltages->cbegin()) {
-                _cellMinMilliVolt = _cellAvgMilliVolt = _cellMaxMilliVolt = iter->second;
-                continue;
-            }
-            _cellMinMilliVolt = std::min(_cellMinMilliVolt, iter->second);
-            _cellAvgMilliVolt = (_cellAvgMilliVolt + iter->second) / 2;
-            _cellMaxMilliVolt = std::max(_cellMaxMilliVolt, iter->second);
-        }
-        _cellVoltageTimestamp = millis();
-    }
-
-    auto oSoftwareVersion = _dataPoints.get<Label::BmsSoftwareVersion>();
-    if (oSoftwareVersion.has_value()) {
-        _fwversion = oSoftwareVersion->c_str();
-    }
-
-    auto oHardwareVersion = _dataPoints.get<Label::BmsHardwareVersion>();
-    if (oHardwareVersion.has_value()) {
-        _hwversion = oHardwareVersion->c_str();
-    }
-
-    _lastUpdate = millis();
-}
-
-void VictronSmartShuntStats::updateFrom(VeDirectShuntController::data_t const& shuntData) {
-    BatteryStats::setVoltage(shuntData.batteryVoltage_V_mV / 1000.0, millis());
-    BatteryStats::setSoC(static_cast<float>(shuntData.SOC) / 10, 1/*precision*/, millis());
-    BatteryStats::setCurrent(static_cast<float>(shuntData.batteryCurrent_I_mA) / 1000, 2/*precision*/, millis());
-    _fwversion = shuntData.getFwVersionFormatted();
-
-    _chargeCycles = shuntData.H4;
-    _timeToGo = shuntData.TTG / 60;
-    _chargedEnergy = static_cast<float>(shuntData.H18) / 100;
-    _dischargedEnergy = static_cast<float>(shuntData.H17) / 100;
-    setManufacturer(String("Victron ") + shuntData.getPidAsString().data());
-    _temperature = shuntData.T;
-    _tempPresent = shuntData.tempPresent;
-    _midpointVoltage = static_cast<float>(shuntData.VM) / 1000;
-    _midpointDeviation = static_cast<float>(shuntData.DM) / 10;
-    _instantaneousPower = shuntData.P;
-    _consumedAmpHours = static_cast<float>(shuntData.CE) / 1000;
-    _lastFullCharge = shuntData.H9 / 60;
-    // shuntData.AR is a bitfield, so we need to check each bit individually
-    _alarmLowVoltage = shuntData.alarmReason_AR & 1;
-    _alarmHighVoltage = shuntData.alarmReason_AR & 2;
-    _alarmLowSOC = shuntData.alarmReason_AR & 4;
-    _alarmLowTemperature = shuntData.alarmReason_AR & 32;
-    _alarmHighTemperature = shuntData.alarmReason_AR & 64;
-
-    _lastUpdate = VeDirectShunt.getLastUpdate();
-}
-
-void VictronSmartShuntStats::getLiveViewData(JsonVariant& root) const {
-    BatteryStats::getLiveViewData(root);
-
-    // values go into the "Status" card of the web application
-    addLiveViewValue(root, "chargeCycles", _chargeCycles, "", 0);
-    addLiveViewValue(root, "chargedEnergy", _chargedEnergy, "kWh", 2);
-    addLiveViewValue(root, "dischargedEnergy", _dischargedEnergy, "kWh", 2);
-    addLiveViewValue(root, "instantaneousPower", _instantaneousPower, "W", 0);
-    addLiveViewValue(root, "consumedAmpHours", _consumedAmpHours, "Ah", 3);
-    addLiveViewValue(root, "midpointVoltage", _midpointVoltage, "V", 2);
-    addLiveViewValue(root, "midpointDeviation", _midpointDeviation, "%", 1);
-    addLiveViewValue(root, "lastFullCharge", _lastFullCharge, "min", 0);
-    if (_tempPresent) {
-        addLiveViewValue(root, "temperature", _temperature, "°C", 0);
-    }
-
-    addLiveViewAlarm(root, "lowVoltage", _alarmLowVoltage);
-    addLiveViewAlarm(root, "highVoltage", _alarmHighVoltage);
-    addLiveViewAlarm(root, "lowSOC", _alarmLowSOC);
-    addLiveViewAlarm(root, "lowTemperature", _alarmLowTemperature);
-    addLiveViewAlarm(root, "highTemperature", _alarmHighTemperature);
-}
-
-void VictronSmartShuntStats::mqttPublish() const {
-    BatteryStats::mqttPublish();
-
-    MqttSettings.publish("battery/chargeCycles", String(_chargeCycles));
-    MqttSettings.publish("battery/chargedEnergy", String(_chargedEnergy));
-    MqttSettings.publish("battery/dischargedEnergy", String(_dischargedEnergy));
-    MqttSettings.publish("battery/instantaneousPower", String(_instantaneousPower));
-    MqttSettings.publish("battery/consumedAmpHours", String(_consumedAmpHours));
-    MqttSettings.publish("battery/lastFullCharge", String(_lastFullCharge));
-    MqttSettings.publish("battery/midpointVoltage", String(_midpointVoltage));
-    MqttSettings.publish("battery/midpointDeviation", String(_midpointDeviation));
-}
diff --git a/src/Huawei_can.cpp b/src/Huawei_can.cpp
index 932bbcf6a..e9875722e 100644
--- a/src/Huawei_can.cpp
+++ b/src/Huawei_can.cpp
@@ -2,13 +2,13 @@
 /*
  * Copyright (C) 2023 Malte Schmidt and others
  */
-#include "Battery.h"
+#include <battery/Controller.h>
+#include <battery/Stats.h>
 #include "Huawei_can.h"
 #include "MessageOutput.h"
 #include "PowerMeter.h"
 #include "PowerLimiter.h"
 #include "Configuration.h"
-#include "Battery.h"
 #include "SpiManager.h"
 #include <mcp_can.h>
 
@@ -513,6 +513,3 @@ void HuaweiCanClass::setMode(uint8_t mode) {
     _mode = mode;
   }
 }
-
-
-
diff --git a/src/MqttHandleBatteryHass.cpp b/src/MqttHandleBatteryHass.cpp
deleted file mode 100644
index c80c65624..000000000
--- a/src/MqttHandleBatteryHass.cpp
+++ /dev/null
@@ -1,381 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "PylontechCanReceiver.h"
-#include "Battery.h"
-#include "MqttHandleBatteryHass.h"
-#include "Configuration.h"
-#include "MqttSettings.h"
-#include "MqttHandleHass.h"
-#include "Utils.h"
-#include "__compiled_constants.h"
-
-MqttHandleBatteryHassClass MqttHandleBatteryHass;
-
-void MqttHandleBatteryHassClass::init(Scheduler& scheduler)
-{
-    scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&MqttHandleBatteryHassClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
-    _loopTask.enable();
-}
-
-void MqttHandleBatteryHassClass::loop()
-{
-    auto const& config = Configuration.get();
-
-    if (!config.Battery.Enabled) { return; }
-
-    if (!config.Mqtt.Hass.Enabled) { return; }
-
-    // TODO(schlimmchen): this cannot make sure that transient
-    // connection problems are actually always noticed.
-    if (!MqttSettings.getConnected()) {
-        _doPublish = true;
-        return;
-    }
-
-    // only publish HA config once when (re-)connecting
-    // to the MQTT broker or on config changes.
-    if (!_doPublish) { return; }
-
-    // the MQTT battery provider does not re-publish the SoC under a different
-    // known topic. we don't know the manufacture either. HASS auto-discovery
-    // for that provider makes no sense.
-    if (config.Battery.Provider != 2) {
-        publishSensor("Manufacturer",          "mdi:factory",        "manufacturer");
-        publishSensor("Data Age",              "mdi:timer-sand",     "dataAge",       "duration", "measurement", "s");
-        publishSensor("State of Charge (SoC)", "mdi:battery-medium", "stateOfCharge", "battery",  "measurement", "%");
-    }
-
-    switch (config.Battery.Provider) {
-        case 0: // Pylontech Battery
-            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 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 voltage limit", NULL, "settings/dischargeVoltageLimitation", "voltage", "measurement", "V");
-            publishSensor("Discharge current limit", NULL, "settings/dischargeCurrentLimitation", "current", "measurement", "A");
-            publishSensor("Module Count", "mdi:counter", "modulesTotal");
-
-            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", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
-            publishBinarySensor("Warning Temperature low", "mdi:thermometer-low", "warning/lowTemperature", "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", "mdi:alert", "alarm/underVoltage", "1", "0");
-            publishBinarySensor("Warning Voltage low", "mdi:alert-outline", "warning/lowVoltage", "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", "mdi:alert", "alarm/bmsInternal", "1", "0");
-            publishBinarySensor("Warning BMS internal", "mdi:alert-outline", "warning/bmsInternal", "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", "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");
-            break;
-        case 1: // JK BMS
-            //            caption              icon                    topic                       dev. class     state class    unit
-            publishSensor("Voltage",           "mdi:battery-charging", "BatteryVoltageMilliVolt",  "voltage",     "measurement", "mV");
-            publishSensor("Current",           "mdi:current-dc",       "BatteryCurrentMilliAmps",  "current",     "measurement", "mA");
-            publishSensor("BMS Temperature",   "mdi:thermometer",      "BmsTempCelsius",           "temperature", "measurement", "°C");
-            publishSensor("Cell Voltage Diff", "mdi:battery-alert",    "CellDiffMilliVolt",        "voltage",     "measurement", "mV");
-            publishSensor("Battery Temperature 1", "mdi:thermometer",  "BatteryTempOneCelsius",    "temperature", "measurement", "°C");
-            publishSensor("Battery Temperature 2", "mdi:thermometer",  "BatteryTempTwoCelsius",    "temperature", "measurement", "°C");
-            publishSensor("Charge Cycles",     "mdi:counter",          "BatteryCycles");
-            publishSensor("Cycle Capacity",    "mdi:battery-sync",     "BatteryCycleCapacity");
-
-            publishBinarySensor("Charging Possible",    "mdi:battery-arrow-up",   "status/ChargingActive",    "1", "0");
-            publishBinarySensor("Discharging Possible", "mdi:battery-arrow-down", "status/DischargingActive", "1", "0");
-            publishBinarySensor("Balancing Active",     "mdi:scale-balance",      "status/BalancingActive",   "1", "0");
-
-#define PBS(a, b, c) publishBinarySensor("Alarm: " a, "mdi:" b, "alarms/" c, "1", "0")
-            PBS("Low Capacity",                "battery-alert-variant-outline", "LowCapacity");
-            PBS("BMS Overtemperature",         "thermometer-alert",             "BmsOvertemperature");
-            PBS("Charging Overvoltage",        "fuse-alert",                    "ChargingOvervoltage");
-            PBS("Discharge Undervoltage",      "fuse-alert",                    "DischargeUndervoltage");
-            PBS("Battery Overtemperature",     "thermometer-alert",             "BatteryOvertemperature");
-            PBS("Charging Overcurrent",        "fuse-alert",                    "ChargingOvercurrent");
-            PBS("Discharging Overcurrent",     "fuse-alert",                    "DischargeOvercurrent");
-            PBS("Cell Voltage Difference",     "battery-alert",                 "CellVoltageDifference");
-            PBS("Battery Box Overtemperature", "thermometer-alert",             "BatteryBoxOvertemperature");
-            PBS("Battery Undertemperature",    "thermometer-alert",             "BatteryUndertemperature");
-            PBS("Cell Overvoltage",            "battery-alert",                 "CellOvervoltage");
-            PBS("Cell Undervoltage",           "battery-alert",                 "CellUndervoltage");
-#undef PBS
-            break;
-        case 2: // SoC from MQTT
-            break;
-        case 3: // Victron SmartShunt
-            publishSensor("Voltage", "mdi:battery-charging", "voltage", "voltage", "measurement", "V");
-            publishSensor("Current", "mdi:current-dc", "current", "current", "measurement", "A");
-            publishSensor("Instantaneous Power", NULL, "instantaneousPower", "power", "measurement", "W");
-            publishSensor("Charged Energy", NULL, "chargedEnergy", "energy", "total_increasing", "kWh");
-            publishSensor("Discharged Energy", NULL, "dischargedEnergy", "energy", "total_increasing", "kWh");
-            publishSensor("Charge Cycles", "mdi:counter", "chargeCycles");
-            publishSensor("Consumed Amp Hours", NULL, "consumedAmpHours", NULL, "measurement", "Ah");
-            publishSensor("Last Full Charge", "mdi:timelapse", "lastFullCharge", NULL, NULL, "min");
-            publishSensor("Midpoint Voltage", NULL, "midpointVoltage", "voltage", "measurement", "V");
-            publishSensor("Midpoint Deviation", NULL, "midpointDeviation", "battery", "measurement", "%");
-            break;
-        case 4: // Pytes Battery
-            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");
-            publishSensor("Discharge voltage limit", NULL, "settings/dischargeVoltageLimitation", "voltage", "measurement", "V");
-
-            publishSensor("Voltage", "mdi:battery-charging", "voltage", "voltage", "measurement", "V");
-            publishSensor("Current", "mdi:current-dc", "current", "current", "measurement", "A");
-            publishSensor("State of Health (SOH)", "mdi:heart-plus", "stateOfHealth", NULL, "measurement", "%");
-            publishSensor("Temperature", "mdi:thermometer", "temperature", "temperature", "measurement", "°C");
-            publishSensor("Charge Cycles", "mdi:counter", "chargeCycles");
-
-            publishSensor("Charged Energy", NULL, "chargedEnergy", "energy", "total_increasing", "kWh");
-            publishSensor("Discharged Energy", NULL, "dischargedEnergy", "energy", "total_increasing", "kWh");
-
-            publishSensor("Total Capacity", NULL, "capacity");
-            publishSensor("Available Capacity", NULL, "availableCapacity");
-
-            publishSensor("Cell Min Voltage", NULL, "CellMinMilliVolt", "voltage", "measurement", "mV");
-            publishSensor("Cell Max Voltage", NULL, "CellMaxMilliVolt", "voltage", "measurement", "mV");
-            publishSensor("Cell Voltage Diff", "mdi:battery-alert", "CellDiffMilliVolt", "voltage", "measurement", "mV");
-            publishSensor("Cell Min Temperature", NULL, "CellMinTemperature", "temperature", "measurement", "°C");
-            publishSensor("Cell Max Temperature", NULL, "CellMaxTemperature", "temperature", "measurement", "°C");
-
-            publishSensor("Cell Min Voltage Label", NULL, "CellMinVoltageName");
-            publishSensor("Cell Max Voltage Label", NULL, "CellMaxVoltageName");
-            publishSensor("Cell Min Temperature Label", NULL, "CellMinTemperatureName");
-            publishSensor("Cell Max Temperature Label", NULL, "CellMaxTemperatureName");
-
-            publishSensor("Modules Online", "mdi:counter", "modulesOnline");
-            publishSensor("Modules Offline", "mdi:counter", "modulesOffline");
-            publishSensor("Modules Blocking Charge", "mdi:counter", "modulesBlockingCharge");
-            publishSensor("Modules Blocking Discharge", "mdi:counter", "modulesBlockingDischarge");
-
-            publishBinarySensor("Alarm Discharge current", "mdi:alert", "alarm/overCurrentDischarge", "1", "0");
-            publishBinarySensor("Alarm High charge current", "mdi:alert", "alarm/overCurrentCharge", "1", "0");
-            publishBinarySensor("Alarm Voltage low", "mdi:alert", "alarm/underVoltage", "1", "0");
-            publishBinarySensor("Alarm Voltage high", "mdi:alert", "alarm/overVoltage", "1", "0");
-            publishBinarySensor("Alarm Temperature low", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
-            publishBinarySensor("Alarm Temperature high", "mdi:thermometer-high", "alarm/overTemperature", "1", "0");
-            publishBinarySensor("Alarm Temperature low (charge)", "mdi:thermometer-low", "alarm/underTemperatureCharge", "1", "0");
-            publishBinarySensor("Alarm Temperature high (charge)", "mdi:thermometer-high", "alarm/overTemperatureCharge", "1", "0");
-            publishBinarySensor("Alarm BMS internal", "mdi:alert", "alarm/bmsInternal", "1", "0");
-            publishBinarySensor("Alarm Cell Imbalance", "mdi:alert-outline", "alarm/cellImbalance", "1", "0");
-
-            publishBinarySensor("Warning Discharge current", "mdi:alert-outline", "warning/highCurrentDischarge", "1", "0");
-            publishBinarySensor("Warning High charge current", "mdi:alert-outline", "warning/highCurrentCharge", "1", "0");
-            publishBinarySensor("Warning Voltage low", "mdi:alert-outline", "warning/lowVoltage", "1", "0");
-            publishBinarySensor("Warning Voltage high", "mdi:alert-outline", "warning/highVoltage", "1", "0");
-            publishBinarySensor("Warning Temperature low", "mdi:thermometer-low", "warning/lowTemperature", "1", "0");
-            publishBinarySensor("Warning Temperature high", "mdi:thermometer-high", "warning/highTemperature", "1", "0");
-            publishBinarySensor("Warning Temperature low (charge)", "mdi:thermometer-low", "warning/lowTemperatureCharge", "1", "0");
-            publishBinarySensor("Warning Temperature high (charge)", "mdi:thermometer-high", "warning/highTemperatureCharge", "1", "0");
-            publishBinarySensor("Warning BMS internal", "mdi:alert-outline", "warning/bmsInternal", "1", "0");
-            publishBinarySensor("Warning Cell Imbalance", "mdi:alert-outline", "warning/cellImbalance", "1", "0");
-
-            publishBinarySensor("Balancing Active", "mdi:scale-balance", "balancingActive", "1", "0");
-            publishBinarySensor("Charge immediately", "mdi:alert", "charging/chargeImmediately", "1", "0");
-            break;
-
-        case 5: // SBS Unipower
-            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 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("Warning Discharge current", "mdi:alert-outline", "warning/highCurrentDischarge", "1", "0");
-
-            publishBinarySensor("Alarm Temperature low", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
-
-            publishBinarySensor("Alarm Temperature high", "mdi:thermometer-high", "alarm/overTemperature", "1", "0");
-
-            publishBinarySensor("Alarm Voltage low", "mdi:alert", "alarm/underVoltage", "1", "0");
-
-            publishBinarySensor("Alarm Voltage high", "mdi:alert", "alarm/overVoltage", "1", "0");
-
-            publishBinarySensor("Alarm BMS internal", "mdi:alert", "alarm/bmsInternal", "1", "0");
-
-            publishBinarySensor("Warning High charge current", "mdi:alert-outline", "warning/highCurrentCharge", "1", "0");
-
-            publishBinarySensor("Charge enabled", "mdi:battery-arrow-up", "charging/chargeEnabled", "1", "0");
-            publishBinarySensor("Discharge enabled", "mdi:battery-arrow-down", "charging/dischargeEnabled", "1", "0");
-
-            break;
-        case 6: // JBD BMS
-            //            caption                  icon                    topic                    dev. class     state class    unit
-            publishSensor("Voltage",               "mdi:battery-charging", "voltage",               "voltage",     "measurement", "V");
-            publishSensor("Current",               "mdi:current-dc",       "current",               "current",     "measurement", "A");
-            publishSensor("Cell Min Voltage",      NULL,                   "CellMinMilliVolt",      "voltage",     "measurement", "mV");
-            publishSensor("Cell Average Voltage",  NULL,                   "CellAvgMilliVolt",      "voltage",     "measurement", "mV");
-            publishSensor("Cell Max Voltage",      NULL,                   "CellMaxMilliVolt",      "voltage",     "measurement", "mV");
-            publishSensor("Cell Voltage Diff",     "mdi:battery-alert",    "CellDiffMilliVolt",     "voltage",     "measurement", "mV");
-            publishSensor("Battery Temperature 1", "mdi:thermometer",      "BatteryTempOneCelsius", "temperature", "measurement", "°C");
-            publishSensor("Battery Temperature 2", "mdi:thermometer",      "BatteryTempTwoCelsius", "temperature", "measurement", "°C");
-            publishSensor("Alarms Bitmask",        NULL,                   "AlarmsBitmask");
-            publishSensor("Charge Cycles",         "mdi:counter",          "BatteryCycles");
-            publishSensor("Available Capacity",    NULL,                   "ActualBatteryCapacityAmpHours");
-
-            publishBinarySensor("Charging enabled",    "mdi:battery-arrow-up",   "BatteryChargeEnabled",    "yes", "no");
-            publishBinarySensor("Discharging enabled", "mdi:battery-arrow-down", "BatteryDischargeEnabled", "yes", "no");
-            publishBinarySensor("Balancing enabled",   "mdi:scale-balance",      "BatteryBalancingEnabled", "yes", "no");
-
-#define PBS(a, b, c) publishBinarySensor("Alarm: " a, "mdi:" b, "alarms/" c, "1", "0")
-            PBS("Cell Overvoltage",             "battery-alert",                 "CellOverVoltage");
-            PBS("Cell Undervoltage",            "battery-alert",                 "CellUnderVoltage");
-            PBS("Pack Overvoltage",             "fuse-alert",                    "PackOverVoltage");
-            PBS("Pack Undervoltage",            "fuse-alert",                    "PackUnderVoltage");
-            PBS("Charging Overtemperature",     "thermometer-alert",             "ChargingOverTemperature");
-            PBS("Charging Undertemperature",    "thermometer-alert",             "ChargingLowTemperature");
-            PBS("Discharging Overtemperature",  "thermometer-alert",             "DischargingOverTemperature");
-            PBS("Discharging Undertemperature", "thermometer-alert",             "DischargingLowTemperature");
-            PBS("Charging Overcurrent",         "fuse-alert",                    "ChargingOverCurrent");
-            PBS("Discharging Overcurrent",      "fuse-alert",                    "DischargeOverCurrent");
-            PBS("Short Circuit",                "fuse-alert",                    "ShortCircuit");
-            PBS("IC Frontend Error",            "battery-alert-variant-outline", "IcFrontEndError");
-            PBS("MOS Software Lock",            "battery-alert-variant-outline", "MosSoftwareLock");
-            PBS("Reserved 1",                   "battery-alert-variant-outline", "Reserved1");
-            PBS("Reserved 2",                   "battery-alert-variant-outline", "Reserved2");
-            PBS("Reserved 3",                   "battery-alert-variant-outline", "Reserved3");
-#undef PBS
-            break;
-    }
-
-    _doPublish = false;
-}
-
-void MqttHandleBatteryHassClass::publishSensor(const char* caption, const char* icon, const char* subTopic, const char* deviceClass, const char* stateClass, const char* unitOfMeasurement )
-{
-    String sensorId = caption;
-    sensorId.replace(" ", "_");
-    sensorId.replace(".", "");
-    sensorId.replace("(", "");
-    sensorId.replace(")", "");
-    sensorId.toLowerCase();
-
-    String configTopic = "sensor/dtu_battery_" + serial
-        + "/" + sensorId
-        + "/config";
-
-    String statTopic = MqttSettings.getPrefix() + "battery/";
-    // omit serial to avoid a breaking change
-    // statTopic.concat(serial);
-    // statTopic.concat("/");
-    statTopic.concat(subTopic);
-
-    JsonDocument root;
-    root["name"] = caption;
-    root["stat_t"] = statTopic;
-    root["uniq_id"] = serial + "_" + sensorId;
-
-    if (icon != NULL) {
-        root["icon"] = icon;
-    }
-
-    if (unitOfMeasurement != NULL) {
-        root["unit_of_meas"] = unitOfMeasurement;
-    }
-
-    JsonObject deviceObj = root["dev"].to<JsonObject>();
-    createDeviceInfo(deviceObj);
-
-    if (Configuration.get().Mqtt.Hass.Expire) {
-        root["exp_aft"] = Battery.getStats()->getMqttFullPublishIntervalMs() / 1000 * 3;
-    }
-    if (deviceClass != NULL) {
-        root["dev_cla"] = deviceClass;
-    }
-    if (stateClass != NULL) {
-        root["stat_cla"] = stateClass;
-    }
-
-    if (!Utils::checkJsonAlloc(root, __FUNCTION__, __LINE__)) {
-        return;
-    }
-
-    char buffer[512];
-    serializeJson(root, buffer);
-    publish(configTopic, buffer);
-
-}
-
-void MqttHandleBatteryHassClass::publishBinarySensor(const char* caption, const char* icon, const char* subTopic, const char* payload_on, const char* payload_off)
-{
-    String sensorId = caption;
-    sensorId.replace(" ", "_");
-    sensorId.replace(".", "");
-    sensorId.replace("(", "");
-    sensorId.replace(")", "");
-    sensorId.replace(":", "");
-    sensorId.toLowerCase();
-
-    String configTopic = "binary_sensor/dtu_battery_" + serial
-        + "/" + sensorId
-        + "/config";
-
-    String statTopic = MqttSettings.getPrefix() + "battery/";
-    // omit serial to avoid a breaking change
-    // statTopic.concat(serial);
-    // statTopic.concat("/");
-    statTopic.concat(subTopic);
-
-    JsonDocument root;
-
-    root["name"] = caption;
-    root["uniq_id"] = serial + "_" + sensorId;
-    root["stat_t"] = statTopic;
-    root["pl_on"] = payload_on;
-    root["pl_off"] = payload_off;
-
-    if (icon != NULL) {
-        root["icon"] = icon;
-    }
-
-    auto deviceObj = root["dev"].to<JsonObject>();
-    createDeviceInfo(deviceObj);
-
-    if (!Utils::checkJsonAlloc(root, __FUNCTION__, __LINE__)) {
-        return;
-    }
-
-    char buffer[512];
-    serializeJson(root, buffer);
-    publish(configTopic, buffer);
-}
-
-void MqttHandleBatteryHassClass::createDeviceInfo(JsonObject& object)
-{
-    object["name"] = "Battery(" + serial + ")";
-
-    auto const& config = Configuration.get();
-    if (config.Battery.Provider == 1) {
-        object["name"] = "JK BMS (" + Battery.getStats()->getManufacturer() + ")";
-    }
-
-    object["ids"] = serial;
-    object["cu"] = MqttHandleHass.getDtuUrl();
-    object["mf"] = "OpenDTU";
-    object["mdl"] = Battery.getStats()->getManufacturer();
-    object["sw"] = __COMPILED_GIT_HASH__;
-    object["via_device"] = MqttHandleHass.getDtuUniqueId();
-}
-
-void MqttHandleBatteryHassClass::publish(const String& subtopic, const String& payload)
-{
-    String topic = Configuration.get().Mqtt.Hass.Topic;
-    topic += subtopic;
-    MqttSettings.publishGeneric(topic.c_str(), payload.c_str(), Configuration.get().Mqtt.Hass.Retain);
-}
diff --git a/src/PowerLimiter.cpp b/src/PowerLimiter.cpp
index e3e7e461a..4d2e1405c 100644
--- a/src/PowerLimiter.cpp
+++ b/src/PowerLimiter.cpp
@@ -3,7 +3,8 @@
  * Copyright (C) 2022 Thomas Basler and others
  */
 
-#include "Battery.h"
+#include <battery/Controller.h>
+#include <battery/Stats.h>
 #include "PowerMeter.h"
 #include "PowerLimiter.h"
 #include "Configuration.h"
diff --git a/src/WebApi_battery.cpp b/src/WebApi_battery.cpp
index 9e6679c30..7128ff045 100644
--- a/src/WebApi_battery.cpp
+++ b/src/WebApi_battery.cpp
@@ -5,9 +5,8 @@
 
 #include "ArduinoJson.h"
 #include "AsyncJson.h"
-#include "Battery.h"
+#include <battery/Controller.h>
 #include "Configuration.h"
-#include "MqttHandleBatteryHass.h"
 #include "MqttHandlePowerLimiterHass.h"
 #include "WebApi.h"
 #include "WebApi_battery.h"
@@ -81,7 +80,6 @@ void WebApiBatteryClass::onAdminPost(AsyncWebServerRequest* request)
     WebApi.sendJsonResponse(request, response, __FUNCTION__, __LINE__);
 
     Battery.updateSettings();
-    MqttHandleBatteryHass.forceUpdate();
 
     // potentially make SoC thresholds auto-discoverable
     MqttHandlePowerLimiterHass.forceUpdate();
diff --git a/src/WebApi_mqtt.cpp b/src/WebApi_mqtt.cpp
index 1d0c2ab15..0c3620f24 100644
--- a/src/WebApi_mqtt.cpp
+++ b/src/WebApi_mqtt.cpp
@@ -4,7 +4,7 @@
  */
 #include "WebApi_mqtt.h"
 #include "Configuration.h"
-#include "MqttHandleBatteryHass.h"
+#include <battery/Controller.h>
 #include "MqttHandleHass.h"
 #include "MqttHandlePowerLimiterHass.h"
 #include "MqttHandleInverter.h"
@@ -331,10 +331,10 @@ void WebApiMqttClass::onMqttAdminPost(AsyncWebServerRequest* request)
 
     MqttSettings.performReconnect();
 
-    MqttHandleBatteryHass.forceUpdate();
     MqttHandleHass.forceUpdate();
     MqttHandlePowerLimiterHass.forceUpdate();
     MqttHandleVedirectHass.forceUpdate();
+    Battery.updateSettings();
 
     MqttHandleHuawei.forceUpdate();
     MqttHandlePowerLimiter.forceUpdate();
diff --git a/src/WebApi_ws_battery.cpp b/src/WebApi_ws_battery.cpp
index b932bfc4e..b0c0db658 100644
--- a/src/WebApi_ws_battery.cpp
+++ b/src/WebApi_ws_battery.cpp
@@ -5,7 +5,8 @@
 #include "WebApi_ws_battery.h"
 #include "AsyncJson.h"
 #include "Configuration.h"
-#include "Battery.h"
+#include <battery/Controller.h>
+#include <battery/Stats.h>
 #include "MessageOutput.h"
 #include "WebApi.h"
 #include "defaults.h"
diff --git a/src/WebApi_ws_live.cpp b/src/WebApi_ws_live.cpp
index 36031a357..8aa488bce 100644
--- a/src/WebApi_ws_live.cpp
+++ b/src/WebApi_ws_live.cpp
@@ -7,7 +7,8 @@
 #include "MessageOutput.h"
 #include "Utils.h"
 #include "WebApi.h"
-#include "Battery.h"
+#include <battery/Controller.h>
+#include <battery/Stats.h>
 #include "Huawei_can.h"
 #include "PowerMeter.h"
 #include "VictronMppt.h"
diff --git a/src/BatteryCanReceiver.cpp b/src/battery/CanReceiver.cpp
similarity index 89%
rename from src/BatteryCanReceiver.cpp
rename to src/battery/CanReceiver.cpp
index af84d0b48..5169ce0e2 100644
--- a/src/BatteryCanReceiver.cpp
+++ b/src/battery/CanReceiver.cpp
@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include "BatteryCanReceiver.h"
-#include "MessageOutput.h"
-#include "PinMapping.h"
+#include <battery/CanReceiver.h>
+#include <MessageOutput.h>
+#include <PinMapping.h>
 #include <driver/twai.h>
 
-bool BatteryCanReceiver::init(bool verboseLogging, char const* providerName)
+namespace BatteryNs {
+
+bool CanReceiver::init(bool verboseLogging, char const* providerName)
 {
     _verboseLogging = verboseLogging;
     _providerName = providerName;
@@ -80,7 +82,7 @@ bool BatteryCanReceiver::init(bool verboseLogging, char const* providerName)
     return true;
 }
 
-void BatteryCanReceiver::deinit()
+void CanReceiver::deinit()
 {
     // Stop TWAI driver
     esp_err_t twaiLastResult = twai_stop();
@@ -109,7 +111,7 @@ void BatteryCanReceiver::deinit()
     }
 }
 
-void BatteryCanReceiver::loop()
+void CanReceiver::loop()
 {
     // 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;
@@ -153,37 +155,39 @@ void BatteryCanReceiver::loop()
     onMessage(rx_message);
 }
 
-uint8_t BatteryCanReceiver::readUnsignedInt8(uint8_t *data)
+uint8_t CanReceiver::readUnsignedInt8(uint8_t *data)
 {
     return data[0];
 }
 
-uint16_t BatteryCanReceiver::readUnsignedInt16(uint8_t *data)
+uint16_t CanReceiver::readUnsignedInt16(uint8_t *data)
 {
     return (data[1] << 8) | data[0];
 }
 
-int16_t BatteryCanReceiver::readSignedInt16(uint8_t *data)
+int16_t CanReceiver::readSignedInt16(uint8_t *data)
 {
     return this->readUnsignedInt16(data);
 }
 
-int32_t BatteryCanReceiver::readSignedInt24(uint8_t *data)
+int32_t CanReceiver::readSignedInt24(uint8_t *data)
 {
     return (data[2] << 16) | (data[1] << 8) | data[0];
 }
 
-uint32_t BatteryCanReceiver::readUnsignedInt32(uint8_t *data)
+uint32_t CanReceiver::readUnsignedInt32(uint8_t *data)
 {
     return (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0];
 }
 
-float BatteryCanReceiver::scaleValue(int32_t value, float factor)
+float CanReceiver::scaleValue(int32_t value, float factor)
 {
     return value * factor;
 }
 
-bool BatteryCanReceiver::getBit(uint8_t value, uint8_t bit)
+bool CanReceiver::getBit(uint8_t value, uint8_t bit)
 {
     return (value & (1 << bit)) >> bit;
 }
+
+} // namespace BatteryNs
diff --git a/src/Battery.cpp b/src/battery/Controller.cpp
similarity index 63%
rename from src/Battery.cpp
rename to src/battery/Controller.cpp
index 5e6ade828..8b194ecc3 100644
--- a/src/Battery.cpp
+++ b/src/battery/Controller.cpp
@@ -1,39 +1,43 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include "Battery.h"
-#include "MessageOutput.h"
-#include "PylontechCanReceiver.h"
-#include "SBSCanReceiver.h"
-#include "JkBmsController.h"
-#include "JbdBmsController.h"
-#include "VictronSmartShunt.h"
-#include "MqttBattery.h"
-#include "PytesCanReceiver.h"
-
-BatteryClass Battery;
-
-std::shared_ptr<BatteryStats const> BatteryClass::getStats() const
+#include <battery/Controller.h>
+#include <battery/jbdbms/Provider.h>
+#include <battery/jkbms/Provider.h>
+#include <battery/mqtt/Provider.h>
+#include <battery/pylontech/Provider.h>
+#include <battery/pytes/Provider.h>
+#include <battery/sbs/Provider.h>
+#include <battery/victronsmartshunt/Provider.h>
+#include <Configuration.h>
+#include <MessageOutput.h>
+#include <MqttSettings.h>
+
+BatteryNs::Controller Battery;
+
+namespace BatteryNs {
+
+std::shared_ptr<Stats const> Controller::getStats() const
 {
     std::lock_guard<std::mutex> lock(_mutex);
 
     if (!_upProvider) {
-        static auto sspDummyStats = std::make_shared<BatteryStats>();
+        static auto sspDummyStats = std::make_shared<Stats>();
         return sspDummyStats;
     }
 
     return _upProvider->getStats();
 }
 
-void BatteryClass::init(Scheduler& scheduler)
+void Controller::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&BatteryClass::loop, this));
+    _loopTask.setCallback(std::bind(&Controller::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
     _loopTask.enable();
 
     this->updateSettings();
 }
 
-void BatteryClass::updateSettings()
+void Controller::updateSettings()
 {
     std::lock_guard<std::mutex> lock(_mutex);
 
@@ -49,25 +53,25 @@ void BatteryClass::updateSettings()
 
     switch (config.Battery.Provider) {
         case 0:
-            _upProvider = std::make_unique<PylontechCanReceiver>();
+            _upProvider = std::make_unique<Pylontech::Provider>();
             break;
         case 1:
-            _upProvider = std::make_unique<JkBms::Controller>();
+            _upProvider = std::make_unique<JkBms::Provider>();
             break;
         case 2:
-            _upProvider = std::make_unique<MqttBattery>();
+            _upProvider = std::make_unique<Mqtt::Provider>();
             break;
         case 3:
-            _upProvider = std::make_unique<VictronSmartShunt>();
+            _upProvider = std::make_unique<VictronSmartShunt::Provider>();
             break;
         case 4:
-            _upProvider = std::make_unique<PytesCanReceiver>();
+            _upProvider = std::make_unique<Pytes::Provider>();
             break;
         case 5:
-            _upProvider = std::make_unique<SBSCanReceiver>();
+            _upProvider = std::make_unique<SBS::Provider>();
             break;
         case 6:
-            _upProvider = std::make_unique<JbdBms::Controller>();
+            _upProvider = std::make_unique<JbdBms::Provider>();
             break;
         default:
             MessageOutput.printf("[Battery] Unknown provider: %d\r\n", config.Battery.Provider);
@@ -75,9 +79,11 @@ void BatteryClass::updateSettings()
     }
 
     if (!_upProvider->init(verboseLogging)) { _upProvider = nullptr; }
+
+    _publishSensors = true;
 }
 
-void BatteryClass::loop()
+void Controller::loop()
 {
     std::lock_guard<std::mutex> lock(_mutex);
 
@@ -86,9 +92,25 @@ void BatteryClass::loop()
     _upProvider->loop();
 
     _upProvider->getStats()->mqttLoop();
+
+    auto const& config = Configuration.get();
+    if (!config.Mqtt.Hass.Enabled) { return; }
+
+    // TODO(schlimmchen): this cannot make sure that transient
+    // connection problems are actually always noticed.
+    if (!MqttSettings.getConnected()) {
+        _publishSensors = true;
+        return;
+    }
+
+    if (!_publishSensors) { return; }
+
+    _upProvider->getHassIntegration().publishSensors();
+
+    _publishSensors = false;
 }
 
-float BatteryClass::getDischargeCurrentLimit()
+float Controller::getDischargeCurrentLimit()
 {
     auto const& config = Configuration.get();
 
@@ -129,3 +151,5 @@ float BatteryClass::getDischargeCurrentLimit()
 
     return FLT_MAX;
 }
+
+} // namespace BatteryNs
diff --git a/src/battery/HassIntegration.cpp b/src/battery/HassIntegration.cpp
new file mode 100644
index 000000000..03eeffafe
--- /dev/null
+++ b/src/battery/HassIntegration.cpp
@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/Controller.h>
+#include <battery/Stats.h>
+#include <battery/HassIntegration.h>
+#include <Configuration.h>
+#include <MqttSettings.h>
+#include <MqttHandleHass.h>
+#include <Utils.h>
+#include <__compiled_constants.h>
+
+namespace BatteryNs {
+
+void HassIntegration::publishSensors() const
+{
+    publishSensor("Manufacturer",          "mdi:factory",        "manufacturer");
+    publishSensor("Data Age",              "mdi:timer-sand",     "dataAge",       "duration", "measurement", "s");
+    publishSensor("State of Charge (SoC)", "mdi:battery-medium", "stateOfCharge", "battery",  "measurement", "%");
+}
+
+void HassIntegration::publishSensor(const char* caption, const char* icon,
+        const char* subTopic, const char* deviceClass,
+        const char* stateClass, const char* unitOfMeasurement) const
+{
+    String sensorId = caption;
+    sensorId.replace(" ", "_");
+    sensorId.replace(".", "");
+    sensorId.replace("(", "");
+    sensorId.replace(")", "");
+    sensorId.toLowerCase();
+
+    String configTopic = "sensor/dtu_battery_" + _serial
+        + "/" + sensorId
+        + "/config";
+
+    String statTopic = MqttSettings.getPrefix() + "battery/";
+    // omit serial to avoid a breaking change
+    // statTopic.concat(_serial);
+    // statTopic.concat("/");
+    statTopic.concat(subTopic);
+
+    JsonDocument root;
+    root["name"] = caption;
+    root["stat_t"] = statTopic;
+    root["uniq_id"] = _serial + "_" + sensorId;
+
+    if (icon != NULL) {
+        root["icon"] = icon;
+    }
+
+    if (unitOfMeasurement != NULL) {
+        root["unit_of_meas"] = unitOfMeasurement;
+    }
+
+    JsonObject deviceObj = root["dev"].to<JsonObject>();
+    createDeviceInfo(deviceObj);
+
+    if (Configuration.get().Mqtt.Hass.Expire) {
+        root["exp_aft"] = Battery.getStats()->getMqttFullPublishIntervalMs() / 1000 * 3;
+    }
+    if (deviceClass != NULL) {
+        root["dev_cla"] = deviceClass;
+    }
+    if (stateClass != NULL) {
+        root["stat_cla"] = stateClass;
+    }
+
+    if (!Utils::checkJsonAlloc(root, __FUNCTION__, __LINE__)) {
+        return;
+    }
+
+    char buffer[512];
+    serializeJson(root, buffer);
+    publish(configTopic, buffer);
+
+}
+
+void HassIntegration::publishBinarySensor(const char* caption,
+        const char* icon, const char* subTopic,
+        const char* payload_on, const char* payload_off) const
+{
+    String sensorId = caption;
+    sensorId.replace(" ", "_");
+    sensorId.replace(".", "");
+    sensorId.replace("(", "");
+    sensorId.replace(")", "");
+    sensorId.replace(":", "");
+    sensorId.toLowerCase();
+
+    String configTopic = "binary_sensor/dtu_battery_" + _serial
+        + "/" + sensorId
+        + "/config";
+
+    String statTopic = MqttSettings.getPrefix() + "battery/";
+    // omit serial to avoid a breaking change
+    // statTopic.concat(_serial);
+    // statTopic.concat("/");
+    statTopic.concat(subTopic);
+
+    JsonDocument root;
+
+    root["name"] = caption;
+    root["uniq_id"] = _serial + "_" + sensorId;
+    root["stat_t"] = statTopic;
+    root["pl_on"] = payload_on;
+    root["pl_off"] = payload_off;
+
+    if (icon != NULL) {
+        root["icon"] = icon;
+    }
+
+    auto deviceObj = root["dev"].to<JsonObject>();
+    createDeviceInfo(deviceObj);
+
+    if (!Utils::checkJsonAlloc(root, __FUNCTION__, __LINE__)) {
+        return;
+    }
+
+    char buffer[512];
+    serializeJson(root, buffer);
+    publish(configTopic, buffer);
+}
+
+void HassIntegration::createDeviceInfo(JsonObject& object) const
+{
+    object["name"] = "Battery(" + _serial + ")";
+
+    auto const& config = Configuration.get();
+    if (config.Battery.Provider == 1) {
+        object["name"] = "JK BMS (" + Battery.getStats()->getManufacturer() + ")";
+    }
+
+    object["ids"] = _serial;
+    object["cu"] = MqttHandleHass.getDtuUrl();
+    object["mf"] = "OpenDTU";
+    object["mdl"] = Battery.getStats()->getManufacturer();
+    object["sw"] = __COMPILED_GIT_HASH__;
+    object["via_device"] = MqttHandleHass.getDtuUniqueId();
+}
+
+void HassIntegration::publish(const String& subtopic, const String& payload) const
+{
+    String topic = Configuration.get().Mqtt.Hass.Topic;
+    topic += subtopic;
+    MqttSettings.publishGeneric(topic.c_str(), payload.c_str(), Configuration.get().Mqtt.Hass.Retain);
+}
+
+} // namespace BatteryNs
diff --git a/src/battery/Stats.cpp b/src/battery/Stats.cpp
new file mode 100644
index 000000000..0760a391a
--- /dev/null
+++ b/src/battery/Stats.cpp
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <limits>
+#include <battery/Stats.h>
+#include <Configuration.h>
+#include <MqttSettings.h>
+
+namespace BatteryNs {
+
+void Stats::setManufacturer(const String& m)
+{
+    String sanitized(m);
+    for (int i = 0; i < sanitized.length(); i++) {
+        char c = sanitized[i];
+        if (c < 0x20 || c >= 0x80) {
+            sanitized.remove(i); // Truncate string
+            break;
+        }
+    }
+    _manufacturer = std::move(sanitized);
+}
+
+bool Stats::updateAvailable(uint32_t since) const
+{
+    if (_lastUpdate == 0) { return false; } // no data at all processed yet
+
+    auto constexpr halfOfAllMillis = std::numeric_limits<uint32_t>::max() / 2;
+    return (_lastUpdate - since) < halfOfAllMillis;
+}
+
+void Stats::getLiveViewData(JsonVariant& root) const
+{
+    root["manufacturer"] = _manufacturer;
+    if (!_serial.isEmpty()) {
+        root["serial"] = _serial;
+    }
+    if (!_fwversion.isEmpty()) {
+        root["fwversion"] = _fwversion;
+    }
+    if (!_hwversion.isEmpty()) {
+        root["hwversion"] = _hwversion;
+    }
+    root["data_age"] = getAgeSeconds();
+
+    if (isSoCValid()) {
+        addLiveViewValue(root, "SoC", _soc, "%", _socPrecision);
+    }
+
+    if (isVoltageValid()) {
+        addLiveViewValue(root, "voltage", _voltage, "V", 2);
+    }
+
+    if (isCurrentValid()) {
+        addLiveViewValue(root, "current", _current, "A", _currentPrecision);
+    }
+
+    if (isDischargeCurrentLimitValid()) {
+        addLiveViewValue(root, "dischargeCurrentLimitation", _dischargeCurrentLimit, "A", 1);
+    }
+
+    root["showIssues"] = supportsAlarmsAndWarnings();
+}
+
+void Stats::mqttLoop()
+{
+    auto& config = Configuration.get();
+
+    if (!MqttSettings.getConnected()
+            || (millis() - _lastMqttPublish) < (config.Mqtt.PublishInterval * 1000)) {
+        return;
+    }
+
+    mqttPublish();
+
+    _lastMqttPublish = millis();
+}
+
+uint32_t Stats::getMqttFullPublishIntervalMs() const
+{
+    auto& config = Configuration.get();
+
+    // this is the default interval, see mqttLoop(). mqttPublish()
+    // implementations in derived classes may choose to publish some values
+    // with a lower frequency and hence implement this method with a different
+    // return value.
+    return config.Mqtt.PublishInterval * 1000;
+}
+
+void Stats::mqttPublish() const
+{
+    MqttSettings.publish("battery/manufacturer", _manufacturer);
+    MqttSettings.publish("battery/dataAge", String(getAgeSeconds()));
+
+    if (isSoCValid()) {
+        MqttSettings.publish("battery/stateOfCharge", String(_soc));
+    }
+
+    if (isVoltageValid()) {
+        MqttSettings.publish("battery/voltage", String(_voltage));
+    }
+
+    if (isCurrentValid()) {
+        MqttSettings.publish("battery/current", String(_current));
+    }
+
+    if (isDischargeCurrentLimitValid()) {
+        MqttSettings.publish("battery/settings/dischargeCurrentLimitation", String(_dischargeCurrentLimit));
+    }
+}
+
+} // namespace BatteryNs
diff --git a/src/battery/jbdbms/HassIntegration.cpp b/src/battery/jbdbms/HassIntegration.cpp
new file mode 100644
index 000000000..add950255
--- /dev/null
+++ b/src/battery/jbdbms/HassIntegration.cpp
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/jbdbms/HassIntegration.h>
+
+namespace BatteryNs::JbdBms {
+
+void HassIntegration::publishSensors() const
+{
+    ::BatteryNs::HassIntegration::publishSensors();
+
+    //            caption                  icon                    topic                    dev. class     state class    unit
+    publishSensor("Voltage",               "mdi:battery-charging", "voltage",               "voltage",     "measurement", "V");
+    publishSensor("Current",               "mdi:current-dc",       "current",               "current",     "measurement", "A");
+    publishSensor("Cell Min Voltage",      NULL,                   "CellMinMilliVolt",      "voltage",     "measurement", "mV");
+    publishSensor("Cell Average Voltage",  NULL,                   "CellAvgMilliVolt",      "voltage",     "measurement", "mV");
+    publishSensor("Cell Max Voltage",      NULL,                   "CellMaxMilliVolt",      "voltage",     "measurement", "mV");
+    publishSensor("Cell Voltage Diff",     "mdi:battery-alert",    "CellDiffMilliVolt",     "voltage",     "measurement", "mV");
+    publishSensor("Battery Temperature 1", "mdi:thermometer",      "BatteryTempOneCelsius", "temperature", "measurement", "°C");
+    publishSensor("Battery Temperature 2", "mdi:thermometer",      "BatteryTempTwoCelsius", "temperature", "measurement", "°C");
+    publishSensor("Alarms Bitmask",        NULL,                   "AlarmsBitmask");
+    publishSensor("Charge Cycles",         "mdi:counter",          "BatteryCycles");
+    publishSensor("Available Capacity",    NULL,                   "ActualBatteryCapacityAmpHours");
+
+    publishBinarySensor("Charging enabled",    "mdi:battery-arrow-up",   "BatteryChargeEnabled",    "yes", "no");
+    publishBinarySensor("Discharging enabled", "mdi:battery-arrow-down", "BatteryDischargeEnabled", "yes", "no");
+    publishBinarySensor("Balancing enabled",   "mdi:scale-balance",      "BatteryBalancingEnabled", "yes", "no");
+
+#define PBS(a, b, c) publishBinarySensor("Alarm: " a, "mdi:" b, "alarms/" c, "1", "0")
+    PBS("Cell Overvoltage",             "battery-alert",                 "CellOverVoltage");
+    PBS("Cell Undervoltage",            "battery-alert",                 "CellUnderVoltage");
+    PBS("Pack Overvoltage",             "fuse-alert",                    "PackOverVoltage");
+    PBS("Pack Undervoltage",            "fuse-alert",                    "PackUnderVoltage");
+    PBS("Charging Overtemperature",     "thermometer-alert",             "ChargingOverTemperature");
+    PBS("Charging Undertemperature",    "thermometer-alert",             "ChargingLowTemperature");
+    PBS("Discharging Overtemperature",  "thermometer-alert",             "DischargingOverTemperature");
+    PBS("Discharging Undertemperature", "thermometer-alert",             "DischargingLowTemperature");
+    PBS("Charging Overcurrent",         "fuse-alert",                    "ChargingOverCurrent");
+    PBS("Discharging Overcurrent",      "fuse-alert",                    "DischargeOverCurrent");
+    PBS("Short Circuit",                "fuse-alert",                    "ShortCircuit");
+    PBS("IC Frontend Error",            "battery-alert-variant-outline", "IcFrontEndError");
+    PBS("MOS Software Lock",            "battery-alert-variant-outline", "MosSoftwareLock");
+    PBS("Reserved 1",                   "battery-alert-variant-outline", "Reserved1");
+    PBS("Reserved 2",                   "battery-alert-variant-outline", "Reserved2");
+    PBS("Reserved 3",                   "battery-alert-variant-outline", "Reserved3");
+#undef PBS
+}
+
+} // namespace BatteryNs::JbdBms
diff --git a/src/JbdBmsController.cpp b/src/battery/jbdbms/Provider.cpp
similarity index 90%
rename from src/JbdBmsController.cpp
rename to src/battery/jbdbms/Provider.cpp
index 3fc1dd331..ed2c60441 100644
--- a/src/JbdBmsController.cpp
+++ b/src/battery/jbdbms/Provider.cpp
@@ -1,18 +1,18 @@
 #include <Arduino.h>
 #include <numeric>
-#include "Configuration.h"
-#include "HardwareSerial.h"
-#include "PinMapping.h"
-#include "MessageOutput.h"
-#include "JbdBmsDataPoints.h"
-#include "JbdBmsController.h"
-#include "JbdBmsSerialMessage.h"
-#include "SerialPortManager.h"
+#include <Configuration.h>
+#include <HardwareSerial.h>
+#include <PinMapping.h>
+#include <MessageOutput.h>
+#include <battery/jbdbms/DataPoints.h>
+#include <battery/jbdbms/Provider.h>
+#include <battery/jbdbms/SerialMessage.h>
+#include <SerialPortManager.h>
 #include <frozen/map.h>
 
-namespace JbdBms {
+namespace BatteryNs::JbdBms {
 
-bool Controller::init(bool verboseLogging)
+bool Provider::init(bool verboseLogging)
 {
     _verboseLogging = verboseLogging;
 
@@ -58,7 +58,7 @@ bool Controller::init(bool verboseLogging)
     return true;
 }
 
-void Controller::deinit()
+void Provider::deinit()
 {
     _upSerial->end();
 
@@ -68,7 +68,7 @@ void Controller::deinit()
     SerialPortManager.freePort(_serialPortOwner);
 }
 
-Controller::Interface Controller::getInterface() const
+Provider::Interface Provider::getInterface() const
 {
     auto const& config = Configuration.get();
     if (0x00 == config.Battery.JkBmsInterface) { return Interface::Uart; }
@@ -76,7 +76,7 @@ Controller::Interface Controller::getInterface() const
     return Interface::Invalid;
 }
 
-frozen::string const& Controller::getStatusText(Controller::Status status)
+frozen::string const& Provider::getStatusText(Provider::Status status)
 {
     static constexpr frozen::string missing = "programmer error: missing status text";
 
@@ -95,7 +95,7 @@ frozen::string const& Controller::getStatusText(Controller::Status status)
     return iter->second;
 }
 
-void Controller::announceStatus(Controller::Status status)
+void Provider::announceStatus(Provider::Status status)
 {
     if (_lastStatus == status && millis() < _lastStatusPrinted + 10 * 1000) { return; }
 
@@ -106,7 +106,7 @@ void Controller::announceStatus(Controller::Status status)
     _lastStatusPrinted = millis();
 }
 
-void Controller::sendRequest(uint8_t pollInterval)
+void Provider::sendRequest(uint8_t pollInterval)
 {
     if (ReadState::Idle != _readState) {
         return announceStatus(Status::BusyReading);
@@ -157,7 +157,7 @@ void Controller::sendRequest(uint8_t pollInterval)
     return announceStatus(Status::RequestSent);
 }
 
-void Controller::loop()
+void Provider::loop()
 {
     auto const& config = Configuration.get();
     uint8_t pollInterval = config.Battery.JkBmsPollingInterval;
@@ -174,7 +174,7 @@ void Controller::loop()
     }
 }
 
-void Controller::rxData(uint8_t inbyte)
+void Provider::rxData(uint8_t inbyte)
 {
     _buffer.push_back(inbyte);
 
@@ -223,13 +223,13 @@ void Controller::rxData(uint8_t inbyte)
     reset();
 }
 
-void Controller::reset()
+void Provider::reset()
 {
     _buffer.clear();
     return setReadState(ReadState::Idle);
 }
 
-void Controller::frameComplete()
+void Provider::frameComplete()
 {
     announceStatus(Status::FrameCompleted);
 
@@ -254,7 +254,7 @@ void Controller::frameComplete()
     reset();
 }
 
-void Controller::processDataPoints(DataPointContainer const& dataPoints)
+void Provider::processDataPoints(DataPointContainer const& dataPoints)
 {
     _stats->updateFrom(dataPoints);
 
@@ -271,4 +271,4 @@ void Controller::processDataPoints(DataPointContainer const& dataPoints)
     }
 }
 
-} /* namespace JbdBms */
+} // namespace BatteryNs::JbdBms
diff --git a/src/JbdBmsSerialMessage.cpp b/src/battery/jbdbms/SerialMessage.cpp
similarity index 98%
rename from src/JbdBmsSerialMessage.cpp
rename to src/battery/jbdbms/SerialMessage.cpp
index 302eeb04f..58b8e9e9f 100644
--- a/src/JbdBmsSerialMessage.cpp
+++ b/src/battery/jbdbms/SerialMessage.cpp
@@ -1,10 +1,10 @@
 #include <numeric>
 #include <sstream>
 #include <iomanip>
-#include "JbdBmsSerialMessage.h"
-#include "MessageOutput.h"
+#include <battery/jbdbms/SerialMessage.h>
+#include <MessageOutput.h>
 
-namespace JbdBms {
+namespace BatteryNs::JbdBms {
 
 SerialCommand::SerialCommand(SerialCommand::Status status, SerialCommand::Command cmd)
     : SerialMessage(7, 0x00) // frame length 7 bytes initialized with zeros
@@ -269,4 +269,4 @@ bool SerialCommand::isValid() const {
     return true;
 }
 
-} /* namespace JbdBms */
+} // namespace BatteryNs::JbdBms
diff --git a/src/battery/jbdbms/Stats.cpp b/src/battery/jbdbms/Stats.cpp
new file mode 100644
index 000000000..17509d947
--- /dev/null
+++ b/src/battery/jbdbms/Stats.cpp
@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <MqttSettings.h>
+#include <battery/jbdbms/Stats.h>
+#include <battery/jbdbms/DataPoints.h>
+
+namespace BatteryNs::JbdBms {
+
+void Stats::getJsonData(JsonVariant& root, bool verbose) const
+{
+    ::BatteryNs::Stats::getLiveViewData(root);
+
+    using Label = JbdBms::DataPointLabel;
+
+    auto oCurrent = _dataPoints.get<Label::BatteryCurrentMilliAmps>();
+    auto oVoltage = _dataPoints.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value() && oCurrent.has_value()) {
+        auto current = static_cast<float>(*oCurrent) / 1000;
+        auto voltage = static_cast<float>(*oVoltage) / 1000;
+        addLiveViewValue(root, "power", current * voltage , "W", 2);
+    }
+
+    auto oBatteryChargeEnabled = _dataPoints.get<Label::BatteryChargeEnabled>();
+    if (oBatteryChargeEnabled.has_value()) {
+        addLiveViewTextValue(root, "chargeEnabled", (*oBatteryChargeEnabled?"yes":"no"));
+    }
+
+    auto oBatteryDischargeEnabled = _dataPoints.get<Label::BatteryDischargeEnabled>();
+    if (oBatteryDischargeEnabled.has_value()) {
+        addLiveViewTextValue(root, "dischargeEnabled", (*oBatteryDischargeEnabled?"yes":"no"));
+    }
+
+    auto oTemperatureOne = _dataPoints.get<Label::BatteryTempOneCelsius>();
+    if (oTemperatureOne.has_value()) {
+        addLiveViewInSection(root, "cells", "batOneTemp", *oTemperatureOne, "°C", 0);
+    }
+
+    auto oTemperatureTwo = _dataPoints.get<Label::BatteryTempTwoCelsius>();
+    if (oTemperatureTwo.has_value()) {
+        addLiveViewInSection(root, "cells", "batTwoTemp", *oTemperatureTwo, "°C", 0);
+    }
+
+    if (_cellVoltageTimestamp > 0) {
+        addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellAvgVoltage", static_cast<float>(_cellAvgMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
+    }
+
+    auto oBalancingEnabled = _dataPoints.get<Label::BalancingEnabled>();
+    if (oBalancingEnabled.has_value()) {
+        addLiveViewTextInSection(root, "cells", "balancingActive", (*oBalancingEnabled?"yes":"no"));
+    }
+
+    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
+    if (oAlarms.has_value()) {
+#define ISSUE(t, x) \
+        auto x = *oAlarms & static_cast<uint16_t>(JbdBms::AlarmBits::x); \
+        addLiveView##t(root, "JbdBmsIssue"#x, x > 0);
+
+        //ISSUE(Warning, LowCapacity);
+        ISSUE(Alarm, CellOverVoltage);
+        ISSUE(Alarm, CellUnderVoltage);
+        ISSUE(Alarm, PackOverVoltage);
+        ISSUE(Alarm, PackUnderVoltage);
+        ISSUE(Alarm, ChargingOverTemperature);
+        ISSUE(Alarm, ChargingLowTemperature);
+        ISSUE(Alarm, DischargingOverTemperature);
+        ISSUE(Alarm, DischargingLowTemperature);
+        ISSUE(Alarm, ChargingOverCurrent);
+        ISSUE(Alarm, DischargeOverCurrent);
+        ISSUE(Alarm, ShortCircuit);
+        ISSUE(Alarm, IcFrontEndError);
+        ISSUE(Alarm, MosSotwareLock);
+        ISSUE(Alarm, Reserved1);
+        ISSUE(Alarm, Reserved2);
+        ISSUE(Alarm, Reserved3);
+#undef ISSUE
+    }
+}
+
+void Stats::mqttPublish() const
+{
+    ::BatteryNs::Stats::mqttPublish();
+
+    using Label = JbdBms::DataPointLabel;
+
+    static std::vector<Label> mqttSkip = {
+        Label::CellsMilliVolt, // complex data format
+        Label::BatteryVoltageMilliVolt, // already published by base class
+        Label::BatterySoCPercent // already published by base class
+    };
+
+    // regularly publish all topics regardless of whether or not their value changed
+    bool neverFullyPublished = _lastFullMqttPublish == 0;
+    bool intervalElapsed = _lastFullMqttPublish + getMqttFullPublishIntervalMs() < millis();
+    bool fullPublish = neverFullyPublished || intervalElapsed;
+
+    for (auto iter = _dataPoints.cbegin(); iter != _dataPoints.cend(); ++iter) {
+        // skip data points that did not change since last published
+        if (!fullPublish && iter->second.getTimestamp() < _lastMqttPublish) { continue; }
+
+        auto skipMatch = std::find(mqttSkip.begin(), mqttSkip.end(), iter->first);
+        if (skipMatch != mqttSkip.end()) { continue; }
+
+        String topic((std::string("battery/") + iter->second.getLabelText()).c_str());
+        MqttSettings.publish(topic, iter->second.getValueText().c_str());
+    }
+
+    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
+    if (oCellVoltages.has_value() && (fullPublish || _cellVoltageTimestamp > _lastMqttPublish)) {
+        unsigned idx = 1;
+        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
+            String topic("battery/Cell");
+            topic += String(idx);
+            topic += "MilliVolt";
+
+            MqttSettings.publish(topic, String(iter->second));
+
+            ++idx;
+        }
+
+        MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
+        MqttSettings.publish("battery/CellAvgMilliVolt", String(_cellAvgMilliVolt));
+        MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
+        MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
+    }
+
+    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
+    if (oAlarms.has_value()) {
+        for (auto iter = JbdBms::AlarmBitTexts.begin(); iter != JbdBms::AlarmBitTexts.end(); ++iter) {
+            auto bit = iter->first;
+            String value = (*oAlarms & static_cast<uint16_t>(bit))?"1":"0";
+            MqttSettings.publish(String("battery/alarms/") + iter->second.data(), value);
+        }
+    }
+
+    _lastMqttPublish = millis();
+    if (fullPublish) { _lastFullMqttPublish = _lastMqttPublish; }
+}
+
+void Stats::updateFrom(JbdBms::DataPointContainer const& dp)
+{
+    using Label = JbdBms::DataPointLabel;
+
+    setManufacturer("JBDBMS");
+
+    auto oSoCValue = dp.get<Label::BatterySoCPercent>();
+    if (oSoCValue.has_value()) {
+        auto oSoCDataPoint = dp.getDataPointFor<Label::BatterySoCPercent>();
+        ::BatteryNs::Stats::setSoC(*oSoCValue, 0/*precision*/,
+                oSoCDataPoint->getTimestamp());
+    }
+
+    auto oVoltage = dp.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value()) {
+        auto oVoltageDataPoint = dp.getDataPointFor<Label::BatteryVoltageMilliVolt>();
+        ::BatteryNs::Stats::setVoltage(static_cast<float>(*oVoltage) / 1000,
+                oVoltageDataPoint->getTimestamp());
+    }
+
+    auto oCurrent = dp.get<Label::BatteryCurrentMilliAmps>();
+    if (oCurrent.has_value()) {
+        auto oCurrentDataPoint = dp.getDataPointFor<Label::BatteryCurrentMilliAmps>();
+        ::BatteryNs::Stats::setCurrent(static_cast<float>(*oCurrent) / 1000, 2/*precision*/,
+                oCurrentDataPoint->getTimestamp());
+    }
+
+    _dataPoints.updateFrom(dp);
+
+    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
+    if (oCellVoltages.has_value()) {
+        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
+            if (iter == oCellVoltages->cbegin()) {
+                _cellMinMilliVolt = _cellAvgMilliVolt = _cellMaxMilliVolt = iter->second;
+                continue;
+            }
+            _cellMinMilliVolt = std::min(_cellMinMilliVolt, iter->second);
+            _cellAvgMilliVolt = (_cellAvgMilliVolt + iter->second) / 2;
+            _cellMaxMilliVolt = std::max(_cellMaxMilliVolt, iter->second);
+        }
+        _cellVoltageTimestamp = millis();
+    }
+
+    auto oSoftwareVersion = _dataPoints.get<Label::BmsSoftwareVersion>();
+    if (oSoftwareVersion.has_value()) {
+        _fwversion = oSoftwareVersion->c_str();
+    }
+
+    auto oHardwareVersion = _dataPoints.get<Label::BmsHardwareVersion>();
+    if (oHardwareVersion.has_value()) {
+        _hwversion = oHardwareVersion->c_str();
+    }
+
+    _lastUpdate = millis();
+}
+
+} // namespace BatteryNs::JbdBms
diff --git a/src/battery/jkbms/HassIntegration.cpp b/src/battery/jkbms/HassIntegration.cpp
new file mode 100644
index 000000000..67c70eda9
--- /dev/null
+++ b/src/battery/jkbms/HassIntegration.cpp
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/jkbms/HassIntegration.h>
+
+namespace BatteryNs::JkBms {
+
+void HassIntegration::publishSensors() const
+{
+    ::BatteryNs::HassIntegration::publishSensors();
+
+    //            caption              icon                    topic                       dev. class     state class    unit
+    publishSensor("Voltage",           "mdi:battery-charging", "BatteryVoltageMilliVolt",  "voltage",     "measurement", "mV");
+    publishSensor("Current",           "mdi:current-dc",       "BatteryCurrentMilliAmps",  "current",     "measurement", "mA");
+    publishSensor("BMS Temperature",   "mdi:thermometer",      "BmsTempCelsius",           "temperature", "measurement", "°C");
+    publishSensor("Cell Voltage Diff", "mdi:battery-alert",    "CellDiffMilliVolt",        "voltage",     "measurement", "mV");
+    publishSensor("Battery Temperature 1", "mdi:thermometer",  "BatteryTempOneCelsius",    "temperature", "measurement", "°C");
+    publishSensor("Battery Temperature 2", "mdi:thermometer",  "BatteryTempTwoCelsius",    "temperature", "measurement", "°C");
+    publishSensor("Charge Cycles",     "mdi:counter",          "BatteryCycles");
+    publishSensor("Cycle Capacity",    "mdi:battery-sync",     "BatteryCycleCapacity");
+
+    publishBinarySensor("Charging Possible",    "mdi:battery-arrow-up",   "status/ChargingActive",    "1", "0");
+    publishBinarySensor("Discharging Possible", "mdi:battery-arrow-down", "status/DischargingActive", "1", "0");
+    publishBinarySensor("Balancing Active",     "mdi:scale-balance",      "status/BalancingActive",   "1", "0");
+
+#define PBS(a, b, c) publishBinarySensor("Alarm: " a, "mdi:" b, "alarms/" c, "1", "0")
+    PBS("Low Capacity",                "battery-alert-variant-outline", "LowCapacity");
+    PBS("BMS Overtemperature",         "thermometer-alert",             "BmsOvertemperature");
+    PBS("Charging Overvoltage",        "fuse-alert",                    "ChargingOvervoltage");
+    PBS("Discharge Undervoltage",      "fuse-alert",                    "DischargeUndervoltage");
+    PBS("Battery Overtemperature",     "thermometer-alert",             "BatteryOvertemperature");
+    PBS("Charging Overcurrent",        "fuse-alert",                    "ChargingOvercurrent");
+    PBS("Discharging Overcurrent",     "fuse-alert",                    "DischargeOvercurrent");
+    PBS("Cell Voltage Difference",     "battery-alert",                 "CellVoltageDifference");
+    PBS("Battery Box Overtemperature", "thermometer-alert",             "BatteryBoxOvertemperature");
+    PBS("Battery Undertemperature",    "thermometer-alert",             "BatteryUndertemperature");
+    PBS("Cell Overvoltage",            "battery-alert",                 "CellOvervoltage");
+    PBS("Cell Undervoltage",           "battery-alert",                 "CellUndervoltage");
+#undef PBS
+}
+
+} // namespace BatteryNs::JkBms
diff --git a/src/JkBmsController.cpp b/src/battery/jkbms/Provider.cpp
similarity index 90%
rename from src/JkBmsController.cpp
rename to src/battery/jkbms/Provider.cpp
index 0a53ec2f2..b0cc2602c 100644
--- a/src/JkBmsController.cpp
+++ b/src/battery/jkbms/Provider.cpp
@@ -1,16 +1,16 @@
 #include <Arduino.h>
-#include "Configuration.h"
-#include "HardwareSerial.h"
-#include "PinMapping.h"
-#include "MessageOutput.h"
-#include "JkBmsDataPoints.h"
-#include "JkBmsController.h"
-#include "SerialPortManager.h"
+#include <Configuration.h>
+#include <HardwareSerial.h>
+#include <PinMapping.h>
+#include <MessageOutput.h>
+#include <battery/jkbms/DataPoints.h>
+#include <battery/jkbms/Provider.h>
+#include <SerialPortManager.h>
 #include <frozen/map.h>
 
-namespace JkBms {
+namespace BatteryNs::JkBms {
 
-bool Controller::init(bool verboseLogging)
+bool Provider::init(bool verboseLogging)
 {
     _verboseLogging = verboseLogging;
 
@@ -56,7 +56,7 @@ bool Controller::init(bool verboseLogging)
     return true;
 }
 
-void Controller::deinit()
+void Provider::deinit()
 {
     _upSerial->end();
 
@@ -66,7 +66,7 @@ void Controller::deinit()
     SerialPortManager.freePort(_serialPortOwner);
 }
 
-Controller::Interface Controller::getInterface() const
+Provider::Interface Provider::getInterface() const
 {
     auto const& config = Configuration.get();
     if (0x00 == config.Battery.JkBmsInterface) { return Interface::Uart; }
@@ -74,7 +74,7 @@ Controller::Interface Controller::getInterface() const
     return Interface::Invalid;
 }
 
-frozen::string const& Controller::getStatusText(Controller::Status status)
+frozen::string const& Provider::getStatusText(Provider::Status status)
 {
     static constexpr frozen::string missing = "programmer error: missing status text";
 
@@ -93,7 +93,7 @@ frozen::string const& Controller::getStatusText(Controller::Status status)
     return iter->second;
 }
 
-void Controller::announceStatus(Controller::Status status)
+void Provider::announceStatus(Provider::Status status)
 {
     if (_lastStatus == status && millis() < _lastStatusPrinted + 10 * 1000) { return; }
 
@@ -104,7 +104,7 @@ void Controller::announceStatus(Controller::Status status)
     _lastStatusPrinted = millis();
 }
 
-void Controller::sendRequest(uint8_t pollInterval)
+void Provider::sendRequest(uint8_t pollInterval)
 {
     if (ReadState::Idle != _readState) {
         return announceStatus(Status::BusyReading);
@@ -139,7 +139,7 @@ void Controller::sendRequest(uint8_t pollInterval)
     return announceStatus(Status::RequestSent);
 }
 
-void Controller::loop()
+void Provider::loop()
 {
     auto const& config = Configuration.get();
     uint8_t pollInterval = config.Battery.JkBmsPollingInterval;
@@ -156,7 +156,7 @@ void Controller::loop()
     }
 }
 
-void Controller::rxData(uint8_t inbyte)
+void Provider::rxData(uint8_t inbyte)
 {
     _buffer.push_back(inbyte);
 
@@ -193,13 +193,13 @@ void Controller::rxData(uint8_t inbyte)
     reset();
 }
 
-void Controller::reset()
+void Provider::reset()
 {
     _buffer.clear();
     return setReadState(ReadState::Idle);
 }
 
-void Controller::frameComplete()
+void Provider::frameComplete()
 {
     announceStatus(Status::FrameCompleted);
 
@@ -224,7 +224,7 @@ void Controller::frameComplete()
     reset();
 }
 
-void Controller::processDataPoints(DataPointContainer const& dataPoints)
+void Provider::processDataPoints(DataPointContainer const& dataPoints)
 {
     _stats->updateFrom(dataPoints);
 
@@ -246,4 +246,4 @@ void Controller::processDataPoints(DataPointContainer const& dataPoints)
     }
 }
 
-} /* namespace JkBms */
+} // namespace BatteryNs::JkBms
diff --git a/src/JkBmsSerialMessage.cpp b/src/battery/jkbms/SerialMessage.cpp
similarity index 99%
rename from src/JkBmsSerialMessage.cpp
rename to src/battery/jkbms/SerialMessage.cpp
index 95744a6d1..d9a1a51ed 100644
--- a/src/JkBmsSerialMessage.cpp
+++ b/src/battery/jkbms/SerialMessage.cpp
@@ -1,9 +1,8 @@
 #include <numeric>
+#include <battery/jkbms/SerialMessage.h>
+#include <MessageOutput.h>
 
-#include "JkBmsSerialMessage.h"
-#include "MessageOutput.h"
-
-namespace JkBms {
+namespace BatteryNs::JkBms {
 
 SerialCommand::SerialCommand(SerialCommand::Command cmd)
     : SerialMessage(20, 0x00)
@@ -360,4 +359,4 @@ bool SerialMessage::isValid() const {
     return true;
 }
 
-} /* namespace JkBms */
+} // namespace BatteryNs::JkBms
diff --git a/src/battery/jkbms/Stats.cpp b/src/battery/jkbms/Stats.cpp
new file mode 100644
index 000000000..ad1e61a5d
--- /dev/null
+++ b/src/battery/jkbms/Stats.cpp
@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <MqttSettings.h>
+#include <battery/jkbms/Stats.h>
+#include <battery/jkbms/DataPoints.h>
+
+namespace BatteryNs::JkBms {
+
+void Stats::getJsonData(JsonVariant& root, bool verbose) const
+{
+    ::BatteryNs::Stats::getLiveViewData(root);
+
+    using Label = JkBms::DataPointLabel;
+
+    auto oCurrent = _dataPoints.get<Label::BatteryCurrentMilliAmps>();
+    auto oVoltage = _dataPoints.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value() && oCurrent.has_value()) {
+        auto current = static_cast<float>(*oCurrent) / 1000;
+        auto voltage = static_cast<float>(*oVoltage) / 1000;
+        addLiveViewValue(root, "power", current * voltage , "W", 2);
+    }
+
+    auto oTemperatureBms = _dataPoints.get<Label::BmsTempCelsius>();
+    if (oTemperatureBms.has_value()) {
+        addLiveViewValue(root, "bmsTemp", *oTemperatureBms, "°C", 0);
+    }
+
+    // labels BatteryChargeEnabled, BatteryDischargeEnabled, and
+    // BalancingEnabled refer to the user setting. we want to show the
+    // actual MOSFETs' state which control whether charging and discharging
+    // is possible and whether the BMS is currently balancing cells.
+    auto oStatus = _dataPoints.get<Label::StatusBitmask>();
+    if (oStatus.has_value()) {
+        using Bits = JkBms::StatusBits;
+        auto chargeEnabled = *oStatus & static_cast<uint16_t>(Bits::ChargingActive);
+        addLiveViewTextValue(root, "chargeEnabled", (chargeEnabled?"yes":"no"));
+        auto dischargeEnabled = *oStatus & static_cast<uint16_t>(Bits::DischargingActive);
+        addLiveViewTextValue(root, "dischargeEnabled", (dischargeEnabled?"yes":"no"));
+    }
+
+    auto oTemperatureOne = _dataPoints.get<Label::BatteryTempOneCelsius>();
+    if (oTemperatureOne.has_value()) {
+        addLiveViewInSection(root, "cells", "batOneTemp", *oTemperatureOne, "°C", 0);
+    }
+
+    auto oTemperatureTwo = _dataPoints.get<Label::BatteryTempTwoCelsius>();
+    if (oTemperatureTwo.has_value()) {
+        addLiveViewInSection(root, "cells", "batTwoTemp", *oTemperatureTwo, "°C", 0);
+    }
+
+    if (_cellVoltageTimestamp > 0) {
+        addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellAvgVoltage", static_cast<float>(_cellAvgMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
+        addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
+    }
+
+    if (oStatus.has_value()) {
+        using Bits = JkBms::StatusBits;
+        auto balancingActive = *oStatus & static_cast<uint16_t>(Bits::BalancingActive);
+        addLiveViewTextInSection(root, "cells", "balancingActive", (balancingActive?"yes":"no"));
+    }
+
+    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
+    if (oAlarms.has_value()) {
+#define ISSUE(t, x) \
+        auto x = *oAlarms & static_cast<uint16_t>(JkBms::AlarmBits::x); \
+        addLiveView##t(root, "JkBmsIssue"#x, x > 0);
+
+        ISSUE(Warning, LowCapacity);
+        ISSUE(Alarm, BmsOvertemperature);
+        ISSUE(Alarm, ChargingOvervoltage);
+        ISSUE(Alarm, DischargeUndervoltage);
+        ISSUE(Alarm, BatteryOvertemperature);
+        ISSUE(Alarm, ChargingOvercurrent);
+        ISSUE(Alarm, DischargeOvercurrent);
+        ISSUE(Alarm, CellVoltageDifference);
+        ISSUE(Alarm, BatteryBoxOvertemperature);
+        ISSUE(Alarm, BatteryUndertemperature);
+        ISSUE(Alarm, CellOvervoltage);
+        ISSUE(Alarm, CellUndervoltage);
+        ISSUE(Alarm, AProtect);
+        ISSUE(Alarm, BProtect);
+#undef ISSUE
+    }
+}
+
+void Stats::mqttPublish() const
+{
+    ::BatteryNs::Stats::mqttPublish();
+
+    using Label = JkBms::DataPointLabel;
+
+    static std::vector<Label> mqttSkip = {
+        Label::CellsMilliVolt, // complex data format
+        Label::ModificationPassword, // sensitive data
+        Label::BatterySoCPercent // already published by base class
+        // NOTE that voltage is also published by the base class, however, we
+        // previously published it only from here using the respective topic.
+        // to avoid a breaking change, we publish the value again using the
+        // "old" topic.
+    };
+
+    // regularly publish all topics regardless of whether or not their value changed
+    bool neverFullyPublished = _lastFullMqttPublish == 0;
+    bool intervalElapsed = _lastFullMqttPublish + getMqttFullPublishIntervalMs() < millis();
+    bool fullPublish = neverFullyPublished || intervalElapsed;
+
+    for (auto iter = _dataPoints.cbegin(); iter != _dataPoints.cend(); ++iter) {
+        // skip data points that did not change since last published
+        if (!fullPublish && iter->second.getTimestamp() < _lastMqttPublish) { continue; }
+
+        auto skipMatch = std::find(mqttSkip.begin(), mqttSkip.end(), iter->first);
+        if (skipMatch != mqttSkip.end()) { continue; }
+
+        String topic((std::string("battery/") + iter->second.getLabelText()).c_str());
+        MqttSettings.publish(topic, iter->second.getValueText().c_str());
+    }
+
+    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
+    if (oCellVoltages.has_value() && (fullPublish || _cellVoltageTimestamp > _lastMqttPublish)) {
+        unsigned idx = 1;
+        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
+            String topic("battery/Cell");
+            topic += String(idx);
+            topic += "MilliVolt";
+
+            MqttSettings.publish(topic, String(iter->second));
+
+            ++idx;
+        }
+
+        MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
+        MqttSettings.publish("battery/CellAvgMilliVolt", String(_cellAvgMilliVolt));
+        MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
+        MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
+    }
+
+    auto oAlarms = _dataPoints.get<Label::AlarmsBitmask>();
+    if (oAlarms.has_value()) {
+        for (auto iter = JkBms::AlarmBitTexts.begin(); iter != JkBms::AlarmBitTexts.end(); ++iter) {
+            auto bit = iter->first;
+            String value = (*oAlarms & static_cast<uint16_t>(bit))?"1":"0";
+            MqttSettings.publish(String("battery/alarms/") + iter->second.data(), value);
+        }
+    }
+
+    auto oStatus = _dataPoints.get<Label::StatusBitmask>();
+    if (oStatus.has_value()) {
+        for (auto iter = JkBms::StatusBitTexts.begin(); iter != JkBms::StatusBitTexts.end(); ++iter) {
+            auto bit = iter->first;
+            String value = (*oStatus & static_cast<uint16_t>(bit))?"1":"0";
+            MqttSettings.publish(String("battery/status/") + iter->second.data(), value);
+        }
+    }
+
+    _lastMqttPublish = millis();
+    if (fullPublish) { _lastFullMqttPublish = _lastMqttPublish; }
+}
+
+void Stats::updateFrom(JkBms::DataPointContainer const& dp)
+{
+    using Label = JkBms::DataPointLabel;
+
+    setManufacturer("JKBMS");
+    auto oProductId = dp.get<Label::ProductId>();
+    if (oProductId.has_value()) {
+        // the first twelve chars are expected to be the "User Private Data"
+        // setting (see smartphone app). the remainder is expected be the BMS
+        // name, which can be changed at will using the smartphone app. so
+        // there is not always a "JK" in this string. if there is, we still cut
+        // the string there to avoid possible regressions.
+        setManufacturer(String(oProductId->substr(12).c_str()));
+        auto pos = oProductId->rfind("JK");
+        if (pos != std::string::npos) {
+            setManufacturer(String(oProductId->substr(pos).c_str()));
+        }
+    }
+
+    auto oSoCValue = dp.get<Label::BatterySoCPercent>();
+    if (oSoCValue.has_value()) {
+        auto oSoCDataPoint = dp.getDataPointFor<Label::BatterySoCPercent>();
+        ::BatteryNs::Stats::setSoC(*oSoCValue, 0/*precision*/,
+                oSoCDataPoint->getTimestamp());
+    }
+
+    auto oVoltage = dp.get<Label::BatteryVoltageMilliVolt>();
+    if (oVoltage.has_value()) {
+        auto oVoltageDataPoint = dp.getDataPointFor<Label::BatteryVoltageMilliVolt>();
+        ::BatteryNs::Stats::setVoltage(static_cast<float>(*oVoltage) / 1000,
+                oVoltageDataPoint->getTimestamp());
+    }
+
+    auto oCurrent = dp.get<Label::BatteryCurrentMilliAmps>();
+    if (oCurrent.has_value()) {
+        auto oCurrentDataPoint = dp.getDataPointFor<Label::BatteryCurrentMilliAmps>();
+        ::BatteryNs::Stats::setCurrent(static_cast<float>(*oCurrent) / 1000, 2/*precision*/,
+                oCurrentDataPoint->getTimestamp());
+    }
+
+    _dataPoints.updateFrom(dp);
+
+    auto oCellVoltages = _dataPoints.get<Label::CellsMilliVolt>();
+    if (oCellVoltages.has_value()) {
+        for (auto iter = oCellVoltages->cbegin(); iter != oCellVoltages->cend(); ++iter) {
+            if (iter == oCellVoltages->cbegin()) {
+                _cellMinMilliVolt = _cellAvgMilliVolt = _cellMaxMilliVolt = iter->second;
+                continue;
+            }
+            _cellMinMilliVolt = std::min(_cellMinMilliVolt, iter->second);
+            _cellAvgMilliVolt = (_cellAvgMilliVolt + iter->second) / 2;
+            _cellMaxMilliVolt = std::max(_cellMaxMilliVolt, iter->second);
+        }
+        _cellVoltageTimestamp = millis();
+    }
+
+    auto oVersion = _dataPoints.get<Label::BmsSoftwareVersion>();
+    if (oVersion.has_value()) {
+        // raw: "11.XW_S11.262H_"
+        //   => Hardware "V11.XW" (displayed in Android app)
+        //   => Software "V11.262H" (displayed in Android app)
+        auto first = oVersion->find('_');
+        if (first != std::string::npos) {
+            _hwversion = oVersion->substr(0, first).c_str();
+
+            auto second = oVersion->find('_', first + 1);
+
+            // the 'S' seems to be merely an indicator for "software"?
+            if (oVersion->at(first + 1) == 'S') { first++; }
+
+            _fwversion = oVersion->substr(first + 1, second - first - 1).c_str();
+        }
+    }
+
+    _lastUpdate = millis();
+}
+
+} // namespace BatteryNs::JkBms
diff --git a/src/MqttBattery.cpp b/src/battery/mqtt/Provider.cpp
similarity index 88%
rename from src/MqttBattery.cpp
rename to src/battery/mqtt/Provider.cpp
index 24d29582f..6efc9193e 100644
--- a/src/MqttBattery.cpp
+++ b/src/battery/mqtt/Provider.cpp
@@ -1,12 +1,13 @@
 #include <functional>
+#include <Configuration.h>
+#include <battery/mqtt/Provider.h>
+#include <MqttSettings.h>
+#include <MessageOutput.h>
+#include <Utils.h>
 
-#include "Configuration.h"
-#include "MqttBattery.h"
-#include "MqttSettings.h"
-#include "MessageOutput.h"
-#include "Utils.h"
+namespace BatteryNs::Mqtt {
 
-bool MqttBattery::init(bool verboseLogging)
+bool Provider::init(bool verboseLogging)
 {
     _verboseLogging = verboseLogging;
     _stats->setManufacturer("MQTT");
@@ -16,7 +17,7 @@ bool MqttBattery::init(bool verboseLogging)
     _socTopic = config.Battery.MqttSocTopic;
     if (!_socTopic.isEmpty()) {
         MqttSettings.subscribe(_socTopic, 0/*QoS*/,
-                std::bind(&MqttBattery::onMqttMessageSoC,
+                std::bind(&Provider::onMqttMessageSoC,
                     this, std::placeholders::_1, std::placeholders::_2,
                     std::placeholders::_3, std::placeholders::_4,
                     std::placeholders::_5, std::placeholders::_6,
@@ -32,7 +33,7 @@ bool MqttBattery::init(bool verboseLogging)
     _voltageTopic = config.Battery.MqttVoltageTopic;
     if (!_voltageTopic.isEmpty()) {
         MqttSettings.subscribe(_voltageTopic, 0/*QoS*/,
-                std::bind(&MqttBattery::onMqttMessageVoltage,
+                std::bind(&Provider::onMqttMessageVoltage,
                     this, std::placeholders::_1, std::placeholders::_2,
                     std::placeholders::_3, std::placeholders::_4,
                     std::placeholders::_5, std::placeholders::_6,
@@ -50,7 +51,7 @@ bool MqttBattery::init(bool verboseLogging)
 
         if (!_dischargeCurrentLimitTopic.isEmpty()) {
             MqttSettings.subscribe(_dischargeCurrentLimitTopic, 0/*QoS*/,
-                    std::bind(&MqttBattery::onMqttMessageDischargeCurrentLimit,
+                    std::bind(&Provider::onMqttMessageDischargeCurrentLimit,
                         this, std::placeholders::_1, std::placeholders::_2,
                         std::placeholders::_3, std::placeholders::_4,
                         std::placeholders::_5, std::placeholders::_6,
@@ -67,7 +68,7 @@ bool MqttBattery::init(bool verboseLogging)
     return true;
 }
 
-void MqttBattery::deinit()
+void Provider::deinit()
 {
     if (!_voltageTopic.isEmpty()) {
         MqttSettings.unsubscribe(_voltageTopic);
@@ -82,7 +83,7 @@ void MqttBattery::deinit()
     }
 }
 
-void MqttBattery::onMqttMessageSoC(espMqttClientTypes::MessageProperties const& properties,
+void Provider::onMqttMessageSoC(espMqttClientTypes::MessageProperties const& properties,
         char const* topic, uint8_t const* payload, size_t len, size_t index, size_t total,
         char const* jsonPath)
 {
@@ -115,7 +116,7 @@ void MqttBattery::onMqttMessageSoC(espMqttClientTypes::MessageProperties const&
     }
 }
 
-void MqttBattery::onMqttMessageVoltage(espMqttClientTypes::MessageProperties const& properties,
+void Provider::onMqttMessageVoltage(espMqttClientTypes::MessageProperties const& properties,
         char const* topic, uint8_t const* payload, size_t len, size_t index, size_t total,
         char const* jsonPath)
 {
@@ -159,7 +160,7 @@ void MqttBattery::onMqttMessageVoltage(espMqttClientTypes::MessageProperties con
     }
 }
 
-void MqttBattery::onMqttMessageDischargeCurrentLimit(espMqttClientTypes::MessageProperties const& properties,
+void Provider::onMqttMessageDischargeCurrentLimit(espMqttClientTypes::MessageProperties const& properties,
         char const* topic, uint8_t const* payload, size_t len, size_t index, size_t total,
         char const* jsonPath)
 {
@@ -193,3 +194,5 @@ void MqttBattery::onMqttMessageDischargeCurrentLimit(espMqttClientTypes::Message
                 *amperage, topic);
     }
 }
+
+} // namespace BatteryNs::Mqtt
diff --git a/src/battery/mqtt/Stats.cpp b/src/battery/mqtt/Stats.cpp
new file mode 100644
index 000000000..8e2ecfe50
--- /dev/null
+++ b/src/battery/mqtt/Stats.cpp
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <MqttSettings.h>
+#include <battery/mqtt/Stats.h>
+
+namespace BatteryNs::Mqtt {
+
+void Stats::getLiveViewData(JsonVariant& root) const
+{
+    // as we don't want to repeat the data that is already shown in the live data card
+    // we only add the live view data here when the discharge current limit can be shown
+    if (isDischargeCurrentLimitValid()) {
+        ::BatteryNs::Stats::getLiveViewData(root);
+    }
+}
+
+} // namespace BatteryNs::Mqtt
diff --git a/src/battery/pylontech/HassIntegration.cpp b/src/battery/pylontech/HassIntegration.cpp
new file mode 100644
index 000000000..75d251e8b
--- /dev/null
+++ b/src/battery/pylontech/HassIntegration.cpp
@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/pylontech/HassIntegration.h>
+
+namespace BatteryNs::Pylontech {
+
+void HassIntegration::publishSensors() const
+{
+    ::BatteryNs::HassIntegration::publishSensors();
+
+    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 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 voltage limit", NULL, "settings/dischargeVoltageLimitation", "voltage", "measurement", "V");
+    publishSensor("Discharge current limit", NULL, "settings/dischargeCurrentLimitation", "current", "measurement", "A");
+    publishSensor("Module Count", "mdi:counter", "modulesTotal");
+
+    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", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
+    publishBinarySensor("Warning Temperature low", "mdi:thermometer-low", "warning/lowTemperature", "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", "mdi:alert", "alarm/underVoltage", "1", "0");
+    publishBinarySensor("Warning Voltage low", "mdi:alert-outline", "warning/lowVoltage", "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", "mdi:alert", "alarm/bmsInternal", "1", "0");
+    publishBinarySensor("Warning BMS internal", "mdi:alert-outline", "warning/bmsInternal", "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", "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");
+}
+
+} // namespace BatteryNs::Pylontech
diff --git a/src/PylontechCanReceiver.cpp b/src/battery/pylontech/Provider.cpp
similarity index 96%
rename from src/PylontechCanReceiver.cpp
rename to src/battery/pylontech/Provider.cpp
index 4be3d44ac..b5d04ab48 100644
--- a/src/PylontechCanReceiver.cpp
+++ b/src/battery/pylontech/Provider.cpp
@@ -1,17 +1,18 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include "PylontechCanReceiver.h"
-#include "MessageOutput.h"
-#include "PinMapping.h"
+#include <battery/pylontech/Provider.h>
+#include <MessageOutput.h>
+#include <PinMapping.h>
 #include <driver/twai.h>
 #include <ctime>
 
-bool PylontechCanReceiver::init(bool verboseLogging)
+namespace BatteryNs::Pylontech {
+
+bool Provider::init(bool verboseLogging)
 {
-    return BatteryCanReceiver::init(verboseLogging, "Pylontech");
+    return ::BatteryNs::CanReceiver::init(verboseLogging, "Pylontech");
 }
 
-
-void PylontechCanReceiver::onMessage(twai_message_t rx_message)
+void Provider::onMessage(twai_message_t rx_message)
 {
     switch (rx_message.identifier) {
         case 0x351: {
@@ -145,7 +146,7 @@ void PylontechCanReceiver::onMessage(twai_message_t rx_message)
 
 // Currently not called because there is no nice way to integrate it right now
 #ifdef PYLONTECH_DUMMY
-void PylontechCanReceiver::dummyData()
+void Provider::dummyData()
 {
     static uint32_t lastUpdate = millis();
     static uint8_t issues = 0;
@@ -223,3 +224,5 @@ void PylontechCanReceiver::dummyData()
     issues = (issues + 1) % 5;
 }
 #endif
+
+} // namespace BatteryNs::Pylontech
diff --git a/src/battery/pylontech/Stats.cpp b/src/battery/pylontech/Stats.cpp
new file mode 100644
index 000000000..52ce65522
--- /dev/null
+++ b/src/battery/pylontech/Stats.cpp
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <MqttSettings.h>
+#include <battery/pylontech/Stats.h>
+
+namespace BatteryNs::Pylontech {
+
+void Stats::getLiveViewData(JsonVariant& root) const
+{
+    ::BatteryNs::Stats::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, "dischargeVoltageLimitation", _dischargeVoltageLimitation, "V", 1);
+    addLiveViewValue(root, "stateOfHealth", _stateOfHealth, "%", 0);
+    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
+    addLiveViewValue(root, "modules", _moduleCount, "", 0);
+
+    addLiveViewTextValue(root, "chargeEnabled", (_chargeEnabled?"yes":"no"));
+    addLiveViewTextValue(root, "dischargeEnabled", (_dischargeEnabled?"yes":"no"));
+    addLiveViewTextValue(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 Stats::mqttPublish() const
+{
+    ::BatteryNs::Stats::mqttPublish();
+
+    MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltage));
+    MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimitation));
+    MqttSettings.publish("battery/settings/dischargeVoltageLimitation", String(_dischargeVoltageLimitation));
+    MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
+    MqttSettings.publish("battery/temperature", String(_temperature));
+    MqttSettings.publish("battery/alarm/overCurrentDischarge", String(_alarmOverCurrentDischarge));
+    MqttSettings.publish("battery/alarm/overCurrentCharge", String(_alarmOverCurrentCharge));
+    MqttSettings.publish("battery/alarm/underTemperature", String(_alarmUnderTemperature));
+    MqttSettings.publish("battery/alarm/overTemperature", String(_alarmOverTemperature));
+    MqttSettings.publish("battery/alarm/underVoltage", String(_alarmUnderVoltage));
+    MqttSettings.publish("battery/alarm/overVoltage", String(_alarmOverVoltage));
+    MqttSettings.publish("battery/alarm/bmsInternal", String(_alarmBmsInternal));
+    MqttSettings.publish("battery/warning/highCurrentDischarge", String(_warningHighCurrentDischarge));
+    MqttSettings.publish("battery/warning/highCurrentCharge", String(_warningHighCurrentCharge));
+    MqttSettings.publish("battery/warning/lowTemperature", String(_warningLowTemperature));
+    MqttSettings.publish("battery/warning/highTemperature", String(_warningHighTemperature));
+    MqttSettings.publish("battery/warning/lowVoltage", String(_warningLowVoltage));
+    MqttSettings.publish("battery/warning/highVoltage", String(_warningHighVoltage));
+    MqttSettings.publish("battery/warning/bmsInternal", String(_warningBmsInternal));
+    MqttSettings.publish("battery/charging/chargeEnabled", String(_chargeEnabled));
+    MqttSettings.publish("battery/charging/dischargeEnabled", String(_dischargeEnabled));
+    MqttSettings.publish("battery/charging/chargeImmediately", String(_chargeImmediately));
+    MqttSettings.publish("battery/modulesTotal", String(_moduleCount));
+}
+
+} // namespace BatteryNs::Pylontech
diff --git a/src/battery/pytes/HassIntegration.cpp b/src/battery/pytes/HassIntegration.cpp
new file mode 100644
index 000000000..8e18b33bd
--- /dev/null
+++ b/src/battery/pytes/HassIntegration.cpp
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/pytes/HassIntegration.h>
+
+namespace BatteryNs::Pytes {
+
+void HassIntegration::publishSensors() const
+{
+    ::BatteryNs::HassIntegration::publishSensors();
+
+    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");
+    publishSensor("Discharge voltage limit", NULL, "settings/dischargeVoltageLimitation", "voltage", "measurement", "V");
+
+    publishSensor("Voltage", "mdi:battery-charging", "voltage", "voltage", "measurement", "V");
+    publishSensor("Current", "mdi:current-dc", "current", "current", "measurement", "A");
+    publishSensor("State of Health (SOH)", "mdi:heart-plus", "stateOfHealth", NULL, "measurement", "%");
+    publishSensor("Temperature", "mdi:thermometer", "temperature", "temperature", "measurement", "°C");
+    publishSensor("Charge Cycles", "mdi:counter", "chargeCycles");
+
+    publishSensor("Charged Energy", NULL, "chargedEnergy", "energy", "total_increasing", "kWh");
+    publishSensor("Discharged Energy", NULL, "dischargedEnergy", "energy", "total_increasing", "kWh");
+
+    publishSensor("Total Capacity", NULL, "capacity");
+    publishSensor("Available Capacity", NULL, "availableCapacity");
+
+    publishSensor("Cell Min Voltage", NULL, "CellMinMilliVolt", "voltage", "measurement", "mV");
+    publishSensor("Cell Max Voltage", NULL, "CellMaxMilliVolt", "voltage", "measurement", "mV");
+    publishSensor("Cell Voltage Diff", "mdi:battery-alert", "CellDiffMilliVolt", "voltage", "measurement", "mV");
+    publishSensor("Cell Min Temperature", NULL, "CellMinTemperature", "temperature", "measurement", "°C");
+    publishSensor("Cell Max Temperature", NULL, "CellMaxTemperature", "temperature", "measurement", "°C");
+
+    publishSensor("Cell Min Voltage Label", NULL, "CellMinVoltageName");
+    publishSensor("Cell Max Voltage Label", NULL, "CellMaxVoltageName");
+    publishSensor("Cell Min Temperature Label", NULL, "CellMinTemperatureName");
+    publishSensor("Cell Max Temperature Label", NULL, "CellMaxTemperatureName");
+
+    publishSensor("Modules Online", "mdi:counter", "modulesOnline");
+    publishSensor("Modules Offline", "mdi:counter", "modulesOffline");
+    publishSensor("Modules Blocking Charge", "mdi:counter", "modulesBlockingCharge");
+    publishSensor("Modules Blocking Discharge", "mdi:counter", "modulesBlockingDischarge");
+
+    publishBinarySensor("Alarm Discharge current", "mdi:alert", "alarm/overCurrentDischarge", "1", "0");
+    publishBinarySensor("Alarm High charge current", "mdi:alert", "alarm/overCurrentCharge", "1", "0");
+    publishBinarySensor("Alarm Voltage low", "mdi:alert", "alarm/underVoltage", "1", "0");
+    publishBinarySensor("Alarm Voltage high", "mdi:alert", "alarm/overVoltage", "1", "0");
+    publishBinarySensor("Alarm Temperature low", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
+    publishBinarySensor("Alarm Temperature high", "mdi:thermometer-high", "alarm/overTemperature", "1", "0");
+    publishBinarySensor("Alarm Temperature low (charge)", "mdi:thermometer-low", "alarm/underTemperatureCharge", "1", "0");
+    publishBinarySensor("Alarm Temperature high (charge)", "mdi:thermometer-high", "alarm/overTemperatureCharge", "1", "0");
+    publishBinarySensor("Alarm BMS internal", "mdi:alert", "alarm/bmsInternal", "1", "0");
+    publishBinarySensor("Alarm Cell Imbalance", "mdi:alert-outline", "alarm/cellImbalance", "1", "0");
+
+    publishBinarySensor("Warning Discharge current", "mdi:alert-outline", "warning/highCurrentDischarge", "1", "0");
+    publishBinarySensor("Warning High charge current", "mdi:alert-outline", "warning/highCurrentCharge", "1", "0");
+    publishBinarySensor("Warning Voltage low", "mdi:alert-outline", "warning/lowVoltage", "1", "0");
+    publishBinarySensor("Warning Voltage high", "mdi:alert-outline", "warning/highVoltage", "1", "0");
+    publishBinarySensor("Warning Temperature low", "mdi:thermometer-low", "warning/lowTemperature", "1", "0");
+    publishBinarySensor("Warning Temperature high", "mdi:thermometer-high", "warning/highTemperature", "1", "0");
+    publishBinarySensor("Warning Temperature low (charge)", "mdi:thermometer-low", "warning/lowTemperatureCharge", "1", "0");
+    publishBinarySensor("Warning Temperature high (charge)", "mdi:thermometer-high", "warning/highTemperatureCharge", "1", "0");
+    publishBinarySensor("Warning BMS internal", "mdi:alert-outline", "warning/bmsInternal", "1", "0");
+    publishBinarySensor("Warning Cell Imbalance", "mdi:alert-outline", "warning/cellImbalance", "1", "0");
+
+    publishBinarySensor("Balancing Active", "mdi:scale-balance", "balancingActive", "1", "0");
+    publishBinarySensor("Charge immediately", "mdi:alert", "charging/chargeImmediately", "1", "0");
+}
+
+} // namespace BatteryNs::Pytes
diff --git a/src/PytesCanReceiver.cpp b/src/battery/pytes/Provider.cpp
similarity index 98%
rename from src/PytesCanReceiver.cpp
rename to src/battery/pytes/Provider.cpp
index 069f84608..615179f1b 100644
--- a/src/PytesCanReceiver.cpp
+++ b/src/battery/pytes/Provider.cpp
@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include "PytesCanReceiver.h"
-#include "MessageOutput.h"
-#include "PinMapping.h"
+#include <battery/pytes/Provider.h>
+#include <MessageOutput.h>
+#include <PinMapping.h>
 #include <driver/twai.h>
 #include <ctime>
 
-namespace {
+namespace BatteryNs::Pytes {
 
 static void pytesSetCellLabel(String& label, uint16_t value) {
     char name[8];
@@ -20,14 +20,12 @@ static uint32_t popCount(uint32_t val) {
     return cnt;
 }
 
-};  // namespace
-
-bool PytesCanReceiver::init(bool verboseLogging)
+bool Provider::init(bool verboseLogging)
 {
-    return BatteryCanReceiver::init(verboseLogging, "Pytes");
+    return ::BatteryNs::CanReceiver::init(verboseLogging, "Pytes");
 }
 
-void PytesCanReceiver::onMessage(twai_message_t rx_message)
+void Provider::onMessage(twai_message_t rx_message)
 {
     switch (rx_message.identifier) {
         case 0x351:
@@ -493,3 +491,5 @@ void PytesCanReceiver::onMessage(twai_message_t rx_message)
 
     _stats->setLastUpdate(millis());
 }
+
+} // namespace BatteryNs::Pytes
diff --git a/src/battery/pytes/Stats.cpp b/src/battery/pytes/Stats.cpp
new file mode 100644
index 000000000..b51bf5455
--- /dev/null
+++ b/src/battery/pytes/Stats.cpp
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <MqttSettings.h>
+#include <battery/pytes/Stats.h>
+
+namespace BatteryNs::Pytes {
+
+void Stats::getLiveViewData(JsonVariant& root) const
+{
+    ::BatteryNs::Stats::getLiveViewData(root);
+
+    // values go into the "Status" card of the web application
+    addLiveViewValue(root, "chargeVoltage", _chargeVoltageLimit, "V", 1);
+    addLiveViewValue(root, "chargeCurrentLimitation", _chargeCurrentLimit, "A", 1);
+    addLiveViewValue(root, "dischargeVoltageLimitation", _dischargeVoltageLimit, "V", 1);
+    addLiveViewValue(root, "stateOfHealth", _stateOfHealth, "%", 0);
+    if (_chargeCycles != -1) {
+        addLiveViewValue(root, "chargeCycles", _chargeCycles, "", 0);
+    }
+    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
+
+    addLiveViewValue(root, "capacity", _totalCapacity, "Ah", _capacityPrecision);
+    addLiveViewValue(root, "availableCapacity", _availableCapacity, "Ah", _capacityPrecision);
+
+    if (_chargedEnergy != -1) {
+        addLiveViewValue(root, "chargedEnergy", _chargedEnergy, "kWh", 1);
+    }
+
+    if (_dischargedEnergy != -1) {
+        addLiveViewValue(root, "dischargedEnergy", _dischargedEnergy, "kWh", 1);
+    }
+    addLiveViewTextValue(root, "chargeImmediately", (_chargeImmediately?"yes":"no"));
+
+    if (_balance != -1) {
+        addLiveViewTextValue(root, "balancingActive", (_balance?"yes":"no"));
+    }
+
+    addLiveViewInSection(root, "cells", "cellMinVoltage", static_cast<float>(_cellMinMilliVolt)/1000, "V", 3);
+    addLiveViewInSection(root, "cells", "cellMaxVoltage", static_cast<float>(_cellMaxMilliVolt)/1000, "V", 3);
+    addLiveViewInSection(root, "cells", "cellDiffVoltage", (_cellMaxMilliVolt - _cellMinMilliVolt), "mV", 0);
+    addLiveViewInSection(root, "cells", "cellMinTemperature", _cellMinTemperature, "°C", 0);
+    addLiveViewInSection(root, "cells", "cellMaxTemperature", _cellMaxTemperature, "°C", 0);
+
+    addLiveViewTextInSection(root, "cells", "cellMinVoltageName", _cellMinVoltageName.c_str(), false);
+    addLiveViewTextInSection(root, "cells", "cellMaxVoltageName", _cellMaxVoltageName.c_str(), false);
+    addLiveViewTextInSection(root, "cells", "cellMinTemperatureName", _cellMinTemperatureName.c_str(), false);
+    addLiveViewTextInSection(root, "cells", "cellMaxTemperatureName", _cellMaxTemperatureName.c_str(), false);
+
+    addLiveViewInSection(root, "modules", "online", _moduleCountOnline, "", 0);
+    addLiveViewInSection(root, "modules", "offline", _moduleCountOffline, "", 0);
+    addLiveViewInSection(root, "modules", "blockingCharge", _moduleCountBlockingCharge, "", 0);
+    addLiveViewInSection(root, "modules", "blockingDischarge", _moduleCountBlockingDischarge, "", 0);
+
+    // alarms and warnings go into the "Issues" card of the web application
+    addLiveViewWarning(root, "highCurrentDischarge", _warningHighDischargeCurrent);
+    addLiveViewAlarm(root, "overCurrentDischarge", _alarmOverCurrentDischarge);
+
+    addLiveViewWarning(root, "highCurrentCharge", _warningHighChargeCurrent);
+    addLiveViewAlarm(root, "overCurrentCharge", _alarmOverCurrentCharge);
+
+    addLiveViewWarning(root, "lowVoltage", _warningLowVoltage);
+    addLiveViewAlarm(root, "underVoltage", _alarmUnderVoltage);
+
+    addLiveViewWarning(root, "highVoltage", _warningHighVoltage);
+    addLiveViewAlarm(root, "overVoltage", _alarmOverVoltage);
+
+    addLiveViewWarning(root, "lowTemperature", _warningLowTemperature);
+    addLiveViewAlarm(root, "underTemperature", _alarmUnderTemperature);
+
+    addLiveViewWarning(root, "highTemperature", _warningHighTemperature);
+    addLiveViewAlarm(root, "overTemperature", _alarmOverTemperature);
+
+    addLiveViewWarning(root, "lowTemperatureCharge", _warningLowTemperatureCharge);
+    addLiveViewAlarm(root, "underTemperatureCharge", _alarmUnderTemperatureCharge);
+
+    addLiveViewWarning(root, "highTemperatureCharge", _warningHighTemperatureCharge);
+    addLiveViewAlarm(root, "overTemperatureCharge", _alarmOverTemperatureCharge);
+
+    addLiveViewWarning(root, "bmsInternal", _warningInternalFailure);
+    addLiveViewAlarm(root, "bmsInternal", _alarmInternalFailure);
+
+    addLiveViewWarning(root, "cellDiffVoltage", _warningCellImbalance);
+    addLiveViewAlarm(root, "cellDiffVoltage", _alarmCellImbalance);
+}
+
+void Stats::mqttPublish() const
+{
+    ::BatteryNs::Stats::mqttPublish();
+
+    MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltageLimit));
+    MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimit));
+    MqttSettings.publish("battery/settings/dischargeVoltageLimitation", String(_dischargeVoltageLimit));
+
+    MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
+    if (_chargeCycles != -1) {
+        MqttSettings.publish("battery/chargeCycles", String(_chargeCycles));
+    }
+    if (_balance != -1) {
+        MqttSettings.publish("battery/balancingActive", String(_balance ? 1 : 0));
+    }
+    MqttSettings.publish("battery/temperature", String(_temperature));
+
+    if (_chargedEnergy != -1) {
+        MqttSettings.publish("battery/chargedEnergy", String(_chargedEnergy));
+    }
+
+    if (_dischargedEnergy != -1) {
+        MqttSettings.publish("battery/dischargedEnergy", String(_dischargedEnergy));
+    }
+
+    MqttSettings.publish("battery/capacity", String(_totalCapacity));
+    MqttSettings.publish("battery/availableCapacity", String(_availableCapacity));
+
+    MqttSettings.publish("battery/CellMinMilliVolt", String(_cellMinMilliVolt));
+    MqttSettings.publish("battery/CellMaxMilliVolt", String(_cellMaxMilliVolt));
+    MqttSettings.publish("battery/CellDiffMilliVolt", String(_cellMaxMilliVolt - _cellMinMilliVolt));
+    MqttSettings.publish("battery/CellMinTemperature", String(_cellMinTemperature));
+    MqttSettings.publish("battery/CellMaxTemperature", String(_cellMaxTemperature));
+    MqttSettings.publish("battery/CellMinVoltageName", String(_cellMinVoltageName));
+    MqttSettings.publish("battery/CellMaxVoltageName", String(_cellMaxVoltageName));
+    MqttSettings.publish("battery/CellMinTemperatureName", String(_cellMinTemperatureName));
+    MqttSettings.publish("battery/CellMaxTemperatureName", String(_cellMaxTemperatureName));
+
+    MqttSettings.publish("battery/modulesOnline", String(_moduleCountOnline));
+    MqttSettings.publish("battery/modulesOffline", String(_moduleCountOffline));
+    MqttSettings.publish("battery/modulesBlockingCharge", String(_moduleCountBlockingCharge));
+    MqttSettings.publish("battery/modulesBlockingDischarge", String(_moduleCountBlockingDischarge));
+
+    MqttSettings.publish("battery/alarm/overCurrentDischarge", String(_alarmOverCurrentDischarge));
+    MqttSettings.publish("battery/alarm/overCurrentCharge", String(_alarmOverCurrentCharge));
+    MqttSettings.publish("battery/alarm/underVoltage", String(_alarmUnderVoltage));
+    MqttSettings.publish("battery/alarm/overVoltage", String(_alarmOverVoltage));
+    MqttSettings.publish("battery/alarm/underTemperature", String(_alarmUnderTemperature));
+    MqttSettings.publish("battery/alarm/overTemperature", String(_alarmOverTemperature));
+    MqttSettings.publish("battery/alarm/underTemperatureCharge", String(_alarmUnderTemperatureCharge));
+    MqttSettings.publish("battery/alarm/overTemperatureCharge", String(_alarmOverTemperatureCharge));
+    MqttSettings.publish("battery/alarm/bmsInternal", String(_alarmInternalFailure));
+    MqttSettings.publish("battery/alarm/cellImbalance", String(_alarmCellImbalance));
+
+    MqttSettings.publish("battery/warning/highCurrentDischarge", String(_warningHighDischargeCurrent));
+    MqttSettings.publish("battery/warning/highCurrentCharge", String(_warningHighChargeCurrent));
+    MqttSettings.publish("battery/warning/lowVoltage", String(_warningLowVoltage));
+    MqttSettings.publish("battery/warning/highVoltage", String(_warningHighVoltage));
+    MqttSettings.publish("battery/warning/lowTemperature", String(_warningLowTemperature));
+    MqttSettings.publish("battery/warning/highTemperature", String(_warningHighTemperature));
+    MqttSettings.publish("battery/warning/lowTemperatureCharge", String(_warningLowTemperatureCharge));
+    MqttSettings.publish("battery/warning/highTemperatureCharge", String(_warningHighTemperatureCharge));
+    MqttSettings.publish("battery/warning/bmsInternal", String(_warningInternalFailure));
+    MqttSettings.publish("battery/warning/cellImbalance", String(_warningCellImbalance));
+
+    MqttSettings.publish("battery/charging/chargeImmediately", String(_chargeImmediately));
+}
+
+} // namespace BatteryNs::Pytes
diff --git a/src/battery/sbs/HassIntegration.cpp b/src/battery/sbs/HassIntegration.cpp
new file mode 100644
index 000000000..dafdf76f0
--- /dev/null
+++ b/src/battery/sbs/HassIntegration.cpp
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/sbs/HassIntegration.h>
+
+namespace BatteryNs::SBS {
+
+void HassIntegration::publishSensors() const
+{
+    ::BatteryNs::HassIntegration::publishSensors();
+
+    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 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("Warning Discharge current", "mdi:alert-outline", "warning/highCurrentDischarge", "1", "0");
+
+    publishBinarySensor("Alarm Temperature low", "mdi:thermometer-low", "alarm/underTemperature", "1", "0");
+
+    publishBinarySensor("Alarm Temperature high", "mdi:thermometer-high", "alarm/overTemperature", "1", "0");
+
+    publishBinarySensor("Alarm Voltage low", "mdi:alert", "alarm/underVoltage", "1", "0");
+
+    publishBinarySensor("Alarm Voltage high", "mdi:alert", "alarm/overVoltage", "1", "0");
+
+    publishBinarySensor("Alarm BMS internal", "mdi:alert", "alarm/bmsInternal", "1", "0");
+
+    publishBinarySensor("Warning High charge current", "mdi:alert-outline", "warning/highCurrentCharge", "1", "0");
+
+    publishBinarySensor("Charge enabled", "mdi:battery-arrow-up", "charging/chargeEnabled", "1", "0");
+    publishBinarySensor("Discharge enabled", "mdi:battery-arrow-down", "charging/dischargeEnabled", "1", "0");
+}
+
+} // namespace BatteryNs::SBS
diff --git a/src/SBSCanReceiver.cpp b/src/battery/sbs/Provider.cpp
similarity index 94%
rename from src/SBSCanReceiver.cpp
rename to src/battery/sbs/Provider.cpp
index 9d225d21c..6769aa416 100644
--- a/src/SBSCanReceiver.cpp
+++ b/src/battery/sbs/Provider.cpp
@@ -1,18 +1,19 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include "SBSCanReceiver.h"
-#include "MessageOutput.h"
-#include "PinMapping.h"
+#include <battery/sbs/Provider.h>
+#include <MessageOutput.h>
+#include <PinMapping.h>
 #include <driver/twai.h>
 #include <ctime>
 
-bool SBSCanReceiver::init(bool verboseLogging)
+namespace BatteryNs::SBS {
+
+bool Provider::init(bool verboseLogging)
 {
     _stats->_chargeVoltage =58.4;
-    return BatteryCanReceiver::init(verboseLogging, "SBS");
+    return ::BatteryNs::CanReceiver::init(verboseLogging, "SBS");
 }
 
-
-void SBSCanReceiver::onMessage(twai_message_t rx_message)
+void Provider::onMessage(twai_message_t rx_message)
 {
     switch (rx_message.identifier) {
         case 0x610: {
@@ -126,7 +127,7 @@ void SBSCanReceiver::onMessage(twai_message_t rx_message)
 }
 
 #ifdef SBSCanReceiver_DUMMY
-void SBSCanReceiver::dummyData()
+void Provider::dummyData()
 {
     static uint32_t lastUpdate = millis();
     static uint8_t issues = 0;
@@ -183,3 +184,5 @@ void SBSCanReceiver::dummyData()
     issues = (issues + 1) % 5;
 }
 #endif
+
+} // namespace BatteryNs::SBS
diff --git a/src/battery/sbs/Stats.cpp b/src/battery/sbs/Stats.cpp
new file mode 100644
index 000000000..fdabe7f91
--- /dev/null
+++ b/src/battery/sbs/Stats.cpp
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <MqttSettings.h>
+#include <battery/sbs/Stats.h>
+
+namespace BatteryNs::SBS {
+
+void Stats::getLiveViewData(JsonVariant& root) const
+{
+    ::BatteryNs::Stats::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, "stateOfHealth", _stateOfHealth, "%", 0);
+    addLiveViewValue(root, "current", _current, "A", 1);
+    addLiveViewValue(root, "temperature", _temperature, "°C", 1);
+    addLiveViewTextValue(root, "chargeEnabled", (_chargeEnabled?"yes":"no"));
+    addLiveViewTextValue(root, "dischargeEnabled", (_dischargeEnabled?"yes":"no"));
+
+    // alarms and warnings go into the "Issues" card of the web application
+    addLiveViewWarning(root, "highCurrentDischarge", _warningHighCurrentDischarge);
+    addLiveViewWarning(root, "highCurrentCharge", _warningHighCurrentCharge);
+    addLiveViewAlarm(root, "underVoltage", _alarmUnderVoltage);
+    addLiveViewAlarm(root, "overVoltage", _alarmOverVoltage);
+    addLiveViewAlarm(root, "bmsInternal", _alarmBmsInternal);
+    addLiveViewAlarm(root, "underTemperature", _alarmUnderTemperature);
+    addLiveViewAlarm(root, "overTemperature", _alarmOverTemperature);
+}
+
+void Stats::mqttPublish() const
+{
+    ::BatteryNs::Stats::mqttPublish();
+
+    MqttSettings.publish("battery/settings/chargeVoltage", String(_chargeVoltage));
+    MqttSettings.publish("battery/settings/chargeCurrentLimitation", String(_chargeCurrentLimitation));
+    MqttSettings.publish("battery/stateOfHealth", String(_stateOfHealth));
+    MqttSettings.publish("battery/current", String(_current));
+    MqttSettings.publish("battery/temperature", String(_temperature));
+    MqttSettings.publish("battery/alarm/underVoltage", String(_alarmUnderVoltage));
+    MqttSettings.publish("battery/alarm/overVoltage", String(_alarmOverVoltage));
+    MqttSettings.publish("battery/alarm/bmsInternal", String(_alarmBmsInternal));
+    MqttSettings.publish("battery/warning/highCurrentDischarge", String(_warningHighCurrentDischarge));
+    MqttSettings.publish("battery/warning/highCurrentCharge", String(_warningHighCurrentCharge));
+    MqttSettings.publish("battery/charging/chargeEnabled", String(_chargeEnabled));
+    MqttSettings.publish("battery/charging/dischargeEnabled", String(_dischargeEnabled));
+}
+
+} // namespace BatteryNs::SBS
diff --git a/src/battery/victronsmartshunt/HassIntegration.cpp b/src/battery/victronsmartshunt/HassIntegration.cpp
new file mode 100644
index 000000000..e2a2a1edb
--- /dev/null
+++ b/src/battery/victronsmartshunt/HassIntegration.cpp
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <battery/victronsmartshunt/HassIntegration.h>
+
+namespace BatteryNs::VictronSmartShunt {
+
+void HassIntegration::publishSensors() const
+{
+    ::BatteryNs::HassIntegration::publishSensors();
+
+    publishSensor("Voltage", "mdi:battery-charging", "voltage", "voltage", "measurement", "V");
+    publishSensor("Current", "mdi:current-dc", "current", "current", "measurement", "A");
+    publishSensor("Instantaneous Power", NULL, "instantaneousPower", "power", "measurement", "W");
+    publishSensor("Charged Energy", NULL, "chargedEnergy", "energy", "total_increasing", "kWh");
+    publishSensor("Discharged Energy", NULL, "dischargedEnergy", "energy", "total_increasing", "kWh");
+    publishSensor("Charge Cycles", "mdi:counter", "chargeCycles");
+    publishSensor("Consumed Amp Hours", NULL, "consumedAmpHours", NULL, "measurement", "Ah");
+    publishSensor("Last Full Charge", "mdi:timelapse", "lastFullCharge", NULL, NULL, "min");
+    publishSensor("Midpoint Voltage", NULL, "midpointVoltage", "voltage", "measurement", "V");
+    publishSensor("Midpoint Deviation", NULL, "midpointDeviation", "battery", "measurement", "%");
+}
+
+} // namespace BatteryNs::VictronSmartShunt
diff --git a/src/VictronSmartShunt.cpp b/src/battery/victronsmartshunt/Provider.cpp
similarity index 76%
rename from src/VictronSmartShunt.cpp
rename to src/battery/victronsmartshunt/Provider.cpp
index c64f9a83a..01db9d475 100644
--- a/src/VictronSmartShunt.cpp
+++ b/src/battery/victronsmartshunt/Provider.cpp
@@ -1,16 +1,17 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
-#include "VictronSmartShunt.h"
-#include "Configuration.h"
-#include "PinMapping.h"
-#include "MessageOutput.h"
-#include "SerialPortManager.h"
+#include <battery/victronsmartshunt/Provider.h>
+#include <PinMapping.h>
+#include <MessageOutput.h>
+#include <SerialPortManager.h>
 
-void VictronSmartShunt::deinit()
+namespace BatteryNs::VictronSmartShunt {
+
+void Provider::deinit()
 {
     SerialPortManager.freePort(_serialPortOwner);
 }
 
-bool VictronSmartShunt::init(bool verboseLogging)
+bool Provider::init(bool verboseLogging)
 {
     MessageOutput.println("[VictronSmartShunt] Initialize interface...");
 
@@ -33,7 +34,7 @@ bool VictronSmartShunt::init(bool verboseLogging)
     return true;
 }
 
-void VictronSmartShunt::loop()
+void Provider::loop()
 {
     VeDirectShunt.loop();
 
@@ -42,3 +43,5 @@ void VictronSmartShunt::loop()
     _stats->updateFrom(VeDirectShunt.getData());
     _lastUpdate = VeDirectShunt.getLastUpdate();
 }
+
+} // namespace BatteryNs::VictronSmartShunt
diff --git a/src/battery/victronsmartshunt/Stats.cpp b/src/battery/victronsmartshunt/Stats.cpp
new file mode 100644
index 000000000..dffaa8987
--- /dev/null
+++ b/src/battery/victronsmartshunt/Stats.cpp
@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include <MqttSettings.h>
+#include <battery/victronsmartshunt/Stats.h>
+
+namespace BatteryNs::VictronSmartShunt {
+
+void Stats::updateFrom(VeDirectShuntController::data_t const& shuntData) {
+    ::BatteryNs::Stats::setVoltage(shuntData.batteryVoltage_V_mV / 1000.0, millis());
+    ::BatteryNs::Stats::setSoC(static_cast<float>(shuntData.SOC) / 10, 1/*precision*/, millis());
+    ::BatteryNs::Stats::setCurrent(static_cast<float>(shuntData.batteryCurrent_I_mA) / 1000, 2/*precision*/, millis());
+    _fwversion = shuntData.getFwVersionFormatted();
+
+    _chargeCycles = shuntData.H4;
+    _timeToGo = shuntData.TTG / 60;
+    _chargedEnergy = static_cast<float>(shuntData.H18) / 100;
+    _dischargedEnergy = static_cast<float>(shuntData.H17) / 100;
+    setManufacturer(String("Victron ") + shuntData.getPidAsString().data());
+    _temperature = shuntData.T;
+    _tempPresent = shuntData.tempPresent;
+    _midpointVoltage = static_cast<float>(shuntData.VM) / 1000;
+    _midpointDeviation = static_cast<float>(shuntData.DM) / 10;
+    _instantaneousPower = shuntData.P;
+    _consumedAmpHours = static_cast<float>(shuntData.CE) / 1000;
+    _lastFullCharge = shuntData.H9 / 60;
+    // shuntData.AR is a bitfield, so we need to check each bit individually
+    _alarmLowVoltage = shuntData.alarmReason_AR & 1;
+    _alarmHighVoltage = shuntData.alarmReason_AR & 2;
+    _alarmLowSOC = shuntData.alarmReason_AR & 4;
+    _alarmLowTemperature = shuntData.alarmReason_AR & 32;
+    _alarmHighTemperature = shuntData.alarmReason_AR & 64;
+
+    _lastUpdate = VeDirectShunt.getLastUpdate();
+}
+
+void Stats::getLiveViewData(JsonVariant& root) const {
+    ::BatteryNs::Stats::getLiveViewData(root);
+
+    // values go into the "Status" card of the web application
+    addLiveViewValue(root, "chargeCycles", _chargeCycles, "", 0);
+    addLiveViewValue(root, "chargedEnergy", _chargedEnergy, "kWh", 2);
+    addLiveViewValue(root, "dischargedEnergy", _dischargedEnergy, "kWh", 2);
+    addLiveViewValue(root, "instantaneousPower", _instantaneousPower, "W", 0);
+    addLiveViewValue(root, "consumedAmpHours", _consumedAmpHours, "Ah", 3);
+    addLiveViewValue(root, "midpointVoltage", _midpointVoltage, "V", 2);
+    addLiveViewValue(root, "midpointDeviation", _midpointDeviation, "%", 1);
+    addLiveViewValue(root, "lastFullCharge", _lastFullCharge, "min", 0);
+    if (_tempPresent) {
+        addLiveViewValue(root, "temperature", _temperature, "°C", 0);
+    }
+
+    addLiveViewAlarm(root, "lowVoltage", _alarmLowVoltage);
+    addLiveViewAlarm(root, "highVoltage", _alarmHighVoltage);
+    addLiveViewAlarm(root, "lowSOC", _alarmLowSOC);
+    addLiveViewAlarm(root, "lowTemperature", _alarmLowTemperature);
+    addLiveViewAlarm(root, "highTemperature", _alarmHighTemperature);
+}
+
+void Stats::mqttPublish() const {
+    ::BatteryNs::Stats::mqttPublish();
+
+    MqttSettings.publish("battery/chargeCycles", String(_chargeCycles));
+    MqttSettings.publish("battery/chargedEnergy", String(_chargedEnergy));
+    MqttSettings.publish("battery/dischargedEnergy", String(_dischargedEnergy));
+    MqttSettings.publish("battery/instantaneousPower", String(_instantaneousPower));
+    MqttSettings.publish("battery/consumedAmpHours", String(_consumedAmpHours));
+    MqttSettings.publish("battery/lastFullCharge", String(_lastFullCharge));
+    MqttSettings.publish("battery/midpointVoltage", String(_midpointVoltage));
+    MqttSettings.publish("battery/midpointDeviation", String(_midpointDeviation));
+}
+
+} // namespace BatteryNs::VictronSmartShunt
diff --git a/src/main.cpp b/src/main.cpp
index 9a4ac2506..8cba649fa 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -11,12 +11,11 @@
 #include "MessageOutput.h"
 #include "SerialPortManager.h"
 #include "VictronMppt.h"
-#include "Battery.h"
+#include <battery/Controller.h>
 #include "Huawei_can.h"
 #include "MqttHandleDtu.h"
 #include "MqttHandleHass.h"
 #include "MqttHandleVedirectHass.h"
-#include "MqttHandleBatteryHass.h"
 #include "MqttHandleInverter.h"
 #include "MqttHandleInverterTotal.h"
 #include "MqttHandleVedirect.h"
@@ -139,7 +138,6 @@ void setup()
     MqttHandleVedirect.init(scheduler);
     MqttHandleHass.init(scheduler);
     MqttHandleVedirectHass.init(scheduler);
-    MqttHandleBatteryHass.init(scheduler);
     MqttHandleHuawei.init(scheduler);
     MqttHandlePowerLimiter.init(scheduler);
     MqttHandlePowerLimiterHass.init(scheduler);