foxesscloud 2.6.9__py3-none-any.whl → 2.7.1__py3-none-any.whl

foxesscloud/foxesscloud.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud
-Updated:  05 November 2024
+Updated:  07 November 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2023
 ##################################################################################################
 
-version = "1.8.0"
+version = "1.8.2"
 print(f"FoxESS-Cloud version {version}")
 
 debug_setting = 1
@@ -798,10 +798,10 @@ def get_charge():
 def time_period(t):
     result = f"{t['startTime']['hour']:02d}:{t['startTime']['minute']:02d}-{t['endTime']['hour']:02d}:{t['endTime']['minute']:02d}"
     if t['startTime']['hour'] != t['endTime']['hour'] or t['startTime']['minute'] != t['endTime']['minute']:
-        result += f" Charge from grid" if t['enableGrid'] else f" Force Charge"
+        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=0, st1=0, en1=True, ch2=0, st2=0, en2=True, force=0, enable=1):
     global device_sn, battery_settings, debug_setting, messages, schedule
     if get_device() is None:
         return None
@@ -1081,6 +1081,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:
@@ -1748,9 +1750,7 @@ def plot_raw(result, plot=1, station=0):
 def report_value_profile(result):
     if type(result) is not list or result[0]['type'] != 'day':
         return (None, None)
-    data = []
-    for h in range(0,24):
-        data.append((0.0, 0)) # value sum, count of values
+    data = [(0.0, 0) for h in range(0,24)]
     totals = 0
     n = 0
     for day in result:
@@ -1780,6 +1780,30 @@ def report_value_profile(result):
 # forwards compatibility
 get_history = get_raw
 
+# rescale history data based on time and steps
+def rescale_history(data, steps):
+    if data is None or len(data) < 1:
+        return None
+    result = [None for i in range(0, 24 * steps)]
+    bst = 1 if 'BST' in data[0]['time'] else 0
+    average = 0.0
+    n = 0
+    i = 0
+    for d in data:
+        h = round_time(time_hours(d['time'][11:]) + bst)
+        new_i = int(h * steps)
+        if new_i != i and i < len(result):
+            result[i] = average / n if n > 0 else None
+            average = 0.0
+            n = 0
+            i = new_i
+        if d['value'] is not None:
+            average += d['value']
+            n += 1
+    if n > 0 and i < len(result):
+        result[i] = average / n
+    return result
+
 ##################################################################################################
 # get energy report data in kWh
 ##################################################################################################
@@ -2752,8 +2776,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:
@@ -2780,41 +2804,55 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
     global charge_config, steps_per_hour
     allowed_drain = charge_config['allowed_drain'] if charge_config.get('allowed_drain') is not None else 4
     bms_loss = (charge_config['bms_power'] / 1000 if charge_config.get('bms_power') is not None else 0.05)
-    charge_loss = charge_config['charge_loss']
-    discharge_loss = charge_config['discharge_loss']
+    charge_loss = charge_config['_charge_loss']
+    discharge_loss = charge_config['_discharge_loss']
     charge_limit = charge_config['charge_limit']
     float_charge = charge_config['float_charge']
     run_time = len(work_mode_timed)
     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):
