foxesscloud 2.5.7__py3-none-any.whl → 2.5.9__py3-none-any.whl

foxesscloud/foxesscloud.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud
-Updated:  28 September 2024
+Updated:  02 October 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2023
 ##################################################################################################
 
-version = "1.6.9"
+version = "1.7.1"
 print(f"FoxESS-Cloud version {version}")
 
 debug_setting = 1
@@ -83,16 +83,17 @@ def query_date(d, offset = None):
     return {'year': t.year, 'month': t.month, 'day': t.day, 'hour': t.hour, 'minute': t.minute, 'second': t.second}
 
 # interpolate a result from a list of values
-def interpolate(f, v):
+def interpolate(f, v, wrap=0):
     if len(v) == 0:
         return None
     if f < 0.0:
         return v[0]
-    elif f >= len(v) - 1:
+    elif wrap == 0 and f >= len(v) - 1:
         return v[-1]
-    i = int(f)
-    x = f - i
-    return v[i] * (1-x) + v[i+1] * x
+    i = int(f) % len(v)
+    x = f % 1.0
+    j = (i + 1) %  len(v)
+    return v[i] * (1-x) + v[j] * x
 
 # build request header with signing
 http_timeout = 55       # http request timeout in seconds
@@ -575,7 +576,9 @@ def get_firmware():
 
 battery = None
 battery_settings = None
-residual_handling = 1 # set to 2 if Residual returns current capacity
+
+# 1 = returns Residual Energy. 2 = resturns Residual Capacity
+residual_handling = 1
 
 def get_battery(info=0):
     global token, device_id, battery, debug_setting, messages
@@ -648,12 +651,12 @@ def get_charge():
 
 # helper to format time period structure
 def time_period(t):
-    result = f"{t['startTime']['hour']:02d}:{t['startTime']['minute']:02d} - {t['endTime']['hour']:02d}:{t['endTime']['minute']:02d}"
+    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"
     return result
 
-def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force=0):
+def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force=0, enable=1):
     global token, device_sn, battery_settings, debug_setting, messages, schedule
     if get_device() is None:
         return None
@@ -703,6 +706,8 @@ def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force
     output(f"\nSetting time periods:", 1)
     output(f"   Time Period 1 = {time_period(battery_settings['times'][0])}", 1)
     output(f"   Time Period 2 = {time_period(battery_settings['times'][1])}", 1)
+    if enable == 0:
+        return battery_settings
     # set charge times
     data = {'sn': device_sn, 'times': battery_settings.get('times')}
     setting_delay()
@@ -721,35 +726,6 @@ def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force
         output(f"success", 2) 
     return battery_settings
 
-def charge_periods(st1=None, en1=None, st2=None, en2=None, min_soc=10, end_soc=100, start_soc=10):
-    output(f"\nConfiguring schedule",1)
-    charge = []
-    st1 = time_hours(st1)
-    en1 = time_hours(en1)
-    st2 = time_hours(st2)
-    en2 = time_hours(en2)
-    span = None
-    if st2 is not None and en2 is not None and st2 != en2:
-        charge.append({'start': st2, 'end': en2, 'mode': 'ForceCharge', 'min_soc': min_soc, 'max_soc': end_soc})
-        span = {'start': st2, 'end': en2}
-        if st1 is not None and en1 is not None and st1 != en1:
-            charge.append({'start': st1, 'end': en1, 'mode': 'SelfUse', 'min_soc': start_soc})
-            span = {'start': st1, 'end': en2}
-    elif st1 is not None and en1 is not None and st1 != en1:
-        span = {'start': st1, 'end': en1}
-        if round_time(en1 - st1) > 0.25:
-            st3 = round_time(en1 - 5 / 60)
-            charge.append({'start': st1, 'end': st3, 'mode': 'SelfUse', 'min_soc': start_soc})
-            st1 = st3
-        charge.append({'start': st1, 'end': en1, 'mode': 'SelfUse', 'min_soc': min_soc})
-    strategy = get_strategy(remove=span, limit=24)[:(8 - len(charge))]
-    for c in charge:
-        strategy.append(c)
-    periods = []
-    for s in sorted(strategy, key=lambda s: s['start']):
-        periods.append(set_period(segment = s, quiet=0))
-    return periods
-
 ##################################################################################################
 # get min soc settings and save in battery_settings
 ##################################################################################################
