foxesscloud 2.5.1__py3-none-any.whl → 2.5.3__py3-none-any.whl

foxesscloud/openapi.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud using Open API
-Updated:  17 September 2024
+Updated:  23 September 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2024
 ##################################################################################################
 
-version = "2.5.1"
+version = "2.5.3"
 print(f"FoxESS-Cloud Open API version {version}")
 
 debug_setting = 1
@@ -19,7 +19,6 @@ debug_setting = 1
 month_names = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
 day_names = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
 
-
 import os.path
 import json
 import time
@@ -37,6 +36,9 @@ user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTM
 time_zone = 'Europe/London'
 lang = 'en'
 
+# optional path to use for file storage 
+storage = ''
+
 # global plot parameters
 figure_width = 9       # width of plots
 legend_location = "upper right"
@@ -786,13 +788,15 @@ merge_settings = {                  # keys to add
     'WorkMode': {'keys': {
         'h115__': 'operation_mode__work_mode',
         'h116__': 'operation_mode__work_mode',
-        'h117__': 'operation_mode__work_mode'
+        'h117__': 'operation_mode__work_mode',
+#        'k106__': 'operation_mode__work_mode',
         },
         'values': ['SelfUse', 'Feedin', 'Backup']},
     'BatteryVolt': {'keys': {
         'h115__': ['h115__14', 'h115__15', 'h115__16'],
         'h116__': ['h116__15', 'h116__16', 'h116__17'],
-        'h117__': ['h117__15', 'h117__16', 'h117__17']
+        'h117__': ['h117__15', 'h117__16', 'h117__17'],
+#        'k106__': ['k106__xx', 'k106__xx', 'k106__xx'],
         },
         'type': 'list',
         'valueType': 'float',
@@ -801,11 +805,11 @@ merge_settings = {                  # keys to add
         'h115__': 'h115__17',
         'h116__': 'h116__18',
         'h117__': 'h117__18',
+#        'k106__': 'k106__xx',
         },
         'type': 'list',
         'valueType': 'int',
         'unit': '℃'},
-
 }
 
 def get_ui():
@@ -1271,7 +1275,7 @@ sample_time = 5.0       # 5 minutes default
 sample_rounding = 2     # round to 30 seconds
 
 def get_history(time_span='hour', d=None, v=None, summary=1, save=None, load=None, plot=0):
-    global token, device_sn, debug_setting, var_list, invert_ct2, tariff, max_power_kw, sample_rounding, sample_time, residual_scale
+    global token, device_sn, debug_setting, var_list, invert_ct2, tariff, max_power_kw, sample_rounding, sample_time, residual_scale, storage
     if get_device() is None:
         return None
     time_span = time_span.lower()