@@ -2874,6 +2912,8 @@ charge_config = {
     'dc_ac_loss': 0.970,              # loss converting battery DC power to AC grid power
     'pv_loss': 0.950,                 # loss converting PV power to DC battery charge power
     'ac_dc_loss': 0.963,              # loss converting AC grid power to DC battery charge power
+    'charge_loss': None,              # loss converting charge energy to stored energy
+    'discharge_loss': None,           # loss converting stored energy to discharge energy
     'inverter_power': 101,            # Inverter power consumption in W
     'bms_power': 50,                  # BMS power consumption in W
     'force_charge_power': 5.00,       # charge power in kW when using force charge
@@ -3020,14 +3060,14 @@ 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.46
         residual = test_soc * capacity / 100
         bat_volt = 317.4
         bat_power = 0.0
         temperature = 30
         bms_charge_current = 15
-        charge_loss = battery_params[2]['charge_loss']
-        discharge_loss = battery_params[2]['discharge_loss']
+        charge_loss = charge_config['charge_loss'] if charge_config.get('charge_loss') is not None else battery_params[2]['charge_loss']
+        discharge_loss = charge_config['discharge_loss'] if charge_config.get('discharge_loss') is not None else battery_params[2]['discharge_loss']
         bat_current = 0.0
         device_power = 6.0
         device_current = 35
@@ -3049,8 +3089,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             output(f"Battery capacity could not be estimated. Please add the parameter 'capacity=xx' in kWh")
             return None
         bms_charge_current = battery.get('charge_rate')
-        charge_loss = battery['charge_loss'] if battery.get('charge_loss') is not None else 0.974
-        discharge_loss = battery['discharge_loss'] if battery.get('discharge_loss') is not None else 0.974
+        charge_loss = charge_config['charge_loss'] if charge_config.get('charge_loss') is not None else battery['charge_loss'] if battery.get('charge_loss') is not None else 0.974
+        discharge_loss = charge_config['discharge_loss'] if charge_config.get('discharge_loss') is not None else battery['discharge_loss'] if battery.get('discharge_loss') is not None else 0.974
         device_power = device.get('power')
         device_current = device.get('max_charge_current')
         model = device.get('deviceType')
@@ -3079,7 +3119,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     output(f"  Temperature: {temperature:.1f}°C")
     output(f"  Resistance:  {bat_resistance:.2f} ohms")
     output(f"  Nominal OCV: {bat_ocv:.1f}V at {nominal_soc}% SoC")
-    output(f"  Losses:      {charge_loss * 100:.1f}% charge / {discharge_loss * 100:.1f}% discharge")
+    output(f"  Losses:      {charge_loss * 100:.1f}% charge / {discharge_loss * 100:.1f}% discharge", 2)
     # inverter losses
     inverter_power = charge_config['inverter_power'] if charge_config['inverter_power'] is not None else round(device_power, 0) * 25
     operating_loss = inverter_power / 1000
@@ -3108,8 +3148,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     charge_config['charge_limit'] = charge_limit
     charge_config['charge_power'] = charge_power
     charge_config['float_charge'] = float_charge
-    charge_config['charge_loss'] = charge_loss
-    charge_config['discharge_loss'] = discharge_loss
+    charge_config['_charge_loss'] = charge_loss
+    charge_config['_discharge_loss'] = discharge_loss
     # display what we have
     output(f"\ncharge_config = {json.dumps(charge_config, indent=2)}", 3)
     output(f"\nDevice Info:")
@@ -3171,27 +3211,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             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
     quarter = int(today[5:7] if charge_today else tomorrow[5:7]) // 3 % 4
     sun_name = seasonal_sun[quarter]['name']
@@ -3209,11 +3228,32 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     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
     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:
@@ -3221,7 +3261,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
@@ -3233,19 +3273,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]
@@ -3258,8 +3296,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):
@@ -3278,7 +3315,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
@@ -3289,30 +3325,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
@@ -3335,8 +3371,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})")
@@ -4304,17 +4341,9 @@ class Solcast :
         total_actual = None
         self.actual = get_history('day', d=day, v=v)
         plots = {}
+        times = [i/2 for i in range(0, 48)]
         for v in self.actual:
-            times = []
-            actual_values = []
-            average = 0.0
-            for i in range(0, len(v.get('data'))):
-                average += v['data'][i]['value'] / 6
-                if i % 6 == 5:
-                    times.append(round_time((i - 5) / 12))
-                    actual_values.append(average)
-                    average = 0
-            plots[v['variable']] = actual_values
+            plots[v['variable']] = rescale_history(v.get('data'), 2)
             if v['variable'] == 'pvPower':
                 total_actual = v.get('kwh')
         if total_actual is None:
@@ -4340,16 +4369,16 @@ 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]
             total_forecast = sum(forecast_values) / 2
             plots['forecast'] = forecast_values
-        if total_actual is not None:
-            print(f"  Total actual: {total_actual:.3f}kWh")
         if total_forecast is not None:
             print(f"  Total forecast: {total_forecast:.3f}kWh")
+        if total_actual is not None:
+            print(f"  Total actual: {total_actual:.3f}kWh")
         print()
         title = f"Forecast / Actual PV Power on {day}"
         plt.figure(figsize=(figure_width, figure_width/3))
@@ -4637,17 +4666,9 @@ class Solar :
         total_actual = None
         self.actual = get_history('day', d=day, v=v)
         plots = {}
+        times = [i/2 for i in range(0, 48)]
         for v in self.actual:
-            times = []
-            actual_values = []
-            average = 0.0
-            for i in range(0, len(v.get('data'))):
-                average += v['data'][i]['value'] / 6
-                if i % 6 == 5:
-                    times.append(round_time((i - 5) / 12))
-                    actual_values.append(average)
-                    average = 0
-            plots[v['variable']] = actual_values
+            plots[v['variable']] = rescale_history(v.get('data'), 2)
             if v['variable'] == 'pvPower':
                 total_actual = v.get('kwh')
         if total_actual is None:
@@ -4671,16 +4692,16 @@ 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]
             total_forecast = sum(forecast_values) / 2
             plots['forecast'] = forecast_values
-        if total_actual is not None:
-            print(f"  Total actual: {total_actual:.3f}kWh")
         if total_forecast is not None:
             print(f"  Total forecast: {total_forecast:.3f}kWh")
+        if total_actual is not None:
+            print(f"  Total actual: {total_actual:.3f}kWh")
         print()
         title = f"Forecast / Actual PV Power on {day}"
         plt.figure(figsize=(figure_width, figure_width/3))

foxesscloud/openapi.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud using Open API
-Updated:  05 November 2024
+Updated:  07 November 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2024
 ##################################################################################################
 
-version = "2.6.9"
+version = "2.7.1"
 print(f"FoxESS-Cloud Open API version {version}")
 
 debug_setting = 1
@@ -671,10 +671,10 @@ def time_period(t, n):
     (enable, start, end) = (t['enable1'], t['startTime1'], t['endTime1']) if n == 1 else (t['enable2'], t['startTime2'], t['endTime2'])
     result = f"{start['hour']:02d}:{start['minute']:02d}-{end['hour']:02d}:{end['minute']:02d}"
     if start['hour'] != end['hour'] or start['minute'] != end['minute']:
-        result += f" Charge from grid" if enable else f" Force Charge"
+        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=0, st1=0, en1=True, ch2=0, st2=0, en2=True, force = 0, enable=1):
     global device_sn, battery_settings, debug_setting, time_period_vars
     if get_device() is None:
         return None
@@ -1448,9 +1448,7 @@ get_raw = get_history
 def report_value_profile(result):
     if type(result) is not list or result[0]['type'] != 'day':
         return (None, None)
-    data = []
-    for h in range(0,24):
-        data.append((0.0, 0)) # value sum, count of values
+    data = [(0.0, 0) for h in range(0,24)]
     totals = 0
     n = 0
     for day in result:
@@ -1477,6 +1475,30 @@ def report_value_profile(result):
         result.append(by_hour[t] * daily_average / current_total)
     return (daily_average, result)
 
+# rescale history data based on time and steps
+def rescale_history(data, steps):
+    if data is None:
+        return None
+    result = [None for i in range(0, 24 * steps)]
+    bst = 1 if 'BST' in data[0]['time'] else 0
+    average = 0.0
+    n = 0
+    i = 0
+    for d in data:
+        h = round_time(time_hours(d['time'][11:]) + bst)
+        new_i = int(h * steps)
+        if new_i != i and i < len(result):
+            result[i] = average / n if n > 0 else None
+            average = 0.0
+            n = 0
+            i = new_i
+        if d['value'] is not None:
+            average += d['value']
+            n += 1
+    if n > 0 and i < len(result):
+        result[i] = average / n
+    return result
+
 
 ##################################################################################################
 # get production report in kWh
