complete rework of internal structures

Author: vaterlangen

include/Configuration.h

@@ -279,7 +279,7 @@ struct GRID_CHARGER_CONFIG_T {
 };
 using GridChargerConfig = struct GRID_CHARGER_CONFIG_T;
 
-enum SolarChargerProviderType { VEDIRECT = 0, MQTT = 1, SmartBufferBattery = 2 };
+enum SolarChargerProviderType { VEDIRECT = 0, MQTT = 1, Integrated = 2 };
 
 struct SOLARCHARGER_MQTT_CONFIG_T {
     bool CalculateOutputPower;

include/battery/SmartBufferStats.h

@@ -3,46 +3,108 @@
 
 #include <battery/Stats.h>
 #include <solarcharger/Controller.h>
-#include <solarcharger/smartbufferbatteries/Provider.h>
-#include <solarcharger/smartbufferbatteries/Stats.h>
+#include <solarcharger/integrated/Provider.h>
+#include <solarcharger/integrated/Stats.h>
 
 namespace Batteries {
 
 // mandatory interface for all kinds of batteries
 class SmartBufferStats : public Stats {
+
 public:
+    using MPPT = SolarChargers::Integrated::MPPT;
+
     virtual std::optional<String> const& getDeviceName() const = 0;
     virtual size_t getNumberMppts() const = 0;
 
+    inline std::optional<float> getSolarPowerOverall() const {
+        return _solar_power_sum;
+    }
+
+    inline std::optional<float> getSolarPower(const MPPT mppt) const {
+        try {
+            return _solar_power.at(mppt);
+        }
+        catch(const std::out_of_range& ex) {;}
+
+        return std::nullopt;
+    }
+
+    inline std::optional<float> getSolarVoltage(const MPPT mppt) const {
+        try {
+            return _solar_voltage.at(mppt);
+        }
+        catch(const std::out_of_range& ex) {;}
+
+        return std::nullopt;
+    }
+
 protected:
-    void setMpptPower(const size_t mppt, const float power, const uint32_t timestamp = millis())
-    {
-        auto charger = getSolarCharger();
-        if (charger != nullptr) {
-            charger->setMpptPower(_solarcharger_id, mppt, power, timestamp);
+    inline void setSolarPower(const MPPT mppt, const std::optional<float> &power, const uint32_t timestamp = millis()) {
+        if (!power.has_value()) { return; }
+        _solar_power[mppt] = power;
+
+        // update sum value
+        std::optional<float> sum = std::nullopt;
+        for (const auto& [index, power] : _solar_power) {
+            if (!power.has_value()) { continue; }
+            sum = sum.value_or(0) + *power;
         }
+        _solar_power_sum = sum;
+
+        // publish value to SolcarCharger integration
+        auto object = getObject(mppt);
+        if (object == nullptr ) { return; }
+        object->setPower(*power, timestamp);
     }
 
-    void setMpptVoltage(const size_t mppt, const float voltage, const uint32_t timestamp = millis())
+    inline void setSolarVoltage(const MPPT mppt, const std::optional<float> &voltage, const uint32_t timestamp = millis()) {
+        if (!voltage.has_value()) { return; }
+        _solar_voltage[mppt] = voltage;
+
+        // publish value to SolcarCharger integration
+        auto object = getObject(mppt);
+        if (object == nullptr) { return; }
+        object->setVoltage(*voltage, timestamp);
+    }
+
+private:
+    std::shared_ptr<SolarChargers::Integrated::MpptData> getObject(const MPPT mppt)
     {
-        auto charger = getSolarCharger();
-        if (charger != nullptr) {
-            charger->setMpptVoltage(_solarcharger_id, mppt, voltage, timestamp);
+        try {
+            return getObjects().at(mppt);
         }
+        catch(const std::out_of_range& ex) {;}
+
+        return nullptr;
     }
 
-    std::shared_ptr<SolarChargers::SmartBufferBatteries::Stats> getSolarCharger()
+
+    std::map<MPPT, std::shared_ptr<SolarChargers::Integrated::MpptData>> getObjects()
     {
-        auto mppt = SolarCharger.getSmartBufferBatteryStats();
-        if (mppt != nullptr && !mppt->hasDevice(_solarcharger_id)) {
-            _solarcharger_id = mppt->addDevice(getManufacturer(), getDeviceName(), getSerial(), getNumberMppts());
-        }
+        auto mppt = SolarCharger.getIntegratedStats();
+        if (mppt == nullptr) { return {}; }
+
+        if (mppt->hasDevice(_solarcharger_id)) { return _objects; }
+
+        // if device was not found, immediatly clear our cached pointers
+        _objects.clear();
 
-        return mppt;
+        // amd try to re-add our device
+        auto result = mppt->addDevice(getManufacturer(), getDeviceName(), getSerial(), getNumberMppts());
+        if (!result.has_value()) { return {}; }
+
+        _solarcharger_id = (*result).first;
+        _objects = (*result).second->getMppts();
+
+        return _objects;
     }
 
     std::optional<uint32_t> _solarcharger_id = std::nullopt;
-
+    std::optional<float> _solar_power_sum = std::nullopt;
+    std::map<MPPT, std::shared_ptr<SolarChargers::Integrated::MpptData>> _objects = std::map<MPPT, std::shared_ptr<SolarChargers::Integrated::MpptData>>();
+    std::map<MPPT, std::optional<float>> _solar_power = std::map<MPPT, std::optional<float>>();
+    std::map<MPPT, std::optional<float>> _solar_voltage = std::map<MPPT, std::optional<float>>();
 };
 
 } // namespace Batteries

include/battery/zendure/Stats.h

@@ -5,8 +5,8 @@
 #include <battery/SmartBufferStats.h>
 #include <battery/zendure/Constants.h>
 #include <solarcharger/Controller.h>
-#include <solarcharger/smartbufferbatteries/Provider.h>
-#include <solarcharger/smartbufferbatteries/Stats.h>
+#include <solarcharger/integrated/Provider.h>
+#include <solarcharger/integrated/Stats.h>
 #include <map>
 #include <optional>
 #include <Configuration.h>
@@ -141,6 +141,10 @@ class Stats : public ::Batteries::SmartBufferStats {
     virtual std::optional<String> const& getDeviceName() const { return _device; }
     virtual size_t getNumberMppts() const { return ZENDURE_NUM_MPPTS; };
 
+    inline std::optional<float> getInputPower() const {
+        return getSolarPowerOverall();
+    }
+
 protected:
     std::shared_ptr<PackStats> getPackData(size_t index) const;
     std::shared_ptr<PackStats> addPackData(size_t index, String serial);
@@ -189,36 +193,6 @@ class Stats : public ::Batteries::SmartBufferStats {
         _device = std::move(device);
     }
 
-    std::shared_ptr<SolarChargers::SmartBufferBatteries::Stats> getSolarCharger() {
-        auto mppt = SolarCharger.getSmartBufferBatteryStats();
-
-        if (mppt == nullptr) {
-            return nullptr;
-        }
-
-        // Doe we need to add our charger, first?
-        if (!mppt->hasDevice(_solarcharger_id)) {
-            _solarcharger_id = mppt->addDevice(*getManufacturer(), _device, *getSerial(), ZENDURE_NUM_MPPTS);
-        }
-
-        return mppt;
-    }
-
-    inline void updateSolarInputPower(const size_t num, const float power) {
-        _input_power = _solar_power_1 + _solar_power_2;
-        setMpptPower(num, power);
-    }
-
-    inline void setSolarPower1(const uint16_t power) {
-        _solar_power_1 = power;
-        updateSolarInputPower(1, power);
-    }
-
-    inline void setSolarPower2(const uint16_t power) {
-        _solar_power_2 = power;
-        updateSolarInputPower(2, power);
-    }
-
     void setChargePower(const uint16_t power) {
         _charge_power = power;
 
@@ -243,16 +217,6 @@ class Stats : public ::Batteries::SmartBufferStats {
         _output_power = power;
     }
 
-    inline void setSolarVoltage1(const float voltage) {
-        _solar_voltage_1 = voltage;
-        setMpptVoltage(1, voltage);
-    }
-
-    inline void setSolarVoltage2(const float voltage) {
-        _solar_voltage_2 = voltage;
-        setMpptVoltage(2, voltage);
-    }
-
     inline void setOutputVoltage(const float voltage) {
         _output_voltage = voltage;
     }
@@ -281,13 +245,6 @@ class Stats : public ::Batteries::SmartBufferStats {
         _auto_recover = static_cast<bool>(value);
     }
 
-    inline void setVoltage(float voltage, uint32_t timestamp) {
-        if (voltage > 0) {
-            setDischargeCurrentLimit(static_cast<float>(_inverse_max) / voltage, timestamp);
-        }
-        Batteries::Stats::setVoltage(voltage, timestamp);
-    }
-
     std::optional<String> _device = std::nullopt;
 
     std::map<size_t, std::shared_ptr<PackStats>> _packData = std::map<size_t, std::shared_ptr<PackStats> >();
@@ -314,12 +271,7 @@ class Stats : public ::Batteries::SmartBufferStats {
     uint16_t _charge_power = 0;
     uint16_t _discharge_power = 0;
     uint16_t _output_power = 0;
-    uint16_t _input_power = 0;
-    uint16_t _solar_power_1 = 0;
-    uint16_t _solar_power_2 = 0;
 
-    float _solar_voltage_1 = 0.0;
-    float _solar_voltage_2 = 0.0;
     float _output_voltage = 0.0;
 
     uint16_t _charge_power_cycle = 0;

include/solarcharger/Controller.h

@@ -6,8 +6,7 @@
 #include <TaskSchedulerDeclarations.h>
 #include <solarcharger/Provider.h>
 #include <solarcharger/Stats.h>
-#include <solarcharger/smartbufferbatteries/Stats.h>
-
+#include <solarcharger/integrated/Stats.h>
 namespace SolarChargers {
 
 class Controller {
@@ -16,7 +15,7 @@ class Controller {
     void updateSettings();
 
     std::shared_ptr<Stats const> getStats() const;
-    std::shared_ptr<SmartBufferBatteries::Stats> getSmartBufferBatteryStats();
+    std::shared_ptr<Integrated::Stats> getIntegratedStats();
 
 private:
     void loop();

include/solarcharger/smartbufferbatteries/Provider.h renamed to include/solarcharger/integrated/Provider.h

@@ -5,10 +5,10 @@
 #include <memory>
 #include <TaskSchedulerDeclarations.h>
 #include <solarcharger/Provider.h>
-#include <solarcharger/smartbufferbatteries/Stats.h>
+#include <solarcharger/integrated/Stats.h>
 #include <espMqttClient.h>
 
-namespace SolarChargers::SmartBufferBatteries {
+namespace SolarChargers::Integrated {
 
 class Provider : public ::SolarChargers::Provider {
 public:
@@ -19,7 +19,7 @@ class Provider : public ::SolarChargers::Provider {
     void deinit() final { return; };
     void loop() final { return; };
     std::shared_ptr<::SolarChargers::Stats> getStats() const final { return _stats; }
-    std::shared_ptr<Stats> getStats() { return _stats; }
+    //std::shared_ptr<Stats> getStats() { return _stats; }
 
 private:
     Provider(Provider const& other) = delete;
@@ -30,4 +30,4 @@ class Provider : public ::SolarChargers::Provider {
     std::shared_ptr<Stats> _stats = std::make_shared<Stats>();
 };
 
-} // namespace SolarChargers::SmartBufferBatteries
+} // namespace SolarChargers::Integrated