@@ -1270,7 +1246,7 @@ def set_period(start=None, end=None, mode=None, min_soc=None, max_soc=None, fdso
         return None
     if quiet == 0:
         s = f"   {hours_time(start)}-{hours_time(end)} {mode}, minsoc {min_soc}%"
-        s += f", maxsoc {max_soc}%" if max_soc is not None else ""
+        s += f", maxsoc {max_soc}%" if max_soc is not None and mode == 'ForceCharge' else ""
         s += f", fdPwr {fdpwr}W, fdSoC {fdsoc}%" if mode == 'ForceDischarge' else ""
         s += f", {price:.2f}p/kWh" if price is not None else ""
         output(s, 1)
@@ -2122,7 +2098,7 @@ def hours_difference(t1, t2):
 # time periods for Octopus Flux
 octopus_flux = {
     'name': 'Octopus Flux',
-    'off_peak1': {'start': 2.0, 'end': 5.0, 'force': 1},        # off-peak period 1 / am charging period
+    'off_peak1': {'start': 2.0, 'end': 5.0, 'hold': 1},         # off-peak period 1 / am charging period
     'peak1': {'start': 16.0, 'end': 19.0 },                     # peak period 1
     'forecast_times': [21, 22],                                 # hours in a day to get a forecast
     'strategy': [
@@ -2133,16 +2109,16 @@ octopus_flux = {
 # time periods for Intelligent Octopus
 intelligent_octopus = {
     'name': 'Intelligent Octopus',
-    'off_peak1': {'start': 23.5, 'end': 5.5, 'force': 1},
+    'off_peak1': {'start': 23.5, 'end': 5.5, 'hold': 1},
     'forecast_times': [21, 22]
     }
 
 # time periods for Octopus Cosy
 octopus_cosy = {
     'name': 'Octopus Cosy',
-    'off_peak1': {'start': 4.0, 'end': 7.0, 'force': 1},
-    'off_peak2': {'start': 13.0, 'end': 16.0, 'force': 0},
-    'off_peak3': {'start': 22.0, 'end': 24.0, 'force': 0},
+    'off_peak1': {'start': 4.0, 'end': 7.0, 'hold': 1},
+    'off_peak2': {'start': 13.0, 'end': 16.0, 'hold': 0},
+    'off_peak3': {'start': 22.0, 'end': 24.0, 'hold': 0},
     'peak1': {'start': 16.0, 'end': 19.0 },
     'forecast_times': [10, 11, 21, 22]
     }
@@ -2150,15 +2126,15 @@ octopus_cosy = {
 # time periods for Octopus Go
 octopus_go = {
     'name': 'Octopus Go',
-    'off_peak1': {'start': 0.5, 'end': 4.5, 'force': 1},
+    'off_peak1': {'start': 0.5, 'end': 4.5, 'hold': 1},
     'forecast_times': [21, 22]
     }
 
 # time periods for Agile Octopus
 agile_octopus = {
     'name': 'Agile Octopus',
-    'off_peak1': {'start':  0.0, 'end':  6.0, 'force': 1},
-    'off_peak2': {'start': 12.0, 'end': 16.0, 'force': 0},
+    'off_peak1': {'start':  0.0, 'end':  6.0, 'hold': 1},
+    'off_peak2': {'start': 12.0, 'end': 16.0, 'hold': 0},
     'peak1': {'start': 16.0, 'end': 19.0 },
     'forecast_times': [9, 10, 21, 22],
     'strategy': [],
@@ -2168,27 +2144,27 @@ agile_octopus = {
 # time periods for British Gas Electric Driver
 bg_driver = {
     'name': 'British Gas Electric Driver',
-    'off_peak1': {'start': 0.0, 'end': 5.0, 'force': 1},
+    'off_peak1': {'start': 0.0, 'end': 5.0, 'hold': 1},
     'forecast_times': [21, 22]
     }
 
 # time periods for EON Next Drive
 eon_drive = {
     'name': 'EON NextDrive',
-    'off_peak1': {'start': 0.0, 'end': 7.0, 'force': 1},
+    'off_peak1': {'start': 0.0, 'end': 7.0, 'hold': 1},
     'forecast_times': [21, 22]
     }
 
 # time periods for Economy 7
 economy_7 = {
     'name': 'Eco 7',
-    'off_peak1': {'start': 0.5, 'end': 7.5, 'force': 1, 'gmt': 1},
+    'off_peak1': {'start': 0.5, 'end': 7.5, 'hold': 1, 'gmt': 1},
     'forecast_times': [21, 22]
     }
 
 # custom time periods / template
 custom_periods = {'name': 'Custom',
-    'off_peak1': {'start': 2.0, 'end': 5.0, 'force': 1},
+    'off_peak1': {'start': 2.0, 'end': 5.0, 'hold': 1},
     'peak1': {'start': 16.0, 'end': 19.0 },
     'forecast_times': [21, 22]
     }
@@ -2208,8 +2184,10 @@ test_strategy = [
         {'start': 21, 'end': 22, 'mode': 'ForceCharge'}]
 
 # return a strategy that has been sorted and filtered for charge times:
-def get_strategy(use=None, strategy=None, quiet=1, remove=None, reserve=0, limit=None):
+def get_strategy(use=None, strategy=None, quiet=1, remove=None, reserve=0, limit=24, timed_mode=1):
     global tariff, base_time
+    if timed_mode == 0:
+        return []
     if use is None:
         use = tariff
     base_time_adjust = 0
@@ -2218,11 +2196,12 @@ def get_strategy(use=None, strategy=None, quiet=1, remove=None, reserve=0, limit
         if tariff.get('strategy') is not None:
             for s in tariff['strategy']:
                 strategy.append(s)
-        if use.get('agile') is not None and use['agile'].get('strategy') is not None:
+        if timed_mode > 1 and use.get('agile') is not None and use['agile'].get('strategy') is not None:
             base_time_adjust = hours_difference(base_time, use['agile'].get('base_time') )
             for s in use['agile']['strategy']:
-                if limit is None or s.get('hour') is None or s['hour'] - base_time_adjust < 24:
-                    s['valid_for'] = [int((s['hour'] - base_time_adjust) * steps_per_hour + i) for i in range(0, steps_per_hour // 2)] if s.get('hour') is not None else None
+                hour = (s['hour'] - base_time_adjust) if limit is not None and s.get('hour') is not None else None
+                if hour is None or (hour >= 0 and hour < limit):
+                    s['valid_for'] = [hour * steps_per_hour + i for i in range(0, steps_per_hour // 2)] if hour is not None else None
                     strategy.append(s)
     if strategy is None or len(strategy) == 0:
         return []
@@ -2271,8 +2250,8 @@ tariff_config = {
     'region': "H",                        # region code to use for Octopus API
     'update_time': 16.5,                  # time in hours when tomrow's data can be fetched
     'weighting': None,                    # weights for weighted average
-    'plunge_price': [3, 10],              # plunge price in p/kWh inc VAT over 24 hours from 7am, 7pm
-    'plunge_slots': 8,                    # number of 30 minute slots to use
+    'plunge_price': [3, 3],               # plunge price in p/kWh inc VAT over 24 hours from 7am, 7pm
+    'plunge_slots': 6,                    # number of 30 minute slots to use
     'data_wrap': 6,                       # prices to show per line
     'show_data': 1,                       # show pricing data
     'show_plot': 1                        # plot pricing data
@@ -2363,7 +2342,7 @@ def get_agile_times(tariff=agile_octopus, d=None):
         col = (now.hour * 2) % data_wrap
         s = f"\nPrice p/kWh inc VAT on {today}:"
         for i in range(0, len(prices)):
-            s += (f"\n  {prices[i]['time']} " + " " * col * 6) if i == 0 or col == 0 else ""
+            s += f"\n  {prices[i]['time']}" if i == 0 or col == 0 else ""
             s += f"  {prices[i]['price']:4.1f}"
             col = (col + 1) % data_wrap
         output(s)
@@ -2481,7 +2460,7 @@ def set_tariff(find, update=1, times=None, forecast_times=None, strategy=None, d
             use[key]['start'] = time_hours(t[1])
             use[key]['end'] = time_hours(t[2])
             if len(t) > 3:
-                use[key]['force'] = t[3]
+                use[key]['hold'] = t[3]
             gmt = ' GMT' if tariff[key].get('gmt') is not None else ''
             output(f"  {key} period: {hours_time(t[1])}-{hours_time(t[2])}{gmt}")
     # update dynamic charge times
@@ -2556,10 +2535,11 @@ def timed_list(data, base_hour, run_time):
     result = []
     h = base_hour
     for t in range(0, run_time):
-        result.append(data[int(h)])
+        result.append(interpolate(h, data, wrap=1))
         h = round_time(h + 1 / steps_per_hour)
     return result
 
+# align forecast with base_hour and expand to cover run_time
 def forecast_value_timed(forecast, today, tomorrow, base_hour, run_time, time_offset=0):
     global steps_per_hour
     profile = []
@@ -2588,10 +2568,11 @@ def strategy_timed(timed_mode, base_hour, run_time, min_soc=10, max_soc=100, cur
     min_soc_now = min_soc
     max_soc_now = max_soc
     current_mode = 'SelfUse' if current_mode is None else current_mode
-    strategy = get_strategy() if timed_mode > 0 else None
+    strategy = get_strategy(timed_mode=timed_mode)
     h = base_hour
     for i in range(0, run_time):
-        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}
+        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}
         if strategy is not None:
             period['mode'] = 'SelfUse'
             for d in strategy:
@@ -2613,22 +2594,23 @@ def strategy_timed(timed_mode, base_hour, run_time, min_soc=10, max_soc=100, cur
     return work_mode_timed
 
 # build the timed battery residual from the charge / discharge, work mode and min_soc
+# all power values are as measured at the inverter battery connection
 def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=None, reserve_drain=None):
-    global charge_config, steps_per_hour
-    bat_timed = []
+    global charge_config, steps_per_hour, residual_handling
     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']
+    charge_loss = charge_config['charge_loss'][residual_handling - 1]
+    discharge_loss = charge_config['discharge_loss'][residual_handling - 1]
     charge_limit = charge_config['charge_limit']
     float_charge = charge_config['float_charge']
     for i in range(0, len(work_mode_timed)):
-        bat_timed.append(kwh_current)
         w = work_mode_timed[i]
+        w['kwh'] = 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'] - w['discharge']) / charge_loss / steps_per_hour
+        kwh_current += (w['pv'] * charge_loss - w['discharge'] / discharge_loss) / steps_per_hour
         if kwh_current > capacity:
             # battery is full
             kwh_current = capacity
@@ -2649,7 +2631,45 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
             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 (bat_timed, kwh_min)
+    return ([work_mode_timed[i]['kwh'] for i in range(0, len(work_mode_timed))], 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):
+    global steps_per_hour
+    strategy = []
+    start = base_hour
+    times = []
+    for t in range(0, min([24 * steps_per_hour, len(work_mode_timed)])):
+        period = times[0] if len(times) > 0 else work_mode_timed[0]
+        next_period = work_mode_timed[t]
+        h = base_hour + t / steps_per_hour
+        if h == 24 or period['mode'] != next_period['mode'] or period['hold'] != next_period['hold']:
+            s = {'start': start % 24, 'end': h % 24, 'mode': period['mode'], 'min_soc': period['min_soc']}
+            if period['mode'] == 'ForceDischarge':
+                s['fdsoc'] = period.get('fdsoc')
+                s['fdpwr'] = period.get('fdpwr')
+            elif period['mode'] == 'ForceCharge':
+                s['max_soc'] = period.get('max_soc')
+            elif period['mode'] == 'SelfUse' and period['hold'] == 1:
+                s['min_soc'] = min([int(period['kwh'] / capacity * 100 + 0.5), 100])
+                s['end'] = (start + 1 / steps_per_hour) % 24
+                for p in times:
+                    p['min_soc'] = s['min_soc']
+            if s['mode'] != 'SelfUse' or s['min_soc'] != min_soc:
+                strategy.append(s)
+            start = h
+            times = []
+        times.append(work_mode_timed[t])
+    if len(strategy) == 0:
+        return []
+    if strategy[-1]['min_soc'] != min_soc:
+        strategy.append({'start': start %24, 'end': (start + 1 / steps_per_hour) % 24, 'mode': 'SelfUse', 'min_soc': min_soc})
+    output(f"\nConfiguring schedule:",1)
+    periods = []
+    for s in strategy:
+        periods.append(set_period(segment = s, quiet=0))
+    return periods
+
 
 # Battery open circuit voltage (OCV) from 0% to 100% SoC
 #                 0%     10%    20%    30%    40%    50%    60%    70%    80%    90%   100%
@@ -2668,9 +2688,11 @@ charge_config = {
     'charge_current': None,           # max battery charge current setting in A
     'discharge_current': None,        # max battery discharge current setting in A
     'export_limit': None,             # maximum export power in kW
-    'discharge_loss': 0.97,           # loss converting battery discharge power to grid power
-    'pv_loss': 0.95,                  # loss converting PV power to battery charge power
-    'grid_loss': 0.975,               # loss converting grid power to battery charge power
+    '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': [0.975, 1.040],    # loss in battery energy for each kWh added (based on residual_handling)
+    'discharge_loss': [0.975, 0.975], # loss in battery energy for each kWh removed (based on residual_handling)
     '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
@@ -2691,11 +2713,11 @@ charge_config = {
     'special_contingency': 33,        # contingency for special days when consumption might be higher
     'special_days': ['12-25', '12-26', '01-01'],
     'full_charge': None,              # day of month (1-28) to do full charge, or 'daily' or 'Mon', 'Tue' etc
-    'derate_temp': 22,                # battery temperature where cold derating starts to be applied
+    'derate_temp': 28,                # BMS temperature when cold derating starts to be applied
     'derate_step': 5,                 # scale for derating factors in C
-    'derating': [24, 15, 10, 2],      # max charge current e.g. 5C step = 22C, 17C, 12C, 7C
+    'derating': [24, 15, 10, 2],      # max charge current de-rating
     'data_wrap': 6,                   # data items to show per line
-    'target_soc': None,               # set the target SoC for charging
+    'target_soc': None,               # the target SoC for charging (over-rides calculated value)
     'shading': {                      # effect of shading on Solcast / forecast.solar
         'solcast': {'adjust': 0.95, 'am_delay': 1.0, 'am_loss': 0.2, 'pm_delay': 1.0, 'pm_loss': 0.2},
         'solar':   {'adjust': 1.20, 'am_delay': 1.0, 'am_loss': 0.2, 'pm_delay': 1.0, 'pm_loss': 0.2}
@@ -2713,12 +2735,12 @@ charge_needed_app_key = "awcr5gro2v13oher3v1qu6hwnovp28"
 #  show_plot: 1 plots battery SoC, 2 plots battery residual. Default = 1
 #  run_after: 0 over-rides 'forecast_times'. The default is 1.
 #  forecast_times: list of hours when forecast can be fetched (UTC)
-#  force_charge: 1 = set force charge, 2 = charge for whole period
+#  force_charge: 1 = hold battery, 2 = charge for whole period
 
 def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=None, show_plot=None, run_after=None, reload=2,
         forecast_times=None, force_charge=0, test_time=None, test_soc=None, test_charge=None, **settings):
     global device, seasonality, solcast_api_key, debug_setting, tariff, solar_arrays, legend_location, time_shift, charge_needed_app_key
-    global timed_strategy, steps_per_hour, base_time, storage
+    global timed_strategy, steps_per_hour, base_time, storage, residual_handling
     print(f"\n---------------- charge_needed ----------------")
     # validate parameters
     args = locals()
@@ -2771,10 +2793,10 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         if tariff is not None and tariff.get(k) is not None:
             start = round_time(time_hours(tariff[k]['start']) + (time_offset if tariff[k].get('gmt') is not None else 0))
             end = round_time(time_hours(tariff[k]['end']) + (time_offset if tariff[k].get('gmt') is not None else 0))
-            force = 0 if tariff[k].get('force') is not None and tariff[k]['force'] == 0 else force_charge
-            times.append({'key': k, 'start': start, 'end': end, 'force': force})
+            hold = 0 if tariff[k].get('hold') is not None and tariff[k]['hold'] == 0 else force_charge
+            times.append({'key': k, 'start': start, 'end': end, 'hold': hold})
     if len(times) == 0:
-        times.append({'key': 'off_peak1', 'start': round_time(base_hour + 1), 'end': round_time(base_hour + 4), 'force': force_charge})
+        times.append({'key': 'off_peak1', 'start': round_time(base_hour + 1), 'end': round_time(base_hour + 4), 'hold': force_charge})
         output(f"Charge time: {hours_time(base_hour + 1)}-{hours_time(base_hour + 4)}")
     time_to_end1 = None
     for t in times:
@@ -2804,7 +2826,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     run_to = time_to_end1 if time_to_end < time_to_end1 else time_to_end1 + 24 * steps_per_hour
     run_time = int(run_to + 0.99) + 1 + hour_adjustment * steps_per_hour
     time_line = [round_time(base_hour + x / steps_per_hour - (hour_adjustment if x >= time_change else 0)) for x in range(0, run_time)]
-    force_charge = times[0]['force']
+    bat_hold = times[0]['hold']
     # if we need to do a full charge, full_charge is the date, otherwise None
     full_charge = charge_config['full_charge'] if charge_key == 'off_peak1' else None
     if type(full_charge) is int:            # value = day of month
@@ -2814,7 +2836,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     if debug_setting > 2:
         output(f"\ntoday = {today}, tomorrow = {tomorrow}, time_shift = {time_shift}")
         output(f"times = {times}")
-        output(f"start_at = {start_at}, end_by = {end_by}, force_charge = {force_charge}")
+        output(f"start_at = {start_at}, end_by = {end_by}, bat_hold = {bat_hold}")
         output(f"base_hour = {base_hour}, hour_adjustment = {hour_adjustment}, change_hour = {change_hour}, time_change = {time_change}")
         output(f"time_to_start = {time_to_start}, run_time = {run_time}, charge_today = {charge_today}")
         output(f"time_to_next = {time_to_next}, full_charge = {full_charge}")
@@ -2842,9 +2864,9 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         model = device.get('deviceType')
     else:
         current_soc = test_soc
-        capacity = 14.6
+        capacity = 14.54
         residual = test_soc * capacity / 100
-        bat_volt = 315.4
+        bat_volt = 317.4
         bat_power = 0.0
         temperature = 30
         bat_current = 0.0
@@ -2887,7 +2909,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
                 output(f"  Charge current reduced from {charge_current:.0f}A to {derated_current:.0f}A" )
                 charge_current = derated_current
         else:
-            force_charge = 2
+            bat_hold = 2
             output(f"  Full charge set")
     # inverter losses
     inverter_power = charge_config['inverter_power'] if charge_config['inverter_power'] is not None else round(device_power, 0) * 25
@@ -2895,35 +2917,35 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     bms_power = charge_config['bms_power']
     bms_loss = bms_power / 1000
     # work out charge limit, power and losses. Max power going to the battery after ac conversion losses
+    ac_dc_loss = charge_config['ac_dc_loss']
     charge_limit = min([charge_current * (bat_ocv + charge_current * bat_resistance) / 1000, max([6, device_power])])
     if charge_limit < 0.1:
         output(f"** charge_current is too low ({charge_current:.1f}A)")
-    charge_loss = 1.0 - charge_limit * 1000 * bat_resistance / bat_ocv ** 2
     force_charge_power = charge_config['force_charge_power'] if timed_mode > 1 and charge_config.get('force_charge_power') is not None else 100
-    grid_loss = charge_config['grid_loss']
-    charge_power = min([(device_power - operating_loss) * grid_loss, force_charge_power * grid_loss, charge_limit])
+    charge_power = min([(device_power - operating_loss) * ac_dc_loss, force_charge_power * ac_dc_loss, charge_limit])
     float_charge = (charge_config['float_current'] if charge_config.get('float_current') is not None else 4) * bat_ocv / 1000
-    charge_config['charge_loss'] = charge_loss
     charge_config['charge_limit'] = charge_limit
     charge_config['charge_power'] = charge_power
     charge_config['float_charge'] = float_charge
+    charge_loss = charge_config['charge_loss'][residual_handling - 1]
     # work out discharge limit = max power coming from the battery before ac conversion losses
-    discharge_loss = charge_config['discharge_loss']
-    discharge_limit = device_power / discharge_loss
+    dc_ac_loss = charge_config['dc_ac_loss']
+    discharge_limit = device_power / dc_ac_loss
     discharge_current = device_current if charge_config['discharge_current'] is None else charge_config['discharge_current']
     discharge_power = discharge_current * bat_ocv / 1000
     discharge_limit = discharge_power if discharge_power < discharge_limit else discharge_limit
+    discharge_loss = charge_config['discharge_loss'][residual_handling - 1]
     # charging happens if generation exceeds export limit in feedin work mode
     export_power = device_power if charge_config['export_limit'] is None else charge_config['export_limit']
-    export_limit = export_power / discharge_loss
+    export_limit = export_power / dc_ac_loss
     current_mode = get_work_mode()
     output(f"\ncharge_config = {json.dumps(charge_config, indent=2)}", 3)
     output(f"\nDevice Info:")
     output(f"  Model:     {model}")
     output(f"  Rating:    {device_power:.2f}kW")
     output(f"  Export:    {export_power:.2f}kW")
-    output(f"  Charge:    {charge_current:.1f}A, {charge_power:.2f}kW, {charge_loss * 100:.1f}% efficient")
-    output(f"  Discharge: {discharge_current:.1f}A, {discharge_limit:.2f}kW, {discharge_loss * 100:.1f}% efficient")
+    output(f"  Charge:    {charge_current:.1f}A, {charge_power:.2f}kW, {ac_dc_loss * 100:.1f}% efficient")
+    output(f"  Discharge: {discharge_current:.1f}A, {discharge_limit:.2f}kW, {dc_ac_loss * 100:.1f}% efficient")
     output(f"  Inverter:  {inverter_power:.0f}W power consumption")
     output(f"  BMS:       {bms_power:.0f}W power consumption")
     if current_mode is not None:
@@ -2960,16 +2982,17 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     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'))
+        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
+            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'))
+        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)
@@ -3007,6 +3030,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     if forecast is not None:
         expected = forecast
         generation_timed = [expected * x / sun_sum for x in sun_timed]
+        output(f"\nForecast: {forecast:.1f}kWh")
     elif solcast_value is not None:
         expected = solcast_value
         generation_timed = solcast_timed
@@ -3025,7 +3049,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, x * charge_config['pv_loss']]) for x in generation_timed]
-    discharge_timed = [min([discharge_limit, x / discharge_loss]) + bms_loss for x in consumption_timed]
+    discharge_timed = [min([discharge_limit, x / dc_ac_loss]) + bms_loss for x in consumption_timed]
     work_mode_timed = strategy_timed(timed_mode, base_hour, 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
@@ -3036,11 +3060,13 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             discharge_timed[i] = discharge_timed[i] * (1.0 - duration)
             work_mode_timed[i]['charge'] = charge_power * duration
         elif timed_mode > 0 and work_mode == 'ForceDischarge':
-            fdpwr = work_mode_timed[i]['fdpwr'] / discharge_loss / 1000
-            fdpwr = min([discharge_limit, export_limit + discharge_timed[i] * charge_loss, fdpwr])
-            discharge_timed[i] = fdpwr * duration / charge_loss + discharge_timed[i] * (1.0 - duration) - charge_timed[i] * duration
-        elif force_charge > 0 and i >= int(time_to_start) and i < int(time_to_end):
+            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
+        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
         elif timed_mode > 0 and work_mode == 'Backup':
             discharge_timed[i] = bms_loss if charge_timed[i] == 0.0 else 0.0
         elif timed_mode > 0 and work_mode == 'Feedin':
@@ -3063,7 +3089,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     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 force_charge == 2 else (target_soc / 100 * capacity) if target_soc is not None else 0
+    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):
         kwh_needed = target_kwh - end_residual
     elif test_charge is not None:
@@ -3080,18 +3106,14 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         start_timed = time_to_end
         end_timed = time_to_end
         end_soc = int(end_residual / capacity * 100 + 0.5)
-        # update min_soc for battery hold
-        if force_charge > 0 and timed_mode > 1:
-            for t in range(int(time_to_start), int(time_to_end)):
-                work_mode_timed[t]['min_soc'] = start_soc
     else:
-        if test_charge is None:
-            output(f"\nCharge needed {kwh_needed:.2f}kWh:")
-            charge_message = "with charge added"
-        output(f"  SoC now:     {current_soc:.0f}% at {hours_time(hour_now)} on {today}")
         # work out time to add kwh_needed to battery
         charge_rate = charge_power * charge_loss
         hours = kwh_needed / charge_rate
+        if test_charge is None:
+            output(f"\nCharge needed: {kwh_needed:.2f}kWh ({hours_time(hours)})")
+            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:
@@ -3100,20 +3122,22 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             kwh_shortfall = (hours - hours_to_full) * charge_rate        # amount of energy that won't be added
             required = hours_to_full + charge_time * kwh_shortfall / abs(start_residual - end_residual)  # time to recover energy not added
             hours = required if required > hours and required < charge_time else charge_time
-        # round charge time
+        # round charge time and work out what will actually be added
         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)
         # 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
         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) if force_charge == 0 else time_to_end
+        end_timed = start_timed + hours * steps_per_hour
         start_residual = interpolate(start_timed, bat_timed)
-        end_soc = min([int((start_residual + kwh_needed) / capacity * 100 + 0.5), 100])
+        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:5.2f}p/kWh" if price is not None else ""))
-        for i in range(int(time_to_start), int(end_timed) + 1):
+        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)")
+        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
             if start_timed >= i and end_timed < j:
@@ -3127,12 +3151,11 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             else:
                 t = 0.0                             # complete hour before start or after end
             output(f"i = {i}, j = {j}, t = {t}", 3)
-            if i >= start_timed:
+            if i >= start_timed and i < end_timed:
+                work_mode_timed[i]['mode'] = 'ForceCharge'
                 work_mode_timed[i]['charge'] = charge_power * t
-                work_mode_timed[i]['max_soc'] = end_soc if timed_mode > 1 else target_soc if target_soc is not None else 100
+                work_mode_timed[i]['max_soc'] = target_soc if target_soc is not None else max_soc
                 work_mode_timed[i]['discharge'] *= (1-t)
-            elif force_charge > 0 and timed_mode > 1:
-                work_mode_timed[i]['min_soc'] = start_soc
     # 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)
     end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends
@@ -3141,6 +3164,20 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     output(f"  Contingency: {kwh_contingency / capacity * 100:.0f}% SoC ({kwh_contingency:.2f}kWh)")
     if not charge_today:
         output(f"  PV cover:    {expected / consumption * 100:.0f}% ({expected:.1f}/{consumption:.1f})")
+    # setup charging
+    if timed_mode > 1:
+        periods = charge_periods(work_mode_timed, base_hour, min_soc, capacity)
+        if update_settings > 0:
+            set_schedule(periods = periods)
+    else:
+        # work out the charge times and set. First period is battery hold, second period is battery charge / hold
+        start1 = round_time(base_hour + time_to_start / steps_per_hour)
+        start2 = round_time(base_hour + start_timed / steps_per_hour)
+        end1 = start1 if bat_hold == 0 else start2
+        end2 = round_time(base_hour + (end_timed if bat_hold == 0 else time_to_end) / steps_per_hour)
+        set_charge(ch1=False, st1=start1, en1=end1, ch2=True, st2=start2, en2=end2, force=1, enable=update_settings)
+    if update_settings == 0:
+        output(f"\nNo changes made to charge settings")
     if show_data > 0:
         data_wrap = charge_config['data_wrap'] if charge_config.get('data_wrap') is not None else 6
         s = f"\nBattery Energy kWh:" if show_data == 2 else f"\nBattery SoC:"
@@ -3148,7 +3185,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         t = 0
         while t < len(time_line) and bat_timed[t] is not None:
             col = h % data_wrap
-            s += (f"\n  {hours_time(time_line[t])}" + " " * col *  6) if t == 0 or col == 0 else ""
+            s += f"\n  {hours_time(time_line[t])}" if t == 0 or col == 0 else ""
             s += f" {bat_timed[t]:5.2f}" if show_data == 2 else f"  {bat_timed[t] / capacity * 100:3.0f}%"
             h += 1
             t += steps_per_hour
@@ -3189,27 +3226,12 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         data['capacity'] = capacity
         data['config'] = charge_config
         data['time'] = time_line
-        data['bat'] = bat_timed
         data['work_mode'] = work_mode_timed
         data['generation'] = generation_timed
         data['consumption'] = consumption_timed
         file = open(storage + file_name, 'w')
         json.dump(data, file, sort_keys = True, indent=4, ensure_ascii= False)
         file.close()
-    # setup charging
-    if update_settings == 1:
-        # work out the charge times and set. First period is battery hold, second period is battery charge / hold
-        start1 = round_time(base_hour + time_to_start / steps_per_hour)
-        start2 = round_time(base_hour + start_timed / steps_per_hour)
-        end1 = start1 if force_charge == 0 else start2
-        end2 = round_time(base_hour + (end_timed if force_charge == 0 else time_to_end) / steps_per_hour)
-        if timed_mode > 1:
-            periods = charge_periods(st1=start1, en1=end1, st2=start2, en2=end2, min_soc=min_soc, end_soc=end_soc, start_soc=start_soc)
-            set_schedule(periods = periods)
-        else:
-            set_charge(ch1=False, st1=start1, en1=end1, ch2=True, st2=start2, en2=end2, force=1)
-    else:
-        output(f"\nNo changes made to charge settings")
     output_close(plot=show_plot)
     return None
 
@@ -3238,10 +3260,10 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3):
     steps_per_hour = data.get('steps')
     capacity = data.get('capacity')
     time_line = data.get('time')
-    bat_timed = data.get('bat')
     generation_timed = data.get('generation')
     consumption_timed = data.get('consumption')
     work_mode_timed = data.get('work_mode')
+    bat_timed = data['bat'] if data.get('bat') is not None else [work_mode_timed[t]['kwh'] for t in range(0, len(work_mode_timed))]
     run_time = len(time_line)
     base_hour = int(time_hours(base_time[11:16]))
     start_day = base_time[:10]
@@ -3283,9 +3305,9 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3):
         s = f"\nBattery Energy kWh:" if show_data == 2 else f"\nBattery SoC:"
         h = base_hour
         t = 0
-        while t < len(time_line) and bat_timed[t] is not None:
+        while t < len(time_line) and bat_timed[t] is not None and plots['SoC'][t] is not None:
             col = h % data_wrap
-            s += (f"\n  {hours_time(time_line[t])}" + " " * col * 6) if t == 0 or col == 0 else ""
+            s += f"\n  {hours_time(time_line[t])}" if t == 0 or col == 0 else ""
             s += f" {plots['SoC'][t]:5.2f}" if show_data == 2 else f"  {plots['SoC'][t] / capacity * 100:3.0f}%"
             h += 1
             t += steps_per_hour
@@ -3833,18 +3855,19 @@ class Solcast :
     Load Solcast Estimate / Actuals / Forecast daily yield
     """ 
 
-    def __init__(self, days = 7, reload = 2, quiet = False, estimated=0, shading=None) :
+    def __init__(self, days = 7, reload = 2, quiet = False, estimated=0, shading=None, d=None) :
         # days sets the number of days to get for forecasts (and estimated if enabled)
         # reload: 0 = use solcast.json, 1 = load new forecast, 2 = use solcast.json if date matches
         # The forecasts and estimated both include the current date, so the total number of days covered is 2 * days - 1.
         # The forecasts and estimated also both include the current time, so the data has to be de-duplicated to get an accurate total for a day
         global debug_setting, solcast_url, solcast_api_key, solcast_save, storage
         self.data = {}
+        now = datetime.now() if d is None else datetime.strptime(d, '%Y-%m-%d %H:%M')
         self.shading = None if shading is None else shading if shading.get('solcast') is None else shading['solcast'] 
-        self.today = datetime.strftime(datetime.date(datetime.now()), '%Y-%m-%d')
+        self.today = datetime.strftime(datetime.date(now), '%Y-%m-%d')
         self.quarter = int(self.today[5:7]) // 3 % 4
-        self.tomorrow = datetime.strftime(datetime.date(datetime.now() + timedelta(days=1)), '%Y-%m-%d')
-        self.yesterday = datetime.strftime(datetime.date(datetime.now() - timedelta(days=1)), '%Y-%m-%d')
+        self.tomorrow = datetime.strftime(datetime.date(now + timedelta(days=1)), '%Y-%m-%d')
+        self.yesterday = datetime.strftime(datetime.date(now - timedelta(days=1)), '%Y-%m-%d')
         self.save = solcast_save #.replace('.', '_%.'.replace('%', self.today.replace('-','')))
         if reload == 1 and os.path.exists(storage + self.save):
             os.remove(storage + self.save)
@@ -4180,13 +4203,14 @@ class Solar :
     """ 
 
     # get solar forecast and return total expected yield
-    def __init__(self, reload=0, quiet=False, shading=None):
+    def __init__(self, reload=0, quiet=False, shading=None, d=None):
         global solar_arrays, solar_save, solar_total, solar_url, solar_api_key, storage
         self.shading = None if shading is None else shading if shading.get('solar') is None else shading['solar'] 
-        self.today = datetime.strftime(datetime.date(datetime.now()), '%Y-%m-%d')
+        now = datetime.now() if d is None else datetime.strptime(d, '%Y-%m-%d %H:%M')
+        self.today = datetime.strftime(datetime.date(now), '%Y-%m-%d')
         self.quarter = int(self.today[5:7]) // 3 % 4
-        self.tomorrow = datetime.strftime(datetime.date(datetime.now() + timedelta(days=1)), '%Y-%m-%d')
-        self.yesterday = datetime.strftime(datetime.date(datetime.now() - timedelta(days=1)), '%Y-%m-%d')
+        self.tomorrow = datetime.strftime(datetime.date(now + timedelta(days=1)), '%Y-%m-%d')
+        self.yesterday = datetime.strftime(datetime.date(now - timedelta(days=1)), '%Y-%m-%d')
         self.arrays = None
         self.results = None
         self.save = solar_save #.replace('.', '_%.'.replace('%',self.today.replace('-','')))