@@ -2417,8 +2439,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:
@@ -2444,41 +2466,55 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
     global charge_config, steps_per_hour
     allowed_drain = charge_config['allowed_drain'] if charge_config.get('allowed_drain') is not None else 4
     bms_loss = (charge_config['bms_power'] / 1000 if charge_config.get('bms_power') is not None else 0.05)
-    charge_loss = charge_config['charge_loss']
-    discharge_loss = charge_config['discharge_loss']
+    charge_loss = charge_config['_charge_loss']
+    discharge_loss = charge_config['_discharge_loss']
     charge_limit = charge_config['charge_limit']
     float_charge = charge_config['float_charge']
     run_time = len(work_mode_timed)
     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):
@@ -2538,6 +2574,8 @@ charge_config = {
     'dc_ac_loss': 0.97,               # loss converting battery DC power to AC grid power
     'pv_loss': 0.95,                  # loss converting PV power to DC battery charge power
     'ac_dc_loss': 0.963,              # loss converting AC grid power to DC battery charge power
+    'charge_loss': None,              # loss converting charge energy to stored energy
+    'discharge_loss': None,           # loss converting stored energy to discharge energy
     'inverter_power': 101,            # Inverter power consumption in W
     'bms_power': 50,                  # BMS power consumption in W
     'force_charge_power': 5.00,       # charge power in kW when using force charge
@@ -2684,14 +2722,14 @@ 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.46
         residual = test_soc * capacity / 100
         bat_volt = 317.4
         bat_power = 0.0
         temperature = 30
         bms_charge_current = 15
-        charge_loss = battery_params[2]['charge_loss']
-        discharge_loss = battery_params[2]['discharge_loss']
+        charge_loss = charge_config['charge_loss'] if charge_config.get('charge_loss') is not None else battery_params[2]['charge_loss']
+        discharge_loss = charge_config['discharge_loss'] if charge_config.get('discharge_loss') is not None else battery_params[2]['discharge_loss']
         bat_current = 0.0
         device_power = 6.0
         device_current = 35
@@ -2713,8 +2751,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             output(f"Battery capacity could not be estimated. Please add the parameter 'capacity=xx' in kWh")
             return None
         bms_charge_current = battery.get('charge_rate')
-        charge_loss = battery['charge_loss'] if battery.get('charge_loss') is not None else 0.974
-        discharge_loss = battery['discharge_loss'] if battery.get('discharge_loss') is not None else 0.974
+        charge_loss = charge_config['charge_loss'] if charge_config.get('charge_loss') is not None else battery['charge_loss'] if battery.get('charge_loss') is not None else 0.974
+        discharge_loss = charge_config['discharge_loss'] if charge_config.get('discharge_loss') is not None else battery['discharge_loss'] if battery.get('discharge_loss') is not None else 0.974
         device_power = device.get('power')
         device_current = device.get('max_charge_current')
         model = device.get('deviceType')
@@ -2743,6 +2781,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     output(f"  Max Charge:  {charge_current:.1f}A")
     output(f"  Resistance:  {bat_resistance:.2f} ohms")
     output(f"  Nominal OCV: {bat_ocv:.1f}V at {nominal_soc}% SoC")
+    output(f"  Losses:      {charge_loss * 100:.1f}% charge / {discharge_loss * 100:.1f}% discharge", 2)
     # charge current may be derated based on temperature
     charge_current = device_current if charge_config['charge_current'] is None else charge_config['charge_current']
     if charge_current > bms_charge_current:
@@ -2775,8 +2814,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     charge_config['charge_limit'] = charge_limit
     charge_config['charge_power'] = charge_power
     charge_config['float_charge'] = float_charge
-    charge_config['charge_loss'] = charge_loss
-    charge_config['discharge_loss'] = discharge_loss
+    charge_config['_charge_loss'] = charge_loss
+    charge_config['_discharge_loss'] = discharge_loss
     # display what we have
     output(f"\ncharge_config = {json.dumps(charge_config, indent=2)}", 3)
     output(f"\nDevice Info:")
@@ -2837,27 +2876,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             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
     quarter = int(today[5:7] if charge_today else tomorrow[5:7]) // 3 % 4
     sun_name = seasonal_sun[quarter]['name']
@@ -2875,11 +2893,32 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     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
     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:
@@ -2887,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
@@ -2899,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]
@@ -2924,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
@@ -2944,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
@@ -2955,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
@@ -3001,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})")
@@ -3967,17 +4003,9 @@ class Solcast :
         total_actual = None
         self.actual = get_history('day', d=day, v=v)
         plots = {}
