Feature: Victron solarcharger: set battery charge-current-limit

include/Configuration.h

@@ -241,6 +241,12 @@ struct BATTERY_CONFIG_T {
     float DischargeCurrentLimitBelowSoc;
     float DischargeCurrentLimitBelowVoltage;
     bool UseBatteryReportedDischargeCurrentLimit;
+    bool EnableChargeCurrentLimit;
+    float MaxChargeCurrentLimit;
+    float MinChargeCurrentLimit;
+    float ChargeCurrentLimitBelowSoc;
+    float ChargeCurrentLimitBelowVoltage;
+    bool UseBatteryReportedChargeCurrentLimit;
 };
 using BatteryConfig = struct BATTERY_CONFIG_T;
 

include/battery/Controller.h

@@ -15,6 +15,7 @@ class Controller {
     void updateSettings();
 
     float getDischargeCurrentLimit();
+    float getChargeCurrentLimit();
 
     std::shared_ptr<Stats const> getStats() const;
 

include/defaults.h

@@ -158,6 +158,14 @@
 #define BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_SOC 100.0
 #define BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_VOLTAGE 60.0
 #define BATTERY_USE_BATTERY_REPORTED_DISCHARGE_CURRENT_LIMIT false
+
+#define BATTERY_ENABLE_CHARGE_CURRENT_LIMIT false
+#define BATTERY_CHARGE_CURRENT_LIMIT_MIN 0.0
+#define BATTERY_CHARGE_CURRENT_LIMIT_MAX 10.0
+#define BATTERY_CHARGE_CURRENT_LIMIT_BELOW_SOC 100.0
+#define BATTERY_CHARGE_CURRENT_LIMIT_BELOW_VOLTAGE 60.0
+#define BATTERY_USE_BATTERY_REPORTED_CHARGE_CURRENT_LIMIT false
+
 #define BATTERY_ZENDURE_POLLING_INTERVAL 15
 #define BATTERY_ZENDURE_DEVICE 0
 #define BATTERY_ZENDURE_MIN_SOC 7

include/solarcharger/Provider.h

@@ -12,6 +12,7 @@ class Provider {
     virtual bool init() = 0;
     virtual void deinit() = 0;
     virtual void loop() = 0;
+    virtual void setChargeLimit(float limit, float act_charge_current) = 0;
     virtual std::shared_ptr<Stats> getStats() const = 0;
 };
 

include/solarcharger/mqtt/Provider.h

@@ -19,6 +19,7 @@ class Provider : public ::SolarChargers::Provider {
     bool init() final;
     void deinit() final;
     void loop() final { return; } // this class is event-driven
+    void setChargeLimit(float limit, float act_charge_current) final { return; }     // actually the charge-limit isn't used for MQTT. Is there any use-case for that?
     std::shared_ptr<::SolarChargers::Stats> getStats() const final { return _stats; }
 
 private:

include/solarcharger/victron/Provider.h

@@ -18,6 +18,7 @@ class Provider : public ::SolarChargers::Provider {
     bool init() final;
     void deinit() final;
     void loop() final;
+    void setChargeLimit( float limit, float act_charge_current) final;
     std::shared_ptr<::SolarChargers::Stats> getStats() const final { return _stats; }
 
 private:
@@ -31,6 +32,8 @@ class Provider : public ::SolarChargers::Provider {
     std::vector<controller_t> _controllers;
     std::vector<String> _serialPortOwners;
     std::shared_ptr<Stats> _stats = std::make_shared<Stats>();
+    float _chargeLimit { 0.0f };
+    float _chargeCurrent { 0.0f };
 
     bool initController(gpio_num_t rx, gpio_num_t tx, uint8_t instance);
 };

lib/VeDirectFrameHandler/VeDirectData.h

@@ -56,6 +56,8 @@ struct veMpptStruct : veStruct {
     std::pair<uint32_t, uint32_t> NetworkTotalDcInputPowerMilliWatts;
     std::pair<uint32_t, uint32_t> BatteryAbsorptionMilliVolt;
     std::pair<uint32_t, uint32_t> BatteryFloatMilliVolt;
+	std::pair<uint32_t, uint16_t> BatteryMaximumCurrent;
+	std::pair<uint32_t, uint16_t> ChargeCurrentLimit;
     std::pair<uint32_t, uint8_t> NetworkInfo;
     std::pair<uint32_t, uint8_t> NetworkMode;
     std::pair<uint32_t, uint8_t> NetworkStatus;
@@ -145,7 +147,9 @@ enum class VeDirectHexRegister : uint16_t {
     HistoryMPPTD30 = 0x10BE,
     BatteryAbsorptionVoltage = 0xEDF7,
     BatteryFloatVoltage = 0xEDF6,
+    BatteryMaximumCurrent = 0xEDF0,
     TotalChargeCurrent = 0x2013,
+    ChargeCurrentLimit = 0x2015,
     ChargeStateElapsedTime= 0x2007,
     BatteryVoltageSense = 0x2002,
     LoadCurrent = 0xEDAD,

lib/VeDirectFrameHandler/VeDirectMpptController.cpp

@@ -117,6 +117,17 @@ void VeDirectMpptController::frameValidEvent() {
 	}
 }
 
+void VeDirectMpptController::setChargeLimit( float limit )
+{
+    // Victron MPPT needs limit with a resolution of 0.1A
+	if (limit == __FLT_MAX__) {
+		_chargeLimit = 0xFFFF;
+	} else if (limit > 0.0f) {
+		_chargeLimit = static_cast<uint16_t>( limit * 10.0f );
+	} else {
+        _chargeLimit = 0;
+    }
+}
 
 void VeDirectMpptController::loop()
 {
@@ -147,6 +158,8 @@ void VeDirectMpptController::loop()
 	resetTimestamp(_tmpFrame.NetworkTotalDcInputPowerMilliWatts);
 	resetTimestamp(_tmpFrame.BatteryFloatMilliVolt);
 	resetTimestamp(_tmpFrame.BatteryAbsorptionMilliVolt);
+    resetTimestamp(_tmpFrame.BatteryMaximumCurrent);
+    resetTimestamp(_tmpFrame.ChargeCurrentLimit);
 
 #ifdef PROCESS_NETWORK_STATE
 	resetTimestamp(_tmpFrame.NetworkInfo);
@@ -234,6 +247,26 @@ bool VeDirectMpptController::hexDataHandler(VeDirectHexData const &data) {
 			return true;
 			break;
 
+        case VeDirectHexRegister::BatteryMaximumCurrent:
+			_tmpFrame.BatteryMaximumCurrent =
+				{ millis(), static_cast<uint16_t>(data.value) };
+
+			ESP_LOGD(TAG, "%s Hex Data: MPPT Bettery Max Current (0x%04X): %.1fA",
+					_logId, regLog,
+					_tmpFrame.BatteryMaximumCurrent.second / 10.0);
+			return true;
+			break;
+
+		case VeDirectHexRegister::ChargeCurrentLimit:
+			_tmpFrame.ChargeCurrentLimit =
+				{ millis(), static_cast<uint16_t>(data.value) };
+
+			ESP_LOGD(TAG, "%s Hex Data: Charge Current Limit (0x%04X): %.1fA",
+					_logId, regLog,
+					static_cast<float>(_tmpFrame.ChargeCurrentLimit.second) / 10.0);
+			return true;
+			break;
+
 #ifdef PROCESS_NETWORK_STATE
 		case VeDirectHexRegister::NetworkInfo:
 			_tmpFrame.NetworkInfo =
@@ -316,7 +349,14 @@ void VeDirectMpptController::sendNextHexCommandFromQueue(void) {
 					(!prio && (_hexQueue[idx]._readPeriod != HIGH_PRIO_COMMAND))) &&
 					(millisTime - _hexQueue[idx]._lastSendTime) > (_hexQueue[idx]._readPeriod * 1000)) {
 
-					sendHexCommand(VeDirectHexCommand::GET, _hexQueue[idx]._hexRegister);
+					if (_hexQueue[idx]._setCommand)
+					{
+        				sendHexCommand(VeDirectHexCommand::SET, _hexQueue[idx]._hexRegister, _hexQueue[idx]._data, _hexQueue[idx]._dataLength);
+					}
+					else
+					{
+						sendHexCommand(VeDirectHexCommand::GET, _hexQueue[idx]._hexRegister);
+					}
 					_hexQueue[idx]._lastSendTime = millisTime;
 
 					// we need this information to check if we get an answer, see hexDataHandler()

lib/VeDirectFrameHandler/VeDirectMpptController.h

@@ -38,8 +38,11 @@ class MovingAverage {
 
 struct VeDirectHexQueue {
     VeDirectHexRegister _hexRegister;   // hex register
+    bool    _setCommand;                // true if the command is a SET-command, false if GET
     uint8_t _readPeriod;                // time period in sec until we send the command again
     uint32_t _lastSendTime;             // time stamp in milli sec of last send
+    uint32_t& _data;                    // data to send (only at SET-command)
+    uint8_t  _dataLength;               // length of data (only at SET-command -> 8/16/32)
 };
 
 class VeDirectMpptController : public VeDirectFrameHandler<veMpptStruct> {
@@ -49,7 +52,7 @@ class VeDirectMpptController : public VeDirectFrameHandler<veMpptStruct> {
     void init(gpio_num_t rx, gpio_num_t tx, uint8_t hwSerialPort);
 
     using data_t = veMpptStruct;
-
+    void setChargeLimit( float value );
     void loop() final;
 
 private:
@@ -62,12 +65,17 @@ class VeDirectMpptController : public VeDirectFrameHandler<veMpptStruct> {
 
     uint32_t _sendTimeout = 0;          // timeout until we send the next command from the queue
     size_t _sendQueueNr = 0;            // actual queue position;
+    uint32_t _chargeLimit = 0xFFFF;     // limit MPPT to this limit (in 0.1A), default: 0xFFFF (=full current)
+    uint32_t _no_data = 0;              // dummy-value
 
     // for slow changing values we use a send time period of 4 sec
     #define HIGH_PRIO_COMMAND 1
-    std::array<VeDirectHexQueue, 5> _hexQueue { VeDirectHexRegister::NetworkTotalDcInputPower, HIGH_PRIO_COMMAND, 0,
-                                                VeDirectHexRegister::ChargeControllerTemperature, 4, 0,
-                                                VeDirectHexRegister::SmartBatterySenseTemperature, 4, 0,
-                                                VeDirectHexRegister::BatteryFloatVoltage, 4, 0,
-                                                VeDirectHexRegister::BatteryAbsorptionVoltage, 4, 0 };
+    std::array<VeDirectHexQueue, 8> _hexQueue { VeDirectHexRegister::NetworkTotalDcInputPower, false, HIGH_PRIO_COMMAND, 0, _no_data, 0,
+                                                VeDirectHexRegister::ChargeControllerTemperature, false, 4, 0, _no_data, 0,
+                                                VeDirectHexRegister::SmartBatterySenseTemperature, false, 4, 0, _no_data, 0,
+                                                VeDirectHexRegister::BatteryFloatVoltage, false, 4, 0, _no_data, 0,
+                                                VeDirectHexRegister::BatteryAbsorptionVoltage, false, 4, 0, _no_data, 0,
+												VeDirectHexRegister::ChargeCurrentLimit, false, 4, 0, _no_data, 0,
+                                                VeDirectHexRegister::BatteryMaximumCurrent, false, 4, 0, _no_data, 0,
+                                                VeDirectHexRegister::ChargeCurrentLimit, true, 10, 0, _chargeLimit, 16};
 };

src/Configuration.cpp

@@ -135,6 +135,12 @@ void ConfigurationClass::serializeBatteryConfig(BatteryConfig const& source, Jso
     target["discharge_current_limit_below_soc"] = config.Battery.DischargeCurrentLimitBelowSoc;
     target["discharge_current_limit_below_voltage"] = config.Battery.DischargeCurrentLimitBelowVoltage;
     target["use_battery_reported_discharge_current_limit"] = config.Battery.UseBatteryReportedDischargeCurrentLimit;
+    target["enable_charge_current_limit"] = config.Battery.EnableChargeCurrentLimit;
+    target["max_charge_current_limit"] = config.Battery.MaxChargeCurrentLimit;
+    target["min_charge_current_limit"] = config.Battery.MinChargeCurrentLimit;
+    target["charge_current_limit_below_soc"] = config.Battery.ChargeCurrentLimitBelowSoc;
+    target["charge_current_limit_below_voltage"] = config.Battery.ChargeCurrentLimitBelowVoltage;
+    target["use_battery_reported_charge_current_limit"] = config.Battery.UseBatteryReportedChargeCurrentLimit;
 }
 
 void ConfigurationClass::serializeBatteryZendureConfig(BatteryZendureConfig const& source, JsonObject& target)
@@ -559,6 +565,12 @@ void ConfigurationClass::deserializeBatteryConfig(JsonObject const& source, Batt
     target.DischargeCurrentLimitBelowSoc = source["discharge_current_limit_below_soc"] | BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_SOC;
     target.DischargeCurrentLimitBelowVoltage = source["discharge_current_limit_below_voltage"] | BATTERY_DISCHARGE_CURRENT_LIMIT_BELOW_VOLTAGE;
     target.UseBatteryReportedDischargeCurrentLimit = source["use_battery_reported_discharge_current_limit"] | BATTERY_USE_BATTERY_REPORTED_DISCHARGE_CURRENT_LIMIT;
+    target.EnableChargeCurrentLimit = source["enable_charge_current_limit"] | BATTERY_ENABLE_CHARGE_CURRENT_LIMIT;
+    target.MaxChargeCurrentLimit = source["max_charge_current_limit"] | BATTERY_CHARGE_CURRENT_LIMIT_MAX;
+    target.MinChargeCurrentLimit = source["min_charge_current_limit"] | BATTERY_CHARGE_CURRENT_LIMIT_MIN;
+    target.ChargeCurrentLimitBelowSoc = source["charge_current_limit_below_soc"] | BATTERY_CHARGE_CURRENT_LIMIT_BELOW_SOC;
+    target.ChargeCurrentLimitBelowVoltage = source["charge_current_limit_below_voltage"] | BATTERY_CHARGE_CURRENT_LIMIT_BELOW_VOLTAGE;
+    target.UseBatteryReportedChargeCurrentLimit = source["use_battery_reported_charge_current_limit"] | BATTERY_USE_BATTERY_REPORTED_CHARGE_CURRENT_LIMIT;
 }
 
 void ConfigurationClass::deserializeBatteryZendureConfig(JsonObject const& source, BatteryZendureConfig& target)

src/battery/Controller.cpp

@@ -152,4 +152,63 @@ float Controller::getDischargeCurrentLimit()
     return std::min(getConfiguredLimit(), getBatteryLimit());
 }
 
+float Controller::getChargeCurrentLimit()
+{
+    auto const& config = Configuration.get();
+
+    if (!config.Battery.EnableChargeCurrentLimit) { return FLT_MAX; }
+
+    /**
+     * we are looking at three limits: (1) the static max charge current limit
+     * setup by the user as part of the configuration, which is effective below
+     * a (SoC or voltage) threshold, (2) the dynamic charge current
+     * limit reported by the BMS and (3) the static min charge current limit, setup by
+     * the user which defines the lowest possible charge current limit.
+     * for the first both types of limits, we will determine its value, then test a bunch
+     * of excuses why the limit might not be applicable.
+     *
+     * the smaller limit will be enforced.
+     * If the resulting limit is smaller than (3), (3) will be used instead
+     */
+    auto spStats = getStats();
+
+    auto getConfiguredMinLimit = [&config,&spStats]() -> float {
+        auto configuredMinLimit = config.Battery.MinChargeCurrentLimit;
+        if (configuredMinLimit < 0.0f) { return 0.0f; } // invalid setting
+
+        return configuredMinLimit;
+    };
+
+    auto getConfiguredMaxLimit = [&config,&spStats]() -> float {
+        auto configuredMaxLimit = config.Battery.MaxChargeCurrentLimit;
+        if (configuredMaxLimit <= 0.0f) { return FLT_MAX; } // invalid setting
+
+        bool useSoC = spStats->getSoCAgeSeconds() <= 60 && !config.PowerLimiter.IgnoreSoc;
+        if (useSoC) {
+            auto threshold = config.Battery.ChargeCurrentLimitBelowSoc;
+            if (spStats->getSoC() >= threshold) { return FLT_MAX; }
+
+            return configuredMaxLimit;
+        }
+
+        bool voltageValid = spStats->getVoltageAgeSeconds() <= 60;
+        if (voltageValid) {
+            auto threshold = config.Battery.ChargeCurrentLimitBelowVoltage;
+            if (spStats->getVoltage() >= threshold) { return FLT_MAX; }
+
+            return configuredMaxLimit;
+        }
+        return configuredMaxLimit;
+    };
+
+    auto getBatteryLimit = [&config,&spStats]() -> float {
+        if (!config.Battery.UseBatteryReportedChargeCurrentLimit) { return FLT_MAX; }
+
+        if (spStats->getChargeCurrentLimitAgeSeconds() > 60) { return FLT_MAX; } // unusable
+
+        return spStats->getChargeCurrentLimit();
+    };
+    auto maxChargeLimit = std::min(getConfiguredMaxLimit(), getBatteryLimit());
+    return std::max(maxChargeLimit, getConfiguredMinLimit());
+}
 } // namespace Batteries

src/solarcharger/Controller.cpp

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include <Configuration.h>
 #include <MqttSettings.h>
+#include <battery/Controller.h>
 #include <solarcharger/Controller.h>
 #include <solarcharger/DummyStats.h>
 #include <solarcharger/victron/Provider.h>
@@ -72,6 +73,12 @@ void Controller::loop()
 
     if (!_upProvider) { return; }
 
+    //get charge current limitation from battery
+    auto stats = Battery.getStats();
+
+    float chargeCurrentLimit = Battery.getChargeCurrentLimit();
+    float actChargeCurrent = stats->getChargeCurrent();
+    _upProvider->setChargeLimit(chargeCurrentLimit, actChargeCurrent);
     _upProvider->loop();
 
     // TODO(schlimmchen): this cannot make sure that transient

src/solarcharger/victron/Provider.cpp

@@ -64,11 +64,71 @@ bool Provider::initController(gpio_num_t rx, gpio_num_t tx, uint8_t instance)
     return true;
 }
 
+void Provider::setChargeLimit( float limit, float act_charge_current )
+{
+    _chargeLimit = limit;
+    _chargeCurrent = act_charge_current;
+}
+
+
 void Provider::loop()
 {
     std::lock_guard<std::mutex> lock(_mutex);
 
+    float overallChargeCurrent  { 0.0f };
+    float remainingLimit        { _chargeLimit };
+    float reservedChargeCurrent { 0.5f };   // minimum current for a controller whenever the given limit is higher
+
+    uint8_t numControllers { 0 };
+    // calculate the actual charge current of all MPPTs
+    for (auto const& upController : _controllers) {
+        overallChargeCurrent += static_cast<float>( upController->getData().batteryCurrent_I_mA ) / 1000.0f;
+        numControllers++;
+    }
+    // increase the charge limit with the current drawn by the inverter(s)
+    const float inverterCurrent { overallChargeCurrent - _chargeCurrent };
+	if (inverterCurrent >= 0.0f) {
+		remainingLimit += inverterCurrent;
+	}
+
+    // reserve a minimum charge-current for every controller, to ensure that we get a good distribution over all MPPTs
+    const float overallReservedChargeCurrent { reservedChargeCurrent * static_cast<float>(numControllers) };
+    if (remainingLimit > overallReservedChargeCurrent) {
+        remainingLimit -= overallReservedChargeCurrent;
+    } else {
+        // the limit is lower than the needed reserve --> distribute the allowed limit in a simple way over all MPPTs
+        reservedChargeCurrent = remainingLimit / static_cast<float>(numControllers);
+        remainingLimit = 0.0f;
+    }
     for (auto const& upController : _controllers) {
+        const float batCurrent { static_cast<float>( upController->getData().batteryCurrent_I_mA ) / 1000.0f };
+        float factor { 0.0f };
+        // if there is not current for automatic distribution --> distribute the limit uniformly to all controllers
+        if (overallChargeCurrent <= 0.0f) {
+            factor = 1.0 / static_cast<float>(numControllers);
+        } else {
+            factor = batCurrent / overallChargeCurrent;
+        }
+        float controllerLimit { reservedChargeCurrent};
+        // no limit left for this controller? Only apply the absolute minimum
+        if (remainingLimit > 0.0f) {
+            controllerLimit += factor * remainingLimit;
+        }
+        // get the maximum allowed battery current of the charger
+        auto batMaxCurrent { upController->getData().BatteryMaximumCurrent };
+        // is the data valid?
+        if (batMaxCurrent.first > 0) {
+            const float maxControllerCurrent { static_cast<float>( batMaxCurrent.second ) / 10.0f };
+            // limit to the maximum allowed battery current of the charger
+            if (controllerLimit > maxControllerCurrent) {
+                controllerLimit = maxControllerCurrent;
+            }
+        }
+        // substract the set limit from the remaining limit for distribution to the other chargers
+        remainingLimit -= controllerLimit;
+        overallChargeCurrent -= batCurrent;
+
+        upController->setChargeLimit(controllerLimit);
         upController->loop();
 
         if (upController->isDataValid()) {

src/solarcharger/victron/Stats.cpp

@@ -251,7 +251,11 @@ void Stats::populateJsonWithInstanceStats(const JsonObject &root, const VeDirect
         device["MpptTemperature"]["u"] = "°C";
         device["MpptTemperature"]["d"] = "1";
     }
-
+    if (mpptData.ChargeCurrentLimit.first > 0) {
+        device["ChargeCurrentLimit"]["v"] = mpptData.ChargeCurrentLimit.second / 10.0;
+        device["ChargeCurrentLimit"]["u"] = "A";
+        device["ChargeCurrentLimit"]["d"] = 1;
+    }
     const JsonObject output = values["output"].to<JsonObject>();
     output["P"]["v"] = mpptData.batteryOutputPower_W;
     output["P"]["u"] = "W";