fix: DPL solar: use 1,5% check to determine if power can be increased

Author: AndreasBoehm

src/PowerLimiterOverscalingInverter.cpp

@@ -38,6 +38,12 @@ uint16_t PowerLimiterOverscalingInverter::scaleLimit(uint16_t expectedOutputWatt
     // unreasonable scaling.
     if (!isProducing()) { return expectedOutputWatts; }
 
+    // TODO(andreasboehm): disallow overscaling for solar inverters until
+    // the new solution to detect shading in getMaxIncreaseWatts() is verified
+    if(_config.PowerSource == PowerLimiterInverterConfig::InverterPowerSource::Solar) {
+        return expectedOutputWatts;
+    }
+
     auto pStats = _spInverter->Statistics();
     std::vector<ChannelNum_t> dcChnls = _spInverter->getChannelsDC();
     std::vector<MpptNum_t> dcMppts = _spInverter->getMppts();

src/PowerLimiterSolarInverter.cpp

@@ -24,25 +24,34 @@ uint16_t PowerLimiterSolarInverter::getMaxIncreaseWatts() const
         return getConfiguredMaxPowerWatts();
     }
 
+    // 1.5% of the inverter's max power can be missing
+    auto maxPowerMissing = getInverterMaxPowerWatts() * 0.015;
+    auto diff = getCurrentLimitWatts() - maxPowerMissing;
+
+    // if the inverter's output is within the limit, we can increase the power
+    if (getCurrentOutputAcWatts() >= diff) {
+        return getConfiguredMaxPowerWatts() - getCurrentLimitWatts();
+    }
+
+    // if we reached this point and can't use overscaling, we can't increase the power
+    if (!_config.UseOverscaling || _spInverter->supportsPowerDistributionLogic()) {
+        return 0;
+    }
+
+    // TODO(andreasboehm): disallow overscaling until the above solution is verified
+    return 0;
+
     // the maximum increase possible for this inverter
     int16_t maxTotalIncrease = getConfiguredMaxPowerWatts() - getCurrentOutputAcWatts();
 
+    auto expectedPowerPercentage = static_cast<float>(_config.ScalingThreshold) / 100.0;
+
     auto pStats = _spInverter->Statistics();
     std::vector<MpptNum_t> dcMppts = _spInverter->getMppts();
     size_t dcTotalMppts = dcMppts.size();
 
     float inverterEfficiencyFactor = pStats->getChannelFieldValue(TYPE_INV, CH0, FLD_EFF) / 100;
 
-    // with 97% we are a bit less strict than when we scale the limit
-    auto expectedPowerPercentage = 0.97;
-
-    // use the scaling threshold as the expected power percentage if lower,
-    // but only when overscaling is enabled and the inverter does not support PDL
-    if (_config.UseOverscaling && !_spInverter->supportsPowerDistributionLogic()) {
-        expectedPowerPercentage = std::min(expectedPowerPercentage, static_cast<float>(_config.ScalingThreshold) / 100.0);
-    }
-
-    // x% of the expected power is good enough
     auto expectedAcPowerPerMppt = (getCurrentLimitWatts() / dcTotalMppts) * expectedPowerPercentage;
 
     size_t dcNonShadedMppts = 0;
@@ -72,23 +81,16 @@ uint16_t PowerLimiterSolarInverter::getMaxIncreaseWatts() const
         return maxTotalIncrease;
     }
 
-    // for inverters without PDL we use the configured max power, because the limit will be divided equally across the MPPTs by the inverter.
-    int16_t inverterMaxPower = getConfiguredMaxPowerWatts();
-
-    // for inverter with PDL or when overscaling is enabled we use the max power of the inverter because each MPPT can deliver its max power.
-    if (_spInverter->supportsPowerDistributionLogic() || _config.UseOverscaling) {
-        inverterMaxPower = getInverterMaxPowerWatts();
-    }
+    // we use the inverter's max power, because each MPPT can deliver its max power individually
+    int16_t inverterMaxPower = getInverterMaxPowerWatts();
 
     int16_t maxPowerPerMppt = inverterMaxPower / dcTotalMppts;
 
     int16_t currentPowerPerNonShadedMppt = nonShadedMpptACPowerSum / dcNonShadedMppts;
 
     int16_t maxIncreasePerNonShadedMppt = maxPowerPerMppt - currentPowerPerNonShadedMppt;
 
-    // maximum increase based on the non-shaded mppts, can be higher than maxTotalIncrease for inverters
-    // with PDL when getConfiguredMaxPowerWatts() is less than getInverterMaxPowerWatts() divided by
-    // the number of used/unshaded MPPTs.
+    // maximum increase based on the non-shaded mppts
     int16_t maxIncreaseNonShadedMppts = maxIncreasePerNonShadedMppt * dcNonShadedMppts;
 
     // maximum increase should not exceed the max total increase