+        times = [i/2 for i in range(0, 48)]
         for v in self.actual:
-            times = []
-            actual_values = []
-            average = 0.0
-            for i in range(0, len(v.get('data'))):
-                average += v['data'][i]['value'] / 6
-                if i % 6 == 5:
-                    times.append(round_time((i - 5) / 12))
-                    actual_values.append(average)
-                    average = 0
-            plots[v['variable']] = actual_values
+            plots[v['variable']] = rescale_history(v.get('data'), 2)
             if v['variable'] == 'pvPower':
                 total_actual = v.get('kwh')
         if total_actual is None:
@@ -4003,16 +4031,16 @@ 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]
             total_forecast = sum(forecast_values) / 2
             plots['forecast'] = forecast_values
-        if total_actual is not None:
-            print(f"  Total actual: {total_actual:.3f}kWh")
         if total_forecast is not None:
             print(f"  Total forecast: {total_forecast:.3f}kWh")
+        if total_actual is not None:
+            print(f"  Total actual: {total_actual:.3f}kWh")
         print()
         title = f"Forecast / Actual PV Power on {day}"
         plt.figure(figsize=(figure_width, figure_width/3))
@@ -4300,17 +4328,9 @@ class Solar :
         total_actual = None
         self.actual = get_history('day', d=day, v=v)
         plots = {}
+        times = [i/2 for i in range(0, 48)]
         for v in self.actual:
-            times = []
-            actual_values = []
-            average = 0.0
-            for i in range(0, len(v.get('data'))):
-                average += v['data'][i]['value'] / 6
-                if i % 6 == 5:
-                    times.append(round_time((i - 5) / 12))
-                    actual_values.append(average)
-                    average = 0
-            plots[v['variable']] = actual_values
+            plots[v['variable']] = rescale_history(v.get('data'), 2)
             if v['variable'] == 'pvPower':
                 total_actual = v.get('kwh')
         if total_actual is None:
@@ -4334,16 +4354,16 @@ 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]
             total_forecast = sum(forecast_values) / 2
             plots['forecast'] = forecast_values
-        if total_actual is not None:
-            print(f"  Total actual: {total_actual:.3f}kWh")
         if total_forecast is not None:
             print(f"  Total forecast: {total_forecast:.3f}kWh")
+        if total_actual is not None:
+            print(f"  Total actual: {total_actual:.3f}kWh")
         print()
         title = f"Forecast / Actual PV Power on {day}"
         plt.figure(figsize=(figure_width, figure_width/3))

