foxesscloud 2.7.0__tar.gz → 2.7.2__tar.gz

{foxesscloud-2.7.0 → foxesscloud-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxesscloud
-Version: 2.7.0
+Version: 2.7.2
 Summary: library for accessing Fox ESS cloud data using Open API
 Author-email: Tony Matthews <tony@quasair.co.uk>
 Project-URL: Homepage, https://github.com/TonyM1958/FoxESS-Cloud
@@ -158,12 +158,12 @@ set_min() applies new SoC settings to the inverter. The parameters update batter
 + minSoc: min Soc setting e.g. 10 = 10%
 
 set_charge() takes the charge times from the battery_settings and applies these to the inverter. The parameters are optional and will update battery_settings. You should specify all 3 parameter for a time period:
-+ ch1: enable charge from grid for period 1 (True or False)
-+ st1: the start time for period 1
-+ en1: the end time for period 1
-+ ch2: enable charge from grid for period 2 (True or False)
-+ st2: the start time for period 2
-+ en2: the end time for period 2
++ ch1: enable charge from grid for period 1 (default True)
++ st1: the start time for period 1 (default 0)
++ en1: the end time for period 1 (default 0)
++ ch2: enable charge from grid for period 2 (default True)
++ st2: the start time for period 2 (default 0)
++ en2: the end time for period 2 (default 0)
 + enable: set to 0 to show settings but stop inverter settings being updated. Default is 1.
 
 set_period() returns a period structure that can be used to build a list for set_schedule()
@@ -807,6 +807,22 @@ This setting can be:
 
 # Version Info
 
+2.7.2<br>
+Fix to get_battery() to return error and flag status=0 in f.battery when the cloud is not returning valid data.
+Fix exception calculating SoH if ratedCapacity is returned as 0 when cloud is not returning valid data.
+Update charge_rate in charge_needed() to use a blended charge rate based on battery warming up during charging.
+Fix exception in set_charge() caused by incorrect default parameter values.
+Update charge_needed() to only show forecast that is in use.
+
+2.7.1<br>
+Update charge_needed() so it only gets generation history if there is no forecast to reduce API calls and save time.
+Update default parameter values for set_charge() so the other time period is cleared if you only set 1 time.
+Fix problem where a full charge was being set when charge_needed() is called with force_charge=1.
+Move charging to the end of the charge time when force_charge=1 so the charge time completes with the required charge.
+Update battery predictions to more accurately reflect what happens when SoC gets to min_soc or fd_soc.
+Correct model to use inverter operating losses instead of BMS losses when the battery is above min_soc.
+Correct exception in Solcast and Solar when a forecast is not available.
+
 2.7.0<br>
 Allow charge_loss / discharge_loss to be configured for charge_needed().
 Change 'Force Charge' to 'Battery Hold' in charge times to avoid confusion with Force Charge work mode.

foxesscloud-2.7.0/src/foxesscloud.egg-info/PKG-INFO → foxesscloud-2.7.2/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.1
-Name: foxesscloud
-Version: 2.7.0
-Summary: library for accessing Fox ESS cloud data using Open API
-Author-email: Tony Matthews <tony@quasair.co.uk>
-Project-URL: Homepage, https://github.com/TonyM1958/FoxESS-Cloud
-Project-URL: Bug Tracker, https://github.com/TonyM1958/FoxESS-Cloud/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENCE
-
 # FoxESS-Cloud
 
 <a href="https://www.buymeacoffee.com/tonym1958" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174" align="right"></a>
@@ -158,12 +144,12 @@ set_min() applies new SoC settings to the inverter. The parameters update batter
 + minSoc: min Soc setting e.g. 10 = 10%
 
 set_charge() takes the charge times from the battery_settings and applies these to the inverter. The parameters are optional and will update battery_settings. You should specify all 3 parameter for a time period:
-+ ch1: enable charge from grid for period 1 (True or False)
-+ st1: the start time for period 1
-+ en1: the end time for period 1
-+ ch2: enable charge from grid for period 2 (True or False)
-+ st2: the start time for period 2
-+ en2: the end time for period 2
++ ch1: enable charge from grid for period 1 (default True)
++ st1: the start time for period 1 (default 0)
++ en1: the end time for period 1 (default 0)
++ ch2: enable charge from grid for period 2 (default True)
++ st2: the start time for period 2 (default 0)
++ en2: the end time for period 2 (default 0)
 + enable: set to 0 to show settings but stop inverter settings being updated. Default is 1.
 
 set_period() returns a period structure that can be used to build a list for set_schedule()
@@ -807,6 +793,22 @@ This setting can be:
 
 # Version Info
 
+2.7.2<br>
+Fix to get_battery() to return error and flag status=0 in f.battery when the cloud is not returning valid data.
+Fix exception calculating SoH if ratedCapacity is returned as 0 when cloud is not returning valid data.
+Update charge_rate in charge_needed() to use a blended charge rate based on battery warming up during charging.
+Fix exception in set_charge() caused by incorrect default parameter values.
+Update charge_needed() to only show forecast that is in use.
+
+2.7.1<br>
+Update charge_needed() so it only gets generation history if there is no forecast to reduce API calls and save time.
+Update default parameter values for set_charge() so the other time period is cleared if you only set 1 time.
+Fix problem where a full charge was being set when charge_needed() is called with force_charge=1.
+Move charging to the end of the charge time when force_charge=1 so the charge time completes with the required charge.
+Update battery predictions to more accurately reflect what happens when SoC gets to min_soc or fd_soc.
+Correct model to use inverter operating losses instead of BMS losses when the battery is above min_soc.
+Correct exception in Solcast and Solar when a forecast is not available.
+
 2.7.0<br>
 Allow charge_loss / discharge_loss to be configured for charge_needed().
 Change 'Force Charge' to 'Battery Hold' in charge times to avoid confusion with Force Charge work mode.

{foxesscloud-2.7.0 → foxesscloud-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "foxesscloud"
-version = "2.7.0"
+version = "2.7.2"
 authors = [
   {name="Tony Matthews", email="tony@quasair.co.uk"},
 ]

{foxesscloud-2.7.0 → foxesscloud-2.7.2}/src/foxesscloud/foxesscloud.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud
-Updated:  06 November 2024
+Updated:  23 November 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2023
 ##################################################################################################
 
-version = "1.8.1"
+version = "1.8.3"
 print(f"FoxESS-Cloud version {version}")
 
 debug_setting = 1
@@ -600,7 +600,7 @@ battery_params = {
     2: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
         'step': 5,
         'offset': 5,
-        'charge_loss': 1.07,
+        'charge_loss': 1.08,
         'discharge_loss': 0.95},
     # Mira BMS with firmware 1.014 or later
     3: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
@@ -615,6 +615,7 @@ def get_battery(info=1, rated=None, count=None):
     if get_device() is None:
         return None
     output(f"getting battery", 2)
+    battery = None
     params = {'id': device_id}
     response = signed_get(path="/c/v0/device/battery/info", params=params)
     if response.status_code != 200:
@@ -625,11 +626,8 @@ def get_battery(info=1, rated=None, count=None):
         errno = response.json().get('errno')
         output(f"** get_battery(), no result data, {errno_message(errno)}")
         return None
-    saved_info = battery['info'] if battery is not None and battery.get('info') is not None else None
     battery = result
-    if saved_info is not None:
-        battery['info'] = saved_info
-    elif info == 1:
+    if info == 1:
         response = signed_get(path="/generic/v0/device/battery/list", params=params)
         if response.status_code != 200:
             output(f"** get_battery().info got response code {response.status_code}: {response.reason}")
@@ -649,6 +647,9 @@ def get_battery(info=1, rated=None, count=None):
     battery['residual_handling'] = residual_handling
     battery['soh'] = None
     battery['soh_supported'] = False
+    if battery.get('status') is None or battery['status'] != 1:
+        output(f"** get_battery(): battery status not available")
+        return None
     if battery.get('residual') is not None:
         battery['residual'] /= 1000
     if battery['residual_handling'] == 2:
@@ -680,9 +681,9 @@ def get_battery(info=1, rated=None, count=None):
     battery['charge_loss'] = params['charge_loss']
     battery['discharge_loss'] = params['discharge_loss']
     if battery.get('ratedCapacity') is not None and battery.get('capacity') is not None:
-        battery['soh'] = round(battery['capacity'] * 1000 / battery['ratedCapacity'] * 100, 1)
+        battery['soh'] = round(battery['capacity'] * 1000 / battery['ratedCapacity'] * 100, 1) if battery['ratedCapacity'] > 0.0 else None
     if battery.get('temperature') is not None:
-        battery['charge_rate'] = params['table'][int((battery['temperature'] - params['offset']) / params['step'])]
+        battery['charge_rate'] = interpolate((battery['temperature'] - params['offset']) / params['step'], params['table'])
     return battery
 
 def get_batteries(info=1, rated=None, count=None):
@@ -690,6 +691,7 @@ def get_batteries(info=1, rated=None, count=None):
     if get_device() is None:
         return None
     output(f"getting batteries", 2)
+    batteries = None
     params = {'id': device_id}
     response = signed_get(path="/generic/v0/device/battery/info", params=params)
     if response.status_code != 200:
@@ -722,6 +724,9 @@ def get_batteries(info=1, rated=None, count=None):
     while len(count) < len(batteries):
         count.append(None)
     for i,b in enumerate(batteries):
+        if b.get('status') is None or b['status'] != 1:
+            output(f"** get_batteries(): battery {i+1} status not available")
+            continue
         b['residual_handling'] = residual_handling
         if b.get('info') is not None:
             if b['info'].get('slaveBatteries') is not None:
@@ -738,6 +743,8 @@ def get_batteries(info=1, rated=None, count=None):
         b['soh'] = int(soh) if soh.isnumeric() and int(soh) > 10 else None
         b['soh_supported'] = b['soh'] is not None
     for i, b in enumerate(batteries):
+        if b.get('status') is None or b['status'] != 1:
+            continue
         if i == 0:
             residual_handling = b['residual_handling']
             get_battery(info=0)
@@ -751,13 +758,13 @@ def get_batteries(info=1, rated=None, count=None):
             residual = b['capacity'] * b['soc'] / 100
             b['residual'] = round(residual, 3)
         if b.get('ratedCapacity') is not None and b.get('capacity') is not None:
-            b['soh'] = round(b['capacity'] * 1000 / b['ratedCapacity'] * 100, 1)
+            b['soh'] = round(b['capacity'] * 1000 / b['ratedCapacity'] * 100, 1) if b['ratedCapacity'] > 0.0 else None
         b['charge_rate'] = None
         params = battery_params[b['residual_handling']]
         b['charge_loss'] = params['charge_loss']
         b['discharge_loss'] = params['discharge_loss']
         if b.get('temperature') is not None:
-            b['charge_rate'] = params['table'][int((b['temperature'] - params['offset']) / params['step'])]
+            b['charge_rate'] = interpolate((b['temperature'] - params['offset']) / params['step'], params['table'])
     return batteries
 
 ##################################################################################################
@@ -801,7 +808,7 @@ def time_period(t):
         result += f" Charge from grid" if t['enableGrid'] else f" Battery Hold"
     return result
 
-def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force=0, enable=1):
+def set_charge(ch1=True, st1=0, en1=0, ch2=True, st2=0, en2=0, force=0, enable=1):
     global device_sn, battery_settings, debug_setting, messages, schedule
     if get_device() is None:
         return None
@@ -1081,6 +1088,8 @@ def get_remote_settings(key):
 
 def get_named_settings(name):
     global named_settings
+    if get_device() is None:
+        return None
     if type(name) is list:
         result = []
         for n in name:
@@ -2774,8 +2783,8 @@ def strategy_timed(timed_mode, time_line, run_time, min_soc=10, max_soc=100, cur
     strategy = get_strategy(timed_mode=timed_mode)
     for i in range(0, run_time):
         h = time_line[i]
-        period = {'mode': current_mode, 'min_soc': min_soc_now, 'max_soc': max_soc, 'fdpwr': 0, 'fdsoc': min_soc_now, 'duration': 1.0, 'charge': 0.0,
-            'pv': 0.0, 'discharge': 0.0, 'hold': 0, 'kwh': None}
+        period = {'mode': current_mode, 'min_soc': min_soc_now, 'max_soc': max_soc, 'fdpwr': 0, 'fdsoc': min_soc_now, 'duration': 1.0,
+            'pv': 0.0, 'charge': 0.0, 'discharge': 0.0, 'fd_kwh': 0.0, 'hold': 0, 'kwh': None}
         if strategy is not None:
             period['mode'] = 'SelfUse'
             for d in strategy:
@@ -2810,33 +2819,47 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
     for i in range(0, run_time):
         w = work_mode_timed[i]
         w['kwh'] = kwh_current
+        kwh_next = kwh_current
         max_now = w['max_soc'] * capacity / 100
-        if kwh_current < max_now and w['charge'] > 0.0:
-            kwh_current += min([w['charge'], charge_limit - w['pv']]) * charge_loss / steps_per_hour
-            kwh_current = max_now if kwh_current > max_now else kwh_current
-        kwh_current += (w['pv'] * charge_loss - w['discharge'] / discharge_loss) / steps_per_hour
-        if kwh_current > capacity:
-            # battery is full
-            kwh_current = capacity
-        w = work_mode_timed[i+1] if (i + 1) < run_time else w
-        min_soc_now = w['fdsoc'] if w['mode'] =='ForceDischarge' else w['min_soc']
+        min_soc_now = w['min_soc']
         reserve_now = capacity * min_soc_now / 100
-        if kwh_current < reserve_now and (i < time_to_next or kwh_min is None):
+        reserve_limit = capacity * (min_soc_now - allowed_drain) / 100
+        fdsoc_limit = (capacity * w['fdsoc'] / 100) if w['mode'] =='ForceDischarge' else capacity
+        if kwh_next < max_now and w['charge'] > 0.0:
+            # charge from grid or force charge
+            kwh_next += min([w['charge'], charge_limit - w['pv']]) * charge_loss / steps_per_hour
+            kwh_next = max_now if kwh_next > max_now else kwh_next
+        if kwh_next > fdsoc_limit and w['fd_kwh'] > 0.0:
+            # force discharge
+            kwh_next += (w['pv' * charge_loss - w['fd_kwh'] / discharge_loss]) / steps_per_hour
+            if kwh_current > fdsoc_limit and kwh_next < fdsoc_limit:
+                kwh_next = fdsoc_limit - w['discharge'] * (1.0 - w['duration']) / discharge_loss / steps_per_hour
+        else:
+            # normal discharge
+            kwh_next += (w['pv'] * charge_loss - w['discharge'] / discharge_loss) / steps_per_hour
+        if kwh_next > capacity:
+            # battery is full
+            kwh_next = capacity
+        if kwh_next < reserve_now and (i < time_to_next or kwh_min is None):
             # battery is empty, check if charge is needed
-            reserve_limit = capacity * (min_soc_now - allowed_drain) / 100
-            reserve_drain = kwh_current if reserve_drain is None or kwh_current > reserve_drain else reserve_drain
-            kwh_current = reserve_drain
+            if kwh_current > reserve_now and kwh_next < reserve_now:
+                kwh_next = reserve_now
+            reserve_drain = kwh_next if reserve_drain is None or kwh_next > reserve_drain else reserve_drain
             if reserve_drain <= reserve_limit:
+                # float charge
                 reserve_drain = min([reserve_now, reserve_drain + float_charge * charge_loss / steps_per_hour])
+                kwh_next = reserve_drain
             else:
                 # BMS power drain
+                kwh_next = reserve_drain
                 reserve_drain -= bms_loss / steps_per_hour
         else:
             # reset drain level
             reserve_drain = reserve_now
-        if kwh_min is not None and kwh_current < kwh_min and i >= time_to_next:       # track minimum without charge
-            kwh_min = kwh_current
-    return ([work_mode_timed[i]['kwh'] for i in range(0, len(work_mode_timed))], kwh_min)
+        if kwh_min is not None and kwh_next < kwh_min and i >= time_to_next:       # track minimum without charge
+            kwh_min = kwh_next
+        kwh_current = kwh_next
+    return ([work_mode_timed[i]['kwh'] for i in range(0, run_time)], kwh_min)
 
 # use work_mode_timed to generate time periods for the inverter schedule
 def charge_periods(work_mode_timed, base_hour, min_soc, capacity):
@@ -3044,7 +3067,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         output(f"full_charge = {full_charge}")
     if test_soc is not None:
         current_soc = test_soc
-        capacity = 14.53
+        capacity = 14.43
         residual = test_soc * capacity / 100
         bat_volt = 317.4
         bat_power = 0.0
@@ -3060,7 +3083,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     # get device and battery info from inverter
         get_battery()
         if battery is None or battery['status'] != 1:
-            output(f"\nBattery status is not available")
             return None
         current_soc = battery['soc']
         bat_volt = battery['volt']
@@ -3176,47 +3198,19 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     consumption_timed = timed_list([consumption * x / daily_sum for x in consumption_by_hour], base_hour, run_time)
     # get Solcast data and produce time line
     solcast_value = None
-    solcast_profile = None
     if forecast is None and solcast_api_key is not None and solcast_api_key != 'my.solcast_api_key' and (system_time.hour in forecast_times or run_after == 0):
         fsolcast = Solcast(quiet=True, reload=reload, shading=charge_config.get('shading'), d=base_time)
         if fsolcast is not None and hasattr(fsolcast, 'daily') and fsolcast.daily.get(forecast_day) is not None:
             solcast_value = fsolcast.daily[forecast_day]['kwh']
             solcast_timed = forecast_value_timed(fsolcast, today, tomorrow, base_hour, run_time, time_offset)
-            solcast_from = time_hours(fsolcast.daily[today]['from']) if fsolcast.daily[today].get('from') is not None else 0
-            output(f"\nSolcast: {tomorrow} {fsolcast.daily[tomorrow]['kwh']:.1f}kWh")
     # get forecast.solar data and produce time line
     solar_value = None
-    solar_profile = None
     if forecast is None and solar_arrays is not None and (system_time.hour in forecast_times or run_after == 0):
         fsolar = Solar(quiet=True, shading=charge_config.get('shading'), d=base_time)
         if fsolar is not None and hasattr(fsolar, 'daily') and fsolar.daily.get(forecast_day) is not None:
             solar_value = fsolar.daily[forecast_day]['kwh']
             solar_timed = forecast_value_timed(fsolar, today, tomorrow, base_hour, run_time, 0)
-            output(f"\nSolar: {tomorrow} {fsolar.daily[tomorrow]['kwh']:.1f}kWh")
-    if solcast_value is None and solar_value is None and debug_setting > 1:
-        output(f"\nNo forecasts available at this time")
-    # get generation data
-    generation = None
-    last_date = today if hour_now >= charge_config['use_today'] else yesterday
-    gen_days = charge_config['generation_days']
-    history = get_raw('week', d=last_date, v=['pvPower','meterPower2'], summary=2)
-    pv_history = {}
-    if history is not None and len(history) > 0:
-        for day in history:
-            date = day['date']
-            if pv_history.get(date) is None:
-                pv_history[date] = 0.0
-            if day.get('kwh') is not None and day.get('kwh_neg') is not None:
-                pv_history[date] += day['kwh_neg'] / 0.92 if day['variable'] == 'meterPower2' else day['kwh']
-        pv_sum = sum([pv_history[d] for d in sorted(pv_history.keys())[-gen_days:]])
-        output(f"\nGeneration (kWh):")
-        s = ""
-        for d in sorted(pv_history.keys())[-gen_days:]:
-            s += f" {d} {pv_history[d]:4.1f},"
-        output(' ' + s[:-1])
-        generation = pv_sum / gen_days
-        output(f"  Average of last {gen_days} days: {generation:.1f}kWh")
-    # choose expected value and produce generation time line
+    # choose expected value
     quarter = int(today[5:7] if charge_today else tomorrow[5:7]) // 3 % 4
     sun_name = seasonal_sun[quarter]['name']
     sun_profile = seasonal_sun[quarter]['sun']
@@ -3230,14 +3224,37 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     elif solcast_value is not None:
         expected = solcast_value
         generation_timed = solcast_timed
+        output(f"\nSolcast: {tomorrow} {fsolcast.daily[tomorrow]['kwh']:.1f}kWh")
     elif solar_value is not None:
         expected = solar_value
         generation_timed = solar_timed
-    elif generation is None or generation == 0.0:
-        output(f"\nNo generation data available")
-        output_close()
-        return None
+        output(f"\nSolar: {tomorrow} {fsolar.daily[tomorrow]['kwh']:.1f}kWh")
     else:
+        # no forecast, use generation history
+        generation = None
+        last_date = today if hour_now >= charge_config['use_today'] else yesterday
+        gen_days = charge_config['generation_days']
+        history = get_raw('week', d=last_date, v=['pvPower','meterPower2'], summary=2)
+        pv_history = {}
+        if history is not None and len(history) > 0:
+            for day in history:
+                date = day['date']
+                if pv_history.get(date) is None:
+                    pv_history[date] = 0.0
+                if day.get('kwh') is not None and day.get('kwh_neg') is not None:
+                    pv_history[date] += day['kwh_neg'] / 0.92 if day['variable'] == 'meterPower2' else day['kwh']
+            pv_sum = sum([pv_history[d] for d in sorted(pv_history.keys())[-gen_days:]])
+            output(f"\nGeneration (kWh):")
+            s = ""
+            for d in sorted(pv_history.keys())[-gen_days:]:
+                s += f" {d} {pv_history[d]:4.1f},"
+            output(' ' + s[:-1])
+            generation = pv_sum / gen_days
+            output(f"  Average of last {gen_days} days: {generation:.1f}kWh")
+        if generation is None or generation == 0.0:
+            output(f"\nNo generation data available")
+            output_close()
+            return None
         expected = generation
         generation_timed = [expected * x / sun_sum for x in sun_timed]
         if charge_config['forecast_selection'] == 1 and update_settings > 0:
@@ -3245,7 +3262,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             update_settings = 0
     # produce time lines for charge, discharge and work mode
     charge_timed = [min([charge_limit, c_float(x) * pv_loss]) for x in generation_timed]
-    discharge_timed = [min([discharge_limit, c_float(x) / dc_ac_loss]) + bms_loss for x in consumption_timed]
+    discharge_timed = [min([discharge_limit, c_float(x) / dc_ac_loss]) + operating_loss for x in consumption_timed]
     work_mode_timed = strategy_timed(timed_mode, time_line, run_time, min_soc=min_soc, max_soc=max_soc, current_mode=current_mode)
     for i in range(0, len(work_mode_timed)):
         # get work mode
@@ -3257,19 +3274,17 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             work_mode_timed[i]['charge'] = charge_power * duration
         elif timed_mode > 0 and work_mode == 'ForceDischarge':
             fdpwr = work_mode_timed[i]['fdpwr'] / dc_ac_loss / 1000
-            fdpwr = min([discharge_limit, export_limit + discharge_timed[i], fdpwr])
-            discharge_timed[i] = fdpwr * duration + discharge_timed[i] * (1.0 - duration) - charge_timed[i] * duration
+            work_mode_timed[i]['fd_kwh'] = min([discharge_limit, export_limit + discharge_timed[i], fdpwr]) * duration
         elif bat_hold > 0 and i >= int(time_to_start) and i < int(time_to_end):
-            discharge_timed[i] = bms_loss
-            if timed_mode > 1:
-                work_mode_timed[i]['hold'] = 1
+            discharge_timed[i] = operating_loss
+            work_mode_timed[i]['hold'] = 1
         elif timed_mode > 0 and work_mode == 'Backup':
-            discharge_timed[i] = bms_loss if charge_timed[i] == 0.0 else 0.0
+            discharge_timed[i] = operating_loss if charge_timed[i] == 0.0 else 0.0
         elif timed_mode > 0 and work_mode == 'Feedin':
-            (discharge_timed[i], charge_timed[i]) = (bms_loss if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
+            (discharge_timed[i], charge_timed[i]) = (0.0 if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
                 0.0 if (charge_timed[i] <= export_limit + discharge_timed[i]) else (charge_timed[i] - export_limit - discharge_timed[i]))
         else: # work_mode == 'SelfUse'
-            (discharge_timed[i], charge_timed[i]) = (bms_loss if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
+            (discharge_timed[i], charge_timed[i]) = (0.0 if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
                 0.0 if (charge_timed[i] <= discharge_timed[i]) else (charge_timed[i] - discharge_timed[i]))
         work_mode_timed[i]['pv'] = charge_timed[i]
         work_mode_timed[i]['discharge'] = discharge_timed[i]
@@ -3282,8 +3297,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     kwh_contingency = consumption * contingency / 100
     kwh_needed = reserve + kwh_contingency - kwh_min
     start_residual = interpolate(time_to_start, bat_timed)      # residual when charge time starts
-    start_soc = int(start_residual / capacity * 100 + 0.5)
-    end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends without charging
+    end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends (without charging)
     target_soc = charge_config.get('target_soc')
     target_kwh = capacity if full_charge is not None or bat_hold == 2 else (target_soc / 100 * capacity) if target_soc is not None else 0
     if target_kwh > (end_residual + kwh_needed):
@@ -3302,7 +3316,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         hours = 0.0
         start_timed = time_to_end
         end_timed = time_to_end
-        end_soc = int(end_residual / capacity * 100 + 0.5)
     else:
         # work out time to add kwh_needed to battery
         charge_rate = charge_power * charge_loss
@@ -3313,30 +3326,30 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             charge_message = "with charge added"
         output(f"  SoC now:     {current_soc:.0f}% at {hours_time(hour_now)} on {today}")
         # check if charge time exceeded or charge needed exceeds capacity
-        hours_to_full = (capacity - start_residual) / charge_rate
-        if hours > charge_time:
+        hours_to_full = (capacity - end_residual) / charge_rate
+        if hours > charge_time or bat_hold == 2:
             hours = charge_time
         elif hours > hours_to_full:
-            kwh_shortfall = kwh_needed - (capacity - start_residual)        # amount of energy that won't be added
+            kwh_shortfall = kwh_needed - (capacity - end_residual)        # amount of energy that won't be added
             required = (hours_to_full + kwh_shortfall / discharge_rate) if discharge_rate > 0.0 else charge_time
             hours = required if required > hours and required < charge_time else charge_time
-        # round charge time and work out what will actually be added
+        # round charge time
         min_hours = charge_config['min_hours']
         hours = int(hours / min_hours + 0.99) * min_hours
-        kwh_added = (hours * charge_rate) if hours < hours_to_full else (capacity - start_residual)
-        kwh_added += discharge_rate * hours         # discharge saved by charging
-        kwh_spare = kwh_min - reserve + kwh_added
         # rework charge and discharge
         charge_period = get_best_charge_period(start_at, hours)
-        charge_offset = round_time(charge_period['start'] - start_at) if charge_period is not None else 0
+        charge_offset = round_time(charge_period['start'] - start_at) if charge_period is not None else charge_time - hours
         price = charge_period.get('price') if charge_period is not None else None
         start_timed = time_to_start + charge_offset * steps_per_hour
         end_timed = start_timed + hours * steps_per_hour
         start_residual = interpolate(start_timed, bat_timed)
-        end_soc = min([int((start_residual + kwh_added) / capacity * 100 + 0.5), 100])
-        output(f"  Start SoC:   {start_residual / capacity * 100:.0f}% at {hours_time(adjusted_hour(start_timed, time_line))} ({start_residual:.2f}kWh)")
-        output(f"  Charge to:   {end_soc:.0f}% {hours_time(adjusted_hour(start_timed, time_line))}-{hours_time(adjusted_hour(end_timed, time_line))}"
-            + (f" at {price:.2f}p" if price is not None else "") + f" ({kwh_added:.2f}kWh)")
+        start_soc = start_residual / capacity * 100
+        kwh_added = (hours * charge_rate) if hours < hours_to_full else (capacity - start_residual)
+        kwh_added += discharge_rate * hours         # discharge saved by charging
+        kwh_spare = kwh_min - reserve + kwh_added
+        output(f"  Start SoC:   {start_soc:.0f}% at {hours_time(adjusted_hour(start_timed, time_line))} ({start_residual:.2f}kWh)")
+        output(f"  Charge:      {hours_time(adjusted_hour(start_timed, time_line))}-{hours_time(adjusted_hour(end_timed, time_line))}"
+            + (f" at {price:.2f}p" if price is not None else "") + f" ({kwh_added:.2f}kWh added)")
         for i in range(int(time_to_start), int(time_to_end)):
             j = i + 1
             # work out time (fraction of hour) when charging in hour from i to j
@@ -3359,8 +3372,9 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     # rebuild the battery residual with the charge added and min_soc
     (bat_timed, x) = battery_timed(work_mode_timed, kwh_current, capacity, time_to_next=start_timed)
     end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends
+    end_soc = end_residual / capacity * 100
     # show the results
-    output(f"  End SoC:     {end_residual / capacity * 100:.0f}% at {hours_time(adjusted_hour(time_to_end, time_line))} ({end_residual:.2f}kWh)")
+    output(f"  End SoC:     {end_soc:.0f}% at {hours_time(adjusted_hour(time_to_end, time_line))} ({end_residual:.2f}kWh)")
     output(f"  Contingency: {kwh_spare / capacity * 100:.0f}% SoC ({kwh_spare:.2f}kWh)")
     if not charge_today:
         output(f"  PV cover:    {expected / consumption * 100:.0f}% ({expected:.1f}/{consumption:.1f})")
@@ -4356,7 +4370,7 @@ class Solcast :
                 estimate_values = [self.estimate[r][hours_time(t)] for t in times]
                 plots[r] = estimate_values
         total_forecast = 0.0
-        if self.daily.get(day) is not None:
+        if hasattr(self, 'daily') and self.daily.get(day) is not None:
             sun_times = get_suntimes(day)
             print(f"\n{day}:\n  Sunrise {sun_times[0]}, Sunset {sun_times[1]}")
             forecast_values = [self.daily[day]['pt30'][hours_time(t - time_offset)] for t in times]
@@ -4679,7 +4693,7 @@ class Solar :
                 estimate_values = [c_float(self.estimate[r].get(hours_time(t))) for t in times]
                 plots[r] = estimate_values
         total_forecast = 0.0
-        if self.daily.get(day) is not None:
+        if hasattr(self, 'daily') and self.daily.get(day) is not None:
             sun_times = get_suntimes(day)
             print(f"\n{day}:\n  Sunrise {sun_times[0]}, Sunset {sun_times[1]}")
             forecast_values = [self.daily[day]['pt30'][hours_time(t)] for t in times]

{foxesscloud-2.7.0 → foxesscloud-2.7.2}/src/foxesscloud/openapi.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud using Open API
-Updated:  06 November 2024
+Updated:  23 November 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2024
 ##################################################################################################
 
-version = "2.7.0"
+version = "2.7.2"
 print(f"FoxESS-Cloud Open API version {version}")
 
 debug_setting = 1
@@ -564,7 +564,7 @@ battery_params = {
     2: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
         'step': 5,
         'offset': 5,
-        'charge_loss': 1.07,
+        'charge_loss': 1.08,
         'discharge_loss': 0.95},
     # Mira BMS with firmware 1.014 or later
     3: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
@@ -582,13 +582,18 @@ def get_battery(info=0, v=None, rated=None, count=None):
     if v is None:
         v = battery_vars
     result = get_real(v)
-    if battery is None:
-        battery = {}
+    battery = {}
     for i in range(0, len(battery_vars)):
         battery[battery_data[i]] = result[i].get('value')
     battery['residual_handling'] = residual_handling
     battery['soh'] = None
     battery['soh_supported'] = False
+    if battery.get('status') is None:
+        battery['status'] = 0 if battery.get('volt') is None or battery['volt'] <= 0 else 1
+    if battery['status'] != 1:
+        output(f"** get_battery(): battery status not available")
+        return None
+    battery['status'] = 1
     if battery['residual_handling'] == 2:
         capacity = battery.get('residual')
         soc = battery.get('soc')
@@ -621,9 +626,9 @@ def get_battery(info=0, v=None, rated=None, count=None):
     battery['charge_loss'] = params['charge_loss']
     battery['discharge_loss'] = params['discharge_loss']
     if battery.get('ratedCapacity') is not None and battery.get('capacity') is not None:
-        battery['soh'] = round(battery['capacity'] * 1000 / battery['ratedCapacity'] * 100, 1)
+        battery['soh'] = round(battery['capacity'] * 1000 / battery['ratedCapacity'] * 100, 1) if battery['ratedCapacity'] > 0.0 else None
     if battery.get('temperature') is not None:
-        battery['charge_rate'] = params['table'][int((battery['temperature'] - params['offset']) / params['step'])]
+        battery['charge_rate'] = interpolate((battery['temperature'] - params['offset']) / params['step'], params['table'])
     return battery
 
 def get_batteries(info=0, rated=None, count=None):
@@ -674,7 +679,7 @@ def time_period(t, n):
         result += f" Charge from grid" if enable else f" Battery Hold"
     return result
 
-def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force = 0, enable=1):
+def set_charge(ch1=True, st1=0, en1=0, ch2=True, st2=0, en2=0, force = 0, enable=1):
     global device_sn, battery_settings, debug_setting, time_period_vars
     if get_device() is None:
         return None
@@ -2439,8 +2444,8 @@ def strategy_timed(timed_mode, time_line, run_time, min_soc=10, max_soc=100, cur
     strategy = get_strategy(timed_mode=timed_mode)
     for i in range(0, run_time):
         h = time_line[i]
-        period = {'mode': current_mode, 'min_soc': min_soc_now, 'max_soc': max_soc, 'fdpwr': 0, 'fdsoc': min_soc_now, 'duration': 1.0, 'charge': 0.0,
-            'pv': 0.0, 'discharge': 0.0, 'hold': 0, 'kwh': None}
+        period = {'mode': current_mode, 'min_soc': min_soc_now, 'max_soc': max_soc, 'fdpwr': 0, 'fdsoc': min_soc_now, 'duration': 1.0,
+            'pv': 0.0, 'charge': 0.0, 'discharge': 0.0, 'fd_kwh': 0.0, 'hold': 0, 'kwh': None}
         if strategy is not None:
             period['mode'] = 'SelfUse'
             for d in strategy:
@@ -2474,33 +2479,47 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
     for i in range(0, run_time):
         w = work_mode_timed[i]
         w['kwh'] = kwh_current
+        kwh_next = kwh_current
         max_now = w['max_soc'] * capacity / 100
-        if kwh_current < max_now and w['charge'] > 0.0:
-            kwh_current += min([w['charge'], charge_limit - w['pv']]) * charge_loss / steps_per_hour
-            kwh_current = max_now if kwh_current > max_now else kwh_current
-        kwh_current += (w['pv'] * charge_loss - w['discharge'] / discharge_loss) / steps_per_hour
-        if kwh_current > capacity:
-            # battery is full
-            kwh_current = capacity
-        w = work_mode_timed[i+1] if (i + 1) < run_time else w
-        min_soc_now = w['fdsoc'] if w['mode'] =='ForceDischarge' else w['min_soc']
+        min_soc_now = w['min_soc']
         reserve_now = capacity * min_soc_now / 100
-        if kwh_current < reserve_now and (i < time_to_next or kwh_min is None):
+        reserve_limit = capacity * (min_soc_now - allowed_drain) / 100
+        fdsoc_limit = (capacity * w['fdsoc'] / 100) if w['mode'] =='ForceDischarge' else capacity
+        if kwh_next < max_now and w['charge'] > 0.0:
+            # charge from grid or force charge
+            kwh_next += min([w['charge'], charge_limit - w['pv']]) * charge_loss / steps_per_hour
+            kwh_next = max_now if kwh_next > max_now else kwh_next
+        if kwh_next > fdsoc_limit and w['fd_kwh'] > 0.0:
+            # force discharge
+            kwh_next += (w['pv' * charge_loss - w['fd_kwh'] / discharge_loss]) / steps_per_hour
+            if kwh_current > fdsoc_limit and kwh_next < fdsoc_limit:
+                kwh_next = fdsoc_limit - w['discharge'] * (1.0 - w['duration']) / discharge_loss / steps_per_hour
+        else:
+            # normal discharge
+            kwh_next += (w['pv'] * charge_loss - w['discharge'] / discharge_loss) / steps_per_hour
+        if kwh_next > capacity:
+            # battery is full
+            kwh_next = capacity
+        if kwh_next < reserve_now and (i < time_to_next or kwh_min is None):
             # battery is empty, check if charge is needed
-            reserve_limit = capacity * (min_soc_now - allowed_drain) / 100
-            reserve_drain = kwh_current if reserve_drain is None or kwh_current > reserve_drain else reserve_drain
-            kwh_current = reserve_drain
+            if kwh_current > reserve_now and kwh_next < reserve_now:
+                kwh_next = reserve_now
+            reserve_drain = kwh_next if reserve_drain is None or kwh_next > reserve_drain else reserve_drain
             if reserve_drain <= reserve_limit:
+                # float charge
                 reserve_drain = min([reserve_now, reserve_drain + float_charge * charge_loss / steps_per_hour])
+                kwh_next = reserve_drain
             else:
                 # BMS power drain
+                kwh_next = reserve_drain
                 reserve_drain -= bms_loss / steps_per_hour
         else:
             # reset drain level
             reserve_drain = reserve_now
-        if kwh_min is not None and kwh_current < kwh_min and i >= time_to_next:       # track minimum without charge
-            kwh_min = kwh_current
-    return ([work_mode_timed[i]['kwh'] for i in range(0, len(work_mode_timed))], kwh_min)
+        if kwh_min is not None and kwh_next < kwh_min and i >= time_to_next:       # track minimum without charge
+            kwh_min = kwh_next
+        kwh_current = kwh_next
+    return ([work_mode_timed[i]['kwh'] for i in range(0, run_time)], kwh_min)
 
 # use work_mode_timed to generate time periods for the inverter schedule
 def charge_periods(work_mode_timed, base_hour, min_soc, capacity):
@@ -2708,7 +2727,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         output(f"full_charge = {full_charge}")
     if test_soc is not None:
         current_soc = test_soc
-        capacity = 14.54
+        capacity = 14.43
         residual = test_soc * capacity / 100
         bat_volt = 317.4
         bat_power = 0.0
@@ -2724,7 +2743,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     # get device and battery info from inverter
         get_battery()
         if battery is None or battery['status'] != 1:
-            output(f"\nBattery status is not available")
             return None
         current_soc = battery['soc']
         bat_volt = battery['volt']
@@ -2844,46 +2862,19 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     consumption_timed = timed_list([consumption * x / daily_sum for x in consumption_by_hour], base_hour, run_time)
     # get Solcast data and produce time line
     solcast_value = None
-    solcast_profile = None
     if forecast is None and solcast_api_key is not None and solcast_api_key != 'my.solcast_api_key' and (system_time.hour in forecast_times or run_after == 0):
         fsolcast = Solcast(quiet=True, reload=reload, shading=charge_config.get('shading'), d=base_time)
         if fsolcast is not None and hasattr(fsolcast, 'daily') and fsolcast.daily.get(forecast_day) is not None:
             solcast_value = fsolcast.daily[forecast_day]['kwh']
             solcast_timed = forecast_value_timed(fsolcast, today, tomorrow, base_hour, run_time, time_offset)
-            output(f"\nSolcast: {tomorrow} {fsolcast.daily[tomorrow]['kwh']:.1f}kWh")
     # get forecast.solar data and produce time line
     solar_value = None
-    solar_profile = None
     if forecast is None and solar_arrays is not None and (system_time.hour in forecast_times or run_after == 0):
         fsolar = Solar(quiet=True, shading=charge_config.get('shading'), d=base_time)
         if fsolar is not None and hasattr(fsolar, 'daily') and fsolar.daily.get(forecast_day) is not None:
             solar_value = fsolar.daily[forecast_day]['kwh']
             solar_timed = forecast_value_timed(fsolar, today, tomorrow, base_hour, run_time, 0)
-            output(f"\nSolar: {tomorrow} {fsolar.daily[tomorrow]['kwh']:.1f}kWh")
-    if solcast_value is None and solar_value is None and debug_setting > 1:
-        output(f"\nNo forecasts available at this time")
-    # get generation data
-    generation = None
-    last_date = today if hour_now >= charge_config['use_today'] else yesterday
-    gen_days = charge_config['generation_days']
-    history = get_raw('week', d=last_date, v=['pvPower','meterPower2'], summary=2)
-    pv_history = {}
-    if history is not None and len(history) > 0:
-        for day in history:
-            date = day['date']
-            if pv_history.get(date) is None:
-                pv_history[date] = 0.0
-            if day.get('kwh') is not None and day.get('kwh_neg') is not None:
-                pv_history[date] += day['kwh_neg'] / 0.92 if day['variable'] == 'meterPower2' else day['kwh']
-        pv_sum = sum([pv_history[d] for d in sorted(pv_history.keys())[-gen_days:]])
-        output(f"\nGeneration (kWh):")
-        s = ""
-        for d in sorted(pv_history.keys())[-gen_days:]:
-            s += f" {d}: {pv_history[d]:4.1f},"
-        output(' ' + s[:-1])
-        generation = pv_sum / gen_days
-        output(f"  Average of last {gen_days} days: {generation:.1f}kWh")
-    # choose expected value and produce generation time line
+    # choose expected value
     quarter = int(today[5:7] if charge_today else tomorrow[5:7]) // 3 % 4
     sun_name = seasonal_sun[quarter]['name']
     sun_profile = seasonal_sun[quarter]['sun']
@@ -2897,14 +2888,37 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     elif solcast_value is not None:
         expected = solcast_value
         generation_timed = solcast_timed
+        output(f"\nSolcast: {tomorrow} {fsolcast.daily[tomorrow]['kwh']:.1f}kWh")
     elif solar_value is not None:
         expected = solar_value
         generation_timed = solar_timed
-    elif generation is None or generation == 0.0:
-        output(f"\nNo generation data available")
-        output_close()
-        return None
+        output(f"\nSolar: {tomorrow} {fsolar.daily[tomorrow]['kwh']:.1f}kWh")
     else:
+        # no forecast, use generation data
+        generation = None
+        last_date = today if hour_now >= charge_config['use_today'] else yesterday
+        gen_days = charge_config['generation_days']
+        history = get_raw('week', d=last_date, v=['pvPower','meterPower2'], summary=2)
+        pv_history = {}
+        if history is not None and len(history) > 0:
+            for day in history:
+                date = day['date']
+                if pv_history.get(date) is None:
+                    pv_history[date] = 0.0
+                if day.get('kwh') is not None and day.get('kwh_neg') is not None:
+                    pv_history[date] += day['kwh_neg'] / 0.92 if day['variable'] == 'meterPower2' else day['kwh']
+            pv_sum = sum([pv_history[d] for d in sorted(pv_history.keys())[-gen_days:]])
+            output(f"\nGeneration (kWh):")
+            s = ""
+            for d in sorted(pv_history.keys())[-gen_days:]:
+                s += f" {d} {pv_history[d]:4.1f},"
+            output(' ' + s[:-1])
+            generation = pv_sum / gen_days
+            output(f"  Average of last {gen_days} days: {generation:.1f}kWh")
+        if generation is None or generation == 0.0:
+            output(f"\nNo generation data available")
+            output_close()
+            return None
         expected = generation
         generation_timed = [expected * x / sun_sum for x in sun_timed]
         if charge_config['forecast_selection'] == 1 and update_settings > 0:
@@ -2912,7 +2926,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             update_settings = 0
     # produce time lines for charge, discharge and work mode
     charge_timed = [min([charge_limit, c_float(x) * pv_loss]) for x in generation_timed]
-    discharge_timed = [min([discharge_limit, c_float(x) / dc_ac_loss]) + bms_loss for x in consumption_timed]
+    discharge_timed = [min([discharge_limit, c_float(x) / dc_ac_loss]) + operating_loss for x in consumption_timed]
     work_mode_timed = strategy_timed(timed_mode, time_line, run_time, min_soc=min_soc, max_soc=max_soc, current_mode=current_mode)
     for i in range(0, len(work_mode_timed)):
         # get work mode
@@ -2924,19 +2938,17 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             work_mode_timed[i]['charge'] = charge_power * duration
         elif timed_mode > 0 and work_mode == 'ForceDischarge':
             fdpwr = work_mode_timed[i]['fdpwr'] / dc_ac_loss / 1000
-            fdpwr = min([discharge_limit, export_limit + discharge_timed[i], fdpwr])
-            discharge_timed[i] = fdpwr * duration + discharge_timed[i] * (1.0 - duration) - charge_timed[i] * duration
+            work_mode_timed[i]['fd_kwh'] = min([discharge_limit, export_limit + discharge_timed[i], fdpwr]) * duration
         elif bat_hold > 0 and i >= int(time_to_start) and i < int(time_to_end):
-            discharge_timed[i] = bms_loss
-            if timed_mode > 1:
-                work_mode_timed[i]['hold'] = 1
+            discharge_timed[i] = operating_loss
+            work_mode_timed[i]['hold'] = 1
         elif timed_mode > 0 and work_mode == 'Backup':
-            discharge_timed[i] = bms_loss if charge_timed[i] == 0.0 else 0.0
+            discharge_timed[i] = operating_loss if charge_timed[i] == 0.0 else 0.0
         elif timed_mode > 0 and work_mode == 'Feedin':
-            (discharge_timed[i], charge_timed[i]) = (bms_loss if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
+            (discharge_timed[i], charge_timed[i]) = (0.0 if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
                 0.0 if (charge_timed[i] <= export_limit + discharge_timed[i]) else (charge_timed[i] - export_limit - discharge_timed[i]))
         else: # work_mode == 'SelfUse'
-            (discharge_timed[i], charge_timed[i]) = (bms_loss if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
+            (discharge_timed[i], charge_timed[i]) = (0.0 if (charge_timed[i] >= discharge_timed[i]) else (discharge_timed[i] - charge_timed[i]),
                 0.0 if (charge_timed[i] <= discharge_timed[i]) else (charge_timed[i] - discharge_timed[i]))
         work_mode_timed[i]['pv'] = charge_timed[i]
         work_mode_timed[i]['discharge'] = discharge_timed[i]
@@ -2949,7 +2961,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     kwh_contingency = consumption * contingency / 100
     kwh_needed = reserve + kwh_contingency - kwh_min
     start_residual = interpolate(time_to_start, bat_timed)      # residual when charge time starts
-    start_soc = int(start_residual / capacity * 100 + 0.5)
     end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends without charging
     target_soc = charge_config.get('target_soc')
     target_kwh = capacity if full_charge is not None or bat_hold == 2 else (target_soc / 100 * capacity) if target_soc is not None else 0
@@ -2969,7 +2980,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         hours = 0.0
         start_timed = time_to_end
         end_timed = time_to_end
-        end_soc = int(end_residual / capacity * 100 + 0.5)
     else:
         # work out time to add kwh_needed to battery
         charge_rate = charge_power * charge_loss
@@ -2980,30 +2990,30 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             charge_message = "with charge added"
         output(f"  SoC now:     {current_soc:.0f}% at {hours_time(hour_now)} on {today}")
         # check if charge time exceeded or charge needed exceeds capacity
-        hours_to_full = (capacity - start_residual) / charge_rate
-        if hours > charge_time:
+        hours_to_full = (capacity - end_residual) / charge_rate
+        if hours > charge_time or bat_hold == 2:
             hours = charge_time
         elif hours > hours_to_full:
-            kwh_shortfall = kwh_needed - (capacity - start_residual)        # amount of energy that won't be added
+            kwh_shortfall = kwh_needed - (capacity - end_residual)        # amount of energy that won't be added
             required = (hours_to_full + kwh_shortfall / discharge_rate) if discharge_rate > 0.0 else charge_time
             hours = required if required > hours and required < charge_time else charge_time
-        # round charge time and work out what will actually be added
+        # round charge time
         min_hours = charge_config['min_hours']
         hours = int(hours / min_hours + 0.99) * min_hours
-        kwh_added = (hours * charge_rate) if hours < hours_to_full else (capacity - start_residual)
-        kwh_added += discharge_rate * hours         # discharge saved during charging
-        kwh_spare = kwh_min - reserve + kwh_added
         # rework charge and discharge
         charge_period = get_best_charge_period(start_at, hours)
-        charge_offset = round_time(charge_period['start'] - start_at) if charge_period is not None else 0
+        charge_offset = round_time(charge_period['start'] - start_at) if charge_period is not None else charge_time - hours
         price = charge_period.get('price') if charge_period is not None else None
         start_timed = time_to_start + charge_offset * steps_per_hour
         end_timed = start_timed + hours * steps_per_hour
         start_residual = interpolate(start_timed, bat_timed)
-        end_soc = min([int((start_residual + kwh_added) / capacity * 100 + 0.5), 100])
-        output(f"  Start SoC:   {start_residual / capacity * 100:.0f}% at {hours_time(adjusted_hour(start_timed, time_line))} ({start_residual:.2f}kWh)")
-        output(f"  Charge to:   {end_soc:.0f}% {hours_time(adjusted_hour(start_timed, time_line))}-{hours_time(adjusted_hour(end_timed, time_line))}"
-            + (f" at {price:.2f}p" if price is not None else "") + f" ({kwh_added:.2f}kWh)")
+        start_soc = start_residual / capacity * 100
+        kwh_added = (hours * charge_rate) if hours < hours_to_full else (capacity - start_residual)
+        kwh_added += discharge_rate * hours         # discharge saved by charging
+        kwh_spare = kwh_min - reserve + kwh_added
+        output(f"  Start SoC:   {start_soc:.0f}% at {hours_time(adjusted_hour(start_timed, time_line))} ({start_residual:.2f}kWh)")
+        output(f"  Charge:      {hours_time(adjusted_hour(start_timed, time_line))}-{hours_time(adjusted_hour(end_timed, time_line))}"
+            + (f" at {price:.2f}p" if price is not None else "") + f" ({kwh_added:.2f}kWh added)")
         for i in range(int(time_to_start), int(time_to_end)):
             j = i + 1
             # work out time (fraction of hour) when charging in hour from i to j
@@ -3026,8 +3036,9 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     # rebuild the battery residual with any charge added and min_soc
     (bat_timed, x) = battery_timed(work_mode_timed, kwh_current, capacity, time_to_next=start_timed)
     end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends
+    end_soc = end_residual / capacity * 100
     # show the results
-    output(f"  End SoC:     {end_residual / capacity * 100:.0f}% at {hours_time(adjusted_hour(time_to_end, time_line))} ({end_residual:.2f}kWh)")
+    output(f"  End SoC:     {end_soc:.0f}% at {hours_time(adjusted_hour(time_to_end, time_line))} ({end_residual:.2f}kWh)")
     output(f"  Contingency: {kwh_spare / capacity * 100:.0f}% SoC ({kwh_spare:.2f}kWh)")
     if not charge_today:
         output(f"  PV cover:    {expected / consumption * 100:.0f}% ({expected:.1f}/{consumption:.1f})")
@@ -4020,7 +4031,7 @@ class Solcast :
                 estimate_values = [self.estimate[r][hours_time(t)] for t in times]
                 plots[r] = estimate_values
         total_forecast = 0.0
-        if self.daily.get(day) is not None:
+        if hasattr(self, 'daily') and self.daily.get(day) is not None:
             sun_times = get_suntimes(day)
             print(f"\n{day}:\n  Sunrise {sun_times[0]}, Sunset {sun_times[1]}")
             forecast_values = [self.daily[day]['pt30'][hours_time(t - time_offset)] for t in times]
@@ -4343,7 +4354,7 @@ class Solar :
                 estimate_values = [c_float(self.estimate[r].get(hours_time(t))) for t in times]
                 plots[r] = estimate_values
         total_forecast = 0.0
-        if self.daily.get(day) is not None:
+        if hasattr(self, 'daily') and self.daily.get(day) is not None:
             sun_times = get_suntimes(day)
             print(f"\n{day}:\n  Sunrise {sun_times[0]}, Sunset {sun_times[1]}")
             forecast_values = [self.daily[day]['pt30'][hours_time(t)] for t in times]

foxesscloud-2.7.0/README.md → foxesscloud-2.7.2/src/foxesscloud.egg-info/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.1
+Name: foxesscloud
+Version: 2.7.2
+Summary: library for accessing Fox ESS cloud data using Open API
+Author-email: Tony Matthews <tony@quasair.co.uk>
+Project-URL: Homepage, https://github.com/TonyM1958/FoxESS-Cloud
+Project-URL: Bug Tracker, https://github.com/TonyM1958/FoxESS-Cloud/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENCE
+
 # FoxESS-Cloud
 
 <a href="https://www.buymeacoffee.com/tonym1958" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174" align="right"></a>
@@ -144,12 +158,12 @@ set_min() applies new SoC settings to the inverter. The parameters update batter
 + minSoc: min Soc setting e.g. 10 = 10%
 
 set_charge() takes the charge times from the battery_settings and applies these to the inverter. The parameters are optional and will update battery_settings. You should specify all 3 parameter for a time period:
-+ ch1: enable charge from grid for period 1 (True or False)
-+ st1: the start time for period 1
-+ en1: the end time for period 1
-+ ch2: enable charge from grid for period 2 (True or False)
-+ st2: the start time for period 2
-+ en2: the end time for period 2
++ ch1: enable charge from grid for period 1 (default True)
++ st1: the start time for period 1 (default 0)
++ en1: the end time for period 1 (default 0)
++ ch2: enable charge from grid for period 2 (default True)
++ st2: the start time for period 2 (default 0)
++ en2: the end time for period 2 (default 0)
 + enable: set to 0 to show settings but stop inverter settings being updated. Default is 1.
 
 set_period() returns a period structure that can be used to build a list for set_schedule()
@@ -793,6 +807,22 @@ This setting can be:
 
 # Version Info
 
+2.7.2<br>
+Fix to get_battery() to return error and flag status=0 in f.battery when the cloud is not returning valid data.
+Fix exception calculating SoH if ratedCapacity is returned as 0 when cloud is not returning valid data.
+Update charge_rate in charge_needed() to use a blended charge rate based on battery warming up during charging.
+Fix exception in set_charge() caused by incorrect default parameter values.
+Update charge_needed() to only show forecast that is in use.
+
+2.7.1<br>
+Update charge_needed() so it only gets generation history if there is no forecast to reduce API calls and save time.
+Update default parameter values for set_charge() so the other time period is cleared if you only set 1 time.
+Fix problem where a full charge was being set when charge_needed() is called with force_charge=1.
+Move charging to the end of the charge time when force_charge=1 so the charge time completes with the required charge.
+Update battery predictions to more accurately reflect what happens when SoC gets to min_soc or fd_soc.
+Correct model to use inverter operating losses instead of BMS losses when the battery is above min_soc.
+Correct exception in Solcast and Solar when a forecast is not available.
+
 2.7.0<br>
 Allow charge_loss / discharge_loss to be configured for charge_needed().
 Change 'Force Charge' to 'Battery Hold' in charge times to avoid confusion with Force Charge work mode.