@@ -1316,12 +1320,12 @@ def get_history(time_span='hour', d=None, v=None, summary=1, save=None, load=Non
             return None
         result = result[0].get('datas')
     else:
-        file = open(load)
+        file = open(storage + load)
         result = json.load(file)
         file.close()
     if save is not None:
         file_name = save + "_history_" + time_span + "_" + d[0:10].replace('-','') + ".txt"
-        file = open(file_name, 'w', encoding='utf-8')
+        file = open(storage + file_name, 'w', encoding='utf-8')
         json.dump(result, file, indent=4, ensure_ascii= False)
         file.close()
     for var in result:
@@ -1391,7 +1395,7 @@ def get_history(time_span='hour', d=None, v=None, summary=1, save=None, load=Non
                 if e > 0.0:
                     kwh += e
                     if tariff is not None:
-                        if hour_in (h, [tariff.get('off_peak1'), tariff.get('off_peak2'), tariff.get('off_peak3')]):
+                        if hour_in (h, [tariff.get('off_peak1'), tariff.get('off_peak2'), tariff.get('off_peak3'), tariff.get('off_peak4')]):
                             kwh_off += e
                         elif hour_in(h, [tariff.get('peak1'), tariff.get('peak2')]):
                             kwh_peak += e
@@ -1537,7 +1541,7 @@ fix_value_threshold = 200000000.0
 fix_value_mask = 0x0000FFFF
 
 def get_report(dimension='day', d=None, v=None, summary=1, save=None, load=None, plot=0):
-    global token, device_sn, var_list, debug_setting, report_vars
+    global token, device_sn, var_list, debug_setting, report_vars, storage
     if get_device() is None:
         return None
     # process list of days
@@ -1643,12 +1647,12 @@ def get_report(dimension='day', d=None, v=None, summary=1, save=None, load=None,
         for x in v:
             result.append({'variable': x, 'values': [], 'date': d})
     if load is not None:
-        file = open(load)
+        file = open(storage + load)
         result = json.load(file)
         file.close()
     elif save is not None:
         file_name = save + "_report_" + dimension + "_" + d.replace('-','') + ".txt"
-        file = open(file_name, 'w', encoding='utf-8')
+        file = open(storage + file_name, 'w', encoding='utf-8')
         json.dump(result, file, indent=4, ensure_ascii= False)
         file.close()
     if summary == 0:
@@ -2209,56 +2213,36 @@ def get_agile_times(tariff=agile_octopus, d=None):
             strategy.append(prices[t])
             output(f"  {format_period(prices[t])} at {prices[t]['price']:.1f}p", 1)
     tariff['agile']['strategy'] = strategy
-    for key in ['off_peak1', 'off_peak2', 'off_peak3']:
+    for key in ['off_peak1', 'off_peak2', 'off_peak3', 'off_peak4']:
         if tariff.get(key) is None:
             continue
         if tariff['agile'].get(key) is None:
             tariff['agile'][key] = {}
         # get price index for AM/PM charge times
-        slots = []
-        for i in range(0, len(prices)):
-            if hour_in(time_hours(prices[i]['start']), tariff[key]):
-                slots.append(i)
+        slots = [i for i in range(0, len(prices)) if hour_in(time_hours(prices[i]['start']), tariff[key])]
         tariff['agile'][key]['slots'] = slots
-        # best charge time for [0.5, 1, 1.5, 2 etc] hours
-        weighting = tariff_config.get('weighting')
-        tariff['agile'][key]['times'] = []
-        for j in range (0, len(slots)):
-            span = j + 1
-            weights = (([1.0] * (span-1) if weighting is None else weighting) + [0.5] * span)[:span]
-            best = None
-            price = None
-            for i in range(0, len(slots) - j):
-                t = slots[i: i + span]
-                p_span = [prices[x]['price'] for x in t]
-                wavg = round(sum(p * w for p,w in zip(p_span, weights)) / sum(weights), 2)
-                if price is None or wavg < price:
-                    price = wavg
-                    best = t
-            # save best time slot for charge duration
-            start = prices[best[0]]['start']
-            tariff['agile'][key]['times'].append({'start': start, 'end': round_time(start + span / 2), 'price': price, 'best': best, 'key': key})
+        tariff['agile'][key]['avg'] = avg([prices[t]['price'] for t in slots])
     # show the results
     if tariff_config['show_data'] > 0:
         data_wrap = tariff_config['data_wrap'] if tariff_config.get('data_wrap') is not None else 6
         t = (now.hour * 2) % data_wrap
-        s = f"\nPricing on {today} p/kWh inc VAT:\n" + " " * t * 12
+        s = f"\nPricing on {today} p/kWh inc VAT:\n" + " " * t * 13
         for i in range(0, len(prices)):
             s += "\n" if i > 0 and t % data_wrap == 0 else ""
-            s += f"  {prices[i]['time']} {prices[i]['price']:4.1f}"
+            s += f"  {prices[i]['time']} {prices[i]['price']:4.1f},"
             t += 1
-        output(s)
+        output(s[:-1])
     if tariff_config['show_plot'] > 0:
         plt.figure(figsize=(figure_width, figure_width/2))
         x_timed = [i for i in range(0, len(prices))]
         plt.xticks(ticks=x_timed, labels=[prices[x]['time'] for x in x_timed], rotation=90, fontsize=8, ha='center')
         plt.plot(x_timed, [prices[x]['price'] for x in x_timed], label='30 minute price', color='blue')
         s = ""
-        for key in ['off_peak1', 'off_peak2']:
-            if tariff['agile'].get(key) is not None and len(tariff['agile'][key]['times']) > 0:
-                p = tariff['agile'][key]['times'][-1]
-                plt.plot(x_timed, [p['price'] if x in p['best'] else None for x in x_timed], label=f"{key} {p['price']:.1f}p")
-                s += f"\n  {format_period(p)} at {p['price']:.1f}p"
+        for key in ['off_peak1', 'off_peak2', 'off_peak3', 'off_peak4']:
+            if tariff['agile'].get(key) is not None and len(tariff['agile'][key]['slots']) > 0:
+                p = tariff['agile'][key]
+                plt.plot(x_timed, [p['avg'] if x in p['slots'] else None for x in x_timed], label=f"{key} {p['avg']:.1f}p")
+                s += f"\n  {hours_time(prices[p['slots'][0]]['start'])}-{hours_time(prices[p['slots'][-1]]['end'])} at {p['avg']:.1f}p"
         output(f"\nCharge times{s}" if s != "" else "", 1)
         plt.title(f"Pricing on {today} p/kWh inc VAT", fontsize=10)
         plt.legend(fontsize=8)
@@ -2269,13 +2253,40 @@ def get_agile_times(tariff=agile_octopus, d=None):
 # return the best charge time:
 def get_best_charge_period(start, duration):
     global tariff
-    if tariff is None:
+    if tariff is None or tariff.get('agile') is None or tariff['agile'].get('prices') is None:
+        return None
+    key = [k for k in ['off_peak1', 'off_peak2', 'off_peak3', 'off_peak4'] if hour_in(start, tariff.get(k))]
+    key = key[0] if len(key) > 0 else None
+    end = tariff[key]['end'] if key is not None else round_time(start + duration)
+    span = int(duration * 2 + 0.99)
+    coverage = max([round_time(end - start), duration])
+    period = {'start': start, 'end': round_time(start + coverage)}
+    prices = tariff['agile']['prices']
+    slots = [i for i in range(0, len(prices)) if hour_in(time_hours(prices[i]['start']), period)]
+    if len(slots) == 0:
         return None
-    key = [k for k in ['off_peak1', 'off_peak2', 'off_peak3'] if hour_in(start, tariff.get(k))][0]
-    if tariff.get('agile') is None or tariff['agile'].get(key) is None:
-        return tariff.get(key)
-    i = min([int(duration * 2), len(tariff['agile'][key]['times']) - 1])
-    return tariff['agile'][key]['times'][i]
+    elif len(slots) == 1:
+        best = slots
+        price = prices[slots[0]]['price']
+        best_start = start
+    else:
+        # best charge time for duration
+        weighting = tariff_config.get('weighting')
+        times = []
+        weights = ([1.0] * span) if weighting is None else (weighting + [1.0] * span)[:span]
+        best = None
+        price = None
+        for i in range(0, len(slots) - span + 1):
+            t = slots[i: i + span]
+            p_span = [prices[x]['price'] for x in t]
+            wavg = round(sum(p * w for p,w in zip(p_span, weights)) / sum(weights), 2)
+            if price is None or wavg < price:
+                price = wavg
+                best = t
+        best_start = prices[best[0]]['start']
+    # save best time slot for charge duration
+    tariff['agile']['best'] = {'start': best_start, 'end': round_time(best_start + span / 2), 'price': price, 'slots': best, 'key': key}
+    return tariff['agile']['best']
 
 # pushover app key for set_tariff()
 set_tariff_app_key = "apx24dswzinhrbeb62sdensvt42aqe"
@@ -2319,7 +2330,7 @@ def set_tariff(find, update=1, times=None, forecast_times=None, strategy=None, d
             times = [times]
         output(f"\n{use['name']}:")
         for t in times:
-            if len(t) not in (1,3,4) or t[0] not in ['off_peak1', 'off_peak2', 'off_peak3', 'peak1', 'peak2']:
+            if len(t) not in (1,3,4) or t[0] not in ['off_peak1', 'off_peak2', 'off_peak3', 'off_peak4', 'peak1', 'peak2']:
                 output(f"** set_tariff(): invalid time period {t}")
                 continue
             key = t[0]
@@ -2358,7 +2369,7 @@ def set_tariff(find, update=1, times=None, forecast_times=None, strategy=None, d
         elif type(strategy) is not list:
             strategy = [strategy]
         output(f"\nStrategy")
-        use['strategy'] = get_strategy(use=use, strategy=strategy, quiet=0, remove=[use.get('off_peak1'), use.get('off_peak2'), use.get('off_peak3')])
+        use['strategy'] = get_strategy(use=use, strategy=strategy, quiet=0, remove=[use.get('off_peak1'), use.get('off_peak2'), use.get('off_peak3'), use.get('off_peak4')])
     output_close(plot=tariff_config['show_plot'])
     if update == 1:
         tariff = use
@@ -2422,18 +2433,17 @@ def forecast_value_timed(forecast, today, tomorrow, base_hour, run_time, time_of
     while h < 48:
         day = today if h < 24 else tomorrow
         if forecast.daily.get(day) is None:
-            value = 0.0
+            value = None
         elif steps_per_hour == 1:
-            value = c_float(forecast.daily[day]['hourly'].get(int(h % 24)))
+            value = forecast.daily[day]['hourly'].get(int(h % 24))
         else:
-            value = c_float(forecast.daily[day]['pt30'].get(hours_time(int(h * 2) / 2)))
-        profile.append(value)
+            value = forecast.daily[day]['pt30'].get(hours_time(int(h * 2) / 2))
+        profile.append(c_float(value))
         h += 1 / steps_per_hour
     while len(profile) < run_time:
         profile.append(0.0)
     return profile[:run_time]
 
-
 # build the timed work mode profile from the tariff strategy:
 def strategy_timed(timed_mode, base_hour, run_time, min_soc=10, max_soc=100, current_mode=None):
     global tariff, steps_per_hour
@@ -2514,7 +2524,7 @@ base_time = None
 
 # charge_needed settings
 charge_config = {
-    'contingency': [20,10,5,15],      # % of consumption. Single value or [winter, spring, summer, autumn]
+    'contingency': [15,10,5,10],      # % of consumption. Single value or [winter, spring, summer, autumn]
     'capacity': None,                 # Battery capacity (over-ride)
     'min_soc': None,                  # Minimum Soc. Default 10%
     'max_soc': None,                  # Maximum Soc. Default 100%
@@ -2553,7 +2563,7 @@ charge_config = {
         '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}
         },
-    'save': 'charge_needed.txt'       # save calculation data for analysis
+    'save': 'charge_needed ###.txt'       # save calculation data for analysis
 }
 
 # app key for charge_needed (used to send output via pushover)
@@ -2568,10 +2578,10 @@ charge_needed_app_key = "awcr5gro2v13oher3v1qu6hwnovp28"
 #  forecast_times: list of hours when forecast can be fetched (UTC)
 #  force_charge: 1 = set force charge, 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,
+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
+    global timed_strategy, steps_per_hour, base_time, storage
     print(f"\n---------------- charge_needed ----------------")
     # validate parameters
     args = locals()
@@ -2604,6 +2614,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     now = system_time + timedelta(hours=time_offset)
     today = datetime.strftime(now, '%Y-%m-%d')
     base_hour = now.hour
+    base_time = today + f" {hours_time(base_hour)}"
     hour_now = now.hour + now.minute / 60
     output(f"  datetime = {today} {hours_time(hour_now)}", 2)
     yesterday = datetime.strftime(now - timedelta(days=1), '%Y-%m-%d')
@@ -2619,17 +2630,20 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     time_change = (change_hour - base_hour) * steps_per_hour
     # get charge times
     times = []
-    for k in ['off_peak1', 'off_peak2', 'off_peak3']:
+    for k in ['off_peak1', 'off_peak2', 'off_peak3', 'off_peak4']:
         if tariff is not None and tariff.get(k) is not None:
-            start = time_hours(tariff[k]['start']) + (time_offset if tariff[k].get('gmt') is not None else 0)
-            end = time_hours(tariff[k]['end']) + (time_offset if tariff[k].get('gmt') is not None else 0)
+            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})
     if len(times) == 0:
-        times.append({'key': 'off_peak1', 'start': round_time(base_hour + 2), 'end': round_time(base_hour + 5), 'force': force_charge})
-        output(f"Charge time: {hours_time(base_hour + 2)}-{hours_time(base_hour + 5)}")
+        times.append({'key': 'off_peak1', 'start': round_time(base_hour + 1), 'end': round_time(base_hour + 4), 'force': force_charge})
+        output(f"Charge time: {hours_time(base_hour + 1)}-{hours_time(base_hour + 4)}")
     time_to_end1 = None
     for t in times:
+        if hour_in(hour_now, t) and update_settings > 0:
+            update_settings = 0
+            output(f"\nSettings will not be updated during a charge period")
         time_to_start = round_time(t['start'] - base_hour) * steps_per_hour
         time_to_start += hour_adjustment * steps_per_hour if time_to_start > time_change else 0
         charge_time = round_time(t['end'] - t['start'])
@@ -2646,9 +2660,6 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     time_to_start = times[0]['time_to_start']
     time_to_end = times[0]['time_to_end']
     charge_time = times[0]['charge_time']
-    if hour_in(hour_now, {'start': round_time(start_at - 0.25), 'end': round_time(end_by + 0.25)}) and update_settings > 0:
-        print(f"\nInverter settings will not be changed less than 15 minutes before or after the next charging period")
-        update_settings = 0
     # work out time window and times with clock changes
     time_to_next = int(time_to_start)
     charge_today = (base_hour + time_to_start / steps_per_hour) < 24
@@ -2802,8 +2813,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         output(f"\nConsumption (kWh):")
         s = ""
         for h in history:
-            s += f"  {h['date']}: {h['total']:4.1f}"
-        output(s)
+            s += f" {h['date']}: {h['total']:4.1f},"
+        output(' ' + s[:-1])
         output(f"  Average of last {consumption_days} {day_tomorrow if consumption_span=='weekday' else 'day'}s: {consumption:.1f}kWh")
     # time line buckets of consumption
     daily_sum = sum(consumption_by_hour)
@@ -2812,14 +2823,11 @@ 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, estimated=1 if charge_today else 0, shading=charge_config.get('shading'))
+        fsolcast = Solcast(quiet=True, reload=reload, shading=charge_config.get('shading'))
         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)
-            if charge_today:
-                output(f"\nSolcast forecast for {today} = {fsolcast.daily[today]['kwh']:.1f}, {tomorrow} = {fsolcast.daily[tomorrow]['kwh']:.1f}")
-            else:
-                output(f"\nSolcast forecast for {forecast_day} = {solcast_value:.1f}kWh")
+            output(f"\nSolcast forecast for {tomorrow}: {fsolcast.daily[tomorrow]['kwh']:.1f}")
     # get forecast.solar data and produce time line
     solar_value = None
     solar_profile = None
@@ -2828,10 +2836,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         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)
-            if charge_today:
-                output(f"\nSolar forecast for {today} = {fsolar.daily[today]['kwh']:.1f}, {tomorrow} = {fsolar.daily[tomorrow]['kwh']:.1f}")
-            else:
-                output(f"\nSolar forecast for {forecast_day} = {solar_value:.1f}kWh")
+            output(f"\nSolar forecast for {tomorrow}: {fsolar.daily[tomorrow]['kwh']:.1f}")
     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
@@ -2851,8 +2856,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         output(f"\nGeneration (kWh):")
         s = ""
         for d in sorted(pv_history.keys())[-gen_days:]:
-            s += f"  {d}: {pv_history[d]:4.1f}"
-        output(s)
+            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
@@ -2931,24 +2936,23 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         kwh_needed = test_charge
         charge_message = "** test charge **"
     # work out charge needed
-    if kwh_min > reserve and kwh_needed < charge_config['min_kwh'] and full_charge is None and test_charge is None and force_charge != 2:
-        output(f"\nNo charging needed ({today} {hours_time(hour_now)} {current_soc}%)\n  Forecast/Consumption: {expected:.1f}/{consumption:.1f} {expected / consumption * 100:.0f}%")
+    if kwh_min > (reserve + kwh_contingency) and kwh_needed < charge_config['min_kwh'] and full_charge is None and test_charge is None and force_charge != 2:
+        output(f"\nNo charging needed ({today} {hours_time(hour_now)} {current_soc:.0f}%)")
         charge_message = "no charge needed"
         kwh_needed = 0.0
         hours = 0.0
         start_timed = time_to_end
         end_timed = time_to_end
         end_soc = int(end_residual / capacity * 100 + 0.5)
-        output(f"  Expected SoC at {hours_time(adjusted_hour(time_to_end, time_line))} is {end_soc}%")
-        # rebuild the battery residual with min_soc for battery hold
+        # 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
-        (bat_timed, x) = battery_timed(work_mode_timed, kwh_current, capacity, time_to_next)
     else:
         if test_charge is None:
-            output(f"\nCharge needed {kwh_needed:.2f}kWh ({today} {hours_time(hour_now)} {current_soc}%)\n  Forecast/Consumption: {expected:.1f}/{consumption:.1f} {expected / consumption * 100:.0f}%")
+            output(f"\nCharge needed {kwh_needed:.2f}kWh ({today} {hours_time(hour_now)} {current_soc:.0f}%)")
             charge_message = "with charge added"
+        output(f"  Start SoC:   {start_residual / capacity * 100:.0f}% at {hours_time(adjusted_hour(time_to_start, time_line))} ({start_residual:.2f}kWh)")
         # work out time to add kwh_needed to battery
         taper_time = 10/60 if (start_residual + kwh_needed) >= (capacity * 0.95) else 0
         hours = round_time(kwh_needed / (charge_power * charge_loss) + taper_time)
@@ -2965,7 +2969,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         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
-        output(f"  Charge {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 ""))
+        output(f"  Charge:      {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):
             j = i + 1
             # work out time (fraction of hour) when charging in hour from i to j
@@ -2986,31 +2990,27 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
                 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
-        # show the state
-        output(f"  Start SoC {start_residual / capacity * 100:3.0f}% at {hours_time(adjusted_hour(time_to_start, time_line))} ({start_residual:.2f}kWh)")
-        output(f"  End SoC   {end_residual / capacity * 100:3.0f}% at {hours_time(adjusted_hour(time_to_end, time_line))} ({end_residual:.2f}kWh)")
-    # show what we have worked out
-    if show_data == 3:
-        output(f"\nTime, Generation, Charge, Consumption, Discharge, Residual, kWh")
-        for i in range(0, run_time):
-            h = base_hour + i / steps_per_hour
-            output(f"  {hours_time(h)}, {generation_timed[i]:6.3f}, {charge_timed[i]:6.3f}, {consumption_timed[i]:6.3f}, {discharge_timed[i]:6.3f}, {bat_timed[i]:6.3f}")
+    # 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)
+    end_residual = interpolate(time_to_end, bat_timed)          # residual when charge time ends
+    # 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"  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})")
     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:\n" if show_data == 2 else f"\nBattery SoC %:\n"
+        s = f"\nBattery Energy kWh:\n" if show_data == 2 else f"\nBattery SoC:\n"
         h = base_hour + 1
         t = steps_per_hour
-        s += " " * (13 if show_data == 2 else 12) * (h % data_wrap)
+        s += " " * (14 if show_data == 2 else 13) * (h % data_wrap)
         while t < len(time_line) and bat_timed[t] is not None:
             s += "\n" if t > steps_per_hour and h % data_wrap == 0 else ""
             s += f"  {hours_time(time_line[t])}"
-            s += f" {bat_timed[t]:5.2f}" if show_data == 2 else f" {bat_timed[t] / capacity * 100:3.0f}%"
+            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
-        output(s)
+        output(s[:-1])
     if show_plot > 0:
         print()
         plt.figure(figsize=(figure_width, figure_width/2))
@@ -3051,7 +3051,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         data['work_mode'] = work_mode_timed
         data['generation'] = generation_timed
         data['consumption'] = consumption_timed
-        file = open(file_name, 'w')
+        file = open(storage + file_name, 'w')
         json.dump(data, file, sort_keys = True, indent=4, ensure_ascii= False)
         file.close()
     # setup charging
@@ -3076,13 +3076,13 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
 ##################################################################################################
 
 def charge_compare(save=None, v=None, show_data=1, show_plot=3):
-    global charge_config
+    global charge_config, storage
     if save is None and charge_config.get('save') is not None:
         save = charge_config.get('save').replace('###', base_time.replace(' ', 'T'))
     if save is None:
         print(f"** charge_compare(): please provide a saved file to load")
         return
-    file = open(save)
+    file = open(storage + save)
     data = json.load(file)
     file.close()
     if data is None or data.get('base_time') is None:
@@ -3102,7 +3102,7 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3):
     run_time = len(time_line)
     base_hour = int(time_hours(base_time[11:16]))
     start_day = base_time[:10]
-    print(f"Run at {start_day} {hours_time(hour_now)} with SoC = {current_soc}%")
+    print(f"Run at {start_day} {hours_time(hour_now)} with SoC {current_soc:.0f}%")
     now = datetime.strptime(base_time, '%Y-%m-%d %H:%M')
     end_day = datetime.strftime(now + timedelta(hours=run_time / steps_per_hour), '%Y-%m-%d')
     if v is None:
@@ -3137,17 +3137,17 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3):
             plots[v][i] = plots[v][i] / count[v][i] if count[v][i] > 0 else None
     if show_data > 0 and plots.get('SoC') is not None:
         data_wrap = charge_config['data_wrap'] if charge_config.get('data_wrap') is not None else 6
-        s = f"\nBattery Energy kWh:\n" if show_data == 2 else f"\nBattery SoC %:\n"
+        s = f"\nBattery Energy kWh:\n" if show_data == 2 else f"\nBattery SoC:\n"
         h = base_hour + 1
         t = steps_per_hour
-        s += " " * (13 if show_data == 2 else 12) * (h % data_wrap)
+        s += " " * (14 if show_data == 2 else 13) * (h % data_wrap)
         while t < len(time_line) and plots['SoC'][t] is not None:
             s += "\n" if t > steps_per_hour and h % data_wrap == 0 else ""
             s += f"  {hours_time(time_line[t])}"
-            s += f" {plots['SoC'][t]:5.2f}" if show_data == 2 else f" {plots['SoC'][t] / capacity * 100:3.0f}%"
+            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
-        print(s)
+        print(s[:-1])
     if show_plot > 0:
         print()
         plt.figure(figsize=(figure_width, figure_width/2))
@@ -3345,6 +3345,7 @@ def write(f, s, m='a'):
 # log battery information in CSV format at 'interval' minutes apart for 'run' times
 # log 1: battery info, 2: add cell volts, 3: add cell temps
 def battery_monitor(interval=30, run=48, log=1, count=None, save=None, overwrite=0):
+    global storage
     run_time = interval * run / 60
     print(f"\n---------------- battery_monitor ------------------")
     print(f"Expected runtime = {hours_time(run_time, day=True)} (hh:mm/days)")
@@ -3353,7 +3354,7 @@ def battery_monitor(interval=30, run=48, log=1, count=None, save=None, overwrite
     print()
     s = f"time,soc,residual,bat_volt,bat_current,bat_temp,nbat,ncell,ntemp,volts*,imbalance*,temps*"
     s += ",cell_volts*" if log == 2 else ",cell_volts*,cell_temps*" if log ==3 else ""
-    write(save, s, 'w' if overwrite == 1 else 'a')
+    write(storage + save, s, 'w' if overwrite == 1 else 'a')
     i = run
     while i > 0:
         t1 = time.time()
@@ -3694,17 +3695,18 @@ class Solcast :
         # 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
+        global debug_setting, solcast_url, solcast_api_key, solcast_save, storage
         self.data = {}
-        self.shading = shading
+        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.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.save = solcast_save #.replace('.', '_%.'.replace('%', self.today.replace('-','')))
-        if reload == 1 and os.path.exists(self.save):
-            os.remove(self.save)
-        if self.save is not None and os.path.exists(self.save):
-            file = open(self.save)
+        if reload == 1 and os.path.exists(storage + self.save):
+            os.remove(storage + self.save)
+        if self.save is not None and os.path.exists(storage + self.save):
+            file = open(storage + self.save)
             self.data = json.load(file)
             file.close()
             if len(self.data) == 0:
@@ -3745,12 +3747,13 @@ class Solcast :
                         return
                     self.data[t][rid] = response.json().get(t)
             if self.save is not None :
-                file = open(self.save, 'w')
+                file = open(storage + self.save, 'w')
                 json.dump(self.data, file, sort_keys = True, indent=4, ensure_ascii= False)
                 file.close()
         self.daily = {}
+        estimated = 0 if self.data.get('estimated_actuals') is None else 1
         loaded = {}     # track what we have loaded so we don't duplicate between forecast and actuals
-        for t in ['forecasts'] if self.data.get('estimated_actuals') is None else ['forecasts', 'estimated_actuals']:
+        for t in ['forecasts'] if estimated == 0 else ['forecasts', 'estimated_actuals']:
             for rid in self.data[t].keys() :            # aggregate sites
                 if loaded.get(rid) is None:
                     loaded[rid] = {}
@@ -3770,33 +3773,37 @@ class Solcast :
                         self.daily[date]['pt30'][key] = 0.0
                     self.daily [date]['pt30'][key] += value
         # ignore first and last dates as these only cover part of the day, so are not accurate
-        self.keys = sorted(self.daily.keys())[1:-1]
+        self.keys = sorted(self.daily.keys())[estimated:-1]
         self.days = len(self.keys)
         # trim the range if fewer days have been requested
-        while self.days > 2 * days :
-            self.keys = self.keys[1:-1]
+        while self.days > days * (1 + estimated) :
+            self.keys = self.keys[estimated:-1]
             self.days = len(self.keys)
-        # fill out forecast to cover 24 hours
+        # fill out forecast to cover 24 hours and set forecast start time
         for date in self.keys:
             for t in [hours_time(t / 2) for t in range(0,48)]:
                 if self.daily[date]['pt30'].get(t) is None:
                     self.daily[date]['pt30'][t] = 0.0
+                elif self.daily[date].get('from') is None:
+                    self.daily[date]['from'] = t
         # apply shading
-        if self.shading is not None and self.shading.get('solcast') is not None:
+        if self.shading is not None:
             for date in self.keys:
                 times = sorted(time_hours(t) for t in self.daily[date]['pt30'].keys())
-                if self.shading['solcast'].get('adjust') is not None:
-                    loss = self.shading['solcast']['adjust']
+                if self.shading.get('adjust') is not None:
+                    loss = self.shading['adjust'] if type(self.shading['adjust']) is not list else self.shading['adjust'][self.quarter]
                     for t in times:
                         self.daily[date]['pt30'][hours_time(t)] *= loss
-                if self.shading['solcast'].get('am_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][0]) + self.shading['solcast']['am_delay']
-                    loss = self.shading['solcast']['am_loss']
+                if self.shading.get('am_delay') is not None:
+                    delay = self.shading['am_delay'] if type(self.shading['am_delay']) is not list else self.shading['am_delay'][self.quarter]
+                    shaded = time_hours(self.daily[date]['sun'][0]) + delay
+                    loss = self.shading['am_loss']
                     for t in [t for t in times if t < shaded]:
                         self.daily[date]['pt30'][hours_time(t)] *= loss
-                if self.shading['solcast'].get('pm_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][1]) - self.shading['solcast']['pm_delay']
-                    loss = self.shading['solcast']['pm_loss']
+                if self.shading.get('pm_delay') is not None:
+                    delay = self.shading['pm_delay'] if type(self.shading['pm_delay']) is not list else self.shading['pm_delay'][self.quarter]
+                    shaded = time_hours(self.daily[date]['sun'][1]) - delay
+                    loss = self.shading['pm_loss']
                     for t in [t for t in times if t > shaded]:
                         self.daily[date]['pt30'][hours_time(t)] *= loss
         # calculate hourly values and total
@@ -4031,18 +4038,19 @@ class Solar :
 
     # get solar forecast and return total expected yield
     def __init__(self, reload=0, quiet=False, shading=None):
-        global solar_arrays, solar_save, solar_total, solar_url, solar_api_key
-        self.shading = shading
+        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')
+        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.arrays = None
         self.results = None
-        self.shading = shading
         self.save = solar_save #.replace('.', '_%.'.replace('%',self.today.replace('-','')))
-        if reload == 1 and os.path.exists(self.save):
-            os.remove(self.save)
-        if self.save is not None and os.path.exists(self.save):
-            file = open(self.save)
+        if reload == 1 and os.path.exists(storage + self.save):
+            os.remove(storage + self.save)
+        if self.save is not None and os.path.exists(storage + self.save):
+            file = open(storage + self.save)
             data = json.load(file)
             file.close()
             if data.get('date') is not None and (data['date'] == self.today and reload != 1):
@@ -4073,7 +4081,7 @@ class Solar :
             if self.save is not None :
                 if debug_setting > 0 and not quiet:
                     print(f"Saving data to {self.save}")
-                file = open(self.save, 'w')
+                file = open(storage + self.save, 'w')
                 json.dump({'date': self.today, 'arrays': self.arrays, 'results': self.results}, file, indent=4, ensure_ascii= False)
                 file.close()
         self.daily = {}
@@ -4101,18 +4109,20 @@ class Solar :
         if self.shading is not None and self.shading.get('solar') is not None:
             for date in self.keys:
                 times = sorted(time_hours(t) for t in self.daily[date]['pt30'].keys())
-                if self.shading['solar'].get('adjust') is not None:
-                    loss = self.shading['solar']['adjust']
+                if self.shading.get('adjust') is not None:
+                    loss = self.shading['adjust'] if type(self.shading['adjust']) is not list else self.shading['adjust'][self.quarter]
                     for t in times:
                         self.daily[date]['pt30'][hours_time(t)] *= loss
-                if self.shading['solar'].get('am_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][0]) + self.shading['solar']['am_delay']
-                    loss = self.shading['solar']['am_loss']
+                if self.shading.get('am_delay') is not None:
+                    delay = self.shading['am_delay'] if type(self.shading['am_delay']) is not list else self.shading['am_delay'][self.quarter]
+                    shaded = time_hours(self.daily[date]['sun'][0]) + delay
+                    loss = self.shading['am_loss']
                     for t in [t for t in times if t < shaded]:
                         self.daily[date]['pt30'][hours_time(t)] *= loss
-                if self.shading['solar'].get('pm_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][1]) - self.shading['solar']['pm_delay']
-                    loss = self.shading['solar']['pm_loss']
+                if self.shading.get('pm_delay') is not None:
+                    delay = self.shading['pm_delay'] if type(self.shading['pm_delay']) is not list else self.shading['pm_delay'][self.quarter]
+                    shaded = time_hours(self.daily[date]['sun'][1]) - delay
+                    loss = self.shading['pm_loss']
                     for t in [t for t in times if t > shaded]:
                         self.daily[date]['pt30'][hours_time(t)] *= loss
         # calculate hourly values and total
@@ -4331,7 +4341,7 @@ pushover_url = "https://api.pushover.net/1/messages.json"
 foxesscloud_app_key = "aqj8up6jeg9hu4zr1pgir3368vda4q"
 
 def pushover_post(message, file=None, app_key=None):
-    global pushover_user_key, pushover_url, foxesscloud_app_key, debug_setting
+    global pushover_user_key, pushover_url, foxesscloud_app_key, debug_setting, storage
     if pushover_user_key is None or message is None:
         return None
     if app_key is None:
@@ -4339,7 +4349,7 @@ def pushover_post(message, file=None, app_key=None):
     if len(message) > 1024:
         message = message[-1024:]
     body = {'token': app_key, 'user': pushover_user_key, 'message': message}
-    files = {'attachment': open(file, 'rb')} if file is not None else None
+    files = {'attachment': open(storage + file, 'rb')} if file is not None else None
     response = requests.post(pushover_url, data=body, files=files)
     if response.status_code != 200:
         print(f"** pushover_post() got response code {response.status_code}: {response.reason}")