{foxesscloud-2.6.9.dist-info → foxesscloud-2.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxesscloud
-Version: 2.6.9
+Version: 2.7.1
 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()
@@ -341,7 +341,7 @@ The previous section provides functions that can be used to access and control y
 Uses forecast PV yield for tomorrow to work out if charging from grid is needed tonight to deliver the expected consumption for tomorrow. If charging is needed, the charge times are configured. If charging is not needed, the charge times are cleared. The results are sent to the inverter.
 
 ```
-f.charge_needed(forecast, force_charge, forecast_selection, forecast_times, update_setings, show_data, show_plot)
+f.charge_needed(forecast, force_charge, forecast_selection, forecast_times, update_setings, show_data, show_plot, timed_mode)
 ```
 
 All the parameters are optional:
@@ -352,6 +352,7 @@ All the parameters are optional:
 + update_settings: 0 no changes, 1 update charge settings. The default is 0
 + show_data: 1 show battery SoC data, 2 show battery Residual data, 3 show timed data. The default is 1.
 + show_plot: 1 plot battery SoC data. 2 plot battery Residual, Generation and Consumption. 3 plot 2 + Charge and Discharge The default is 3
++ timed_mode: 0 use charge times, 1 use charge times and follow strategy, 2 use Mode Scheduler
 
 ### Modelling
 
@@ -394,6 +395,8 @@ export_limit: None             # maximum export power in kW. None uses the inver
 dc_ac_loss: 0.970              # loss converting battery DC power to AC grid power
 pv_loss: 0.950                 # loss converting PV power to DC battery charge power
 ac_dc_loss: 0.960              # loss converting AC grid power to DC battery charge power
+charge_loss: None              # loss converting charge energy to stored energy
+discharge_loss: None           # loss converting stored energy to discharge energy
 inverter_power: None           # inverter power consumption in W (dynamically set)
 bms_power: 50                  # BMS power consumption in W
 force_charge_power: 5.00       # power used when Force Charge is scheduled
@@ -804,6 +807,21 @@ This setting can be:
 
 # Version Info
 
+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.
+Correct problem with missing periods of actual data in forecast.compare()
+
 2.6.9<br>
 Add get and set_named_settings() (for WorkMode and ExportLimit).
 If a list of named settings is provided, the return value is a list indicating which settings succeeded (1) or failed (0).

foxesscloud-2.7.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+foxesscloud/foxesscloud.py,sha256=rV8qX1sJyXEvmyie8kvJSFVd3sU-a-9Zcy-i-ag_gTQ,222996
+foxesscloud/openapi.py,sha256=0oxiSNedH_9UnSDQmNaeXgPIaTvwqzg3fa1Dupdi7yQ,206923
+foxesscloud-2.7.1.dist-info/LICENCE,sha256=-3xv8CElCJV8Bc8PbAsg3iyxMpAK8MoJneM3rXigxqI,1074
+foxesscloud-2.7.1.dist-info/METADATA,sha256=Bl4xmInDDpLjnt1pp-Zn_N8dkBzxncEPlq-HPB2ZHts,61833
+foxesscloud-2.7.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+foxesscloud-2.7.1.dist-info/top_level.txt,sha256=IWOrKSNZCLU6IDXSX_b4_bqCfbZoWAT4CC0w0Lg7PuU,12
+foxesscloud-2.7.1.dist-info/RECORD,,

foxesscloud-2.6.9.dist-info/RECORD

@@ -1,7 +0,0 @@
-foxesscloud/foxesscloud.py,sha256=2rBhstr0ZH9PxvCipZhxf79JN7xQ_CqQc_xRyy-0Yd4,221818
-foxesscloud/openapi.py,sha256=NncnwOSohoTTVWLELZWfkXnD5Peav6gl8aq2tRGsizk,205719
-foxesscloud-2.6.9.dist-info/LICENCE,sha256=-3xv8CElCJV8Bc8PbAsg3iyxMpAK8MoJneM3rXigxqI,1074
-foxesscloud-2.6.9.dist-info/METADATA,sha256=NfNht53QGiO5BHMY-SMM6zo49qPS1HQHE4yKo3O_mLI,60502
-foxesscloud-2.6.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-foxesscloud-2.6.9.dist-info/top_level.txt,sha256=IWOrKSNZCLU6IDXSX_b4_bqCfbZoWAT4CC0w0Lg7PuU,12
-foxesscloud-2.6.9.dist-info/RECORD,,