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

foxesscloud/foxesscloud.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud
-Updated:  17 September 2024
+Updated:  23 September 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2023
 ##################################################################################################
 
-version = "1.6.3"
+version = "1.6.5"
 print(f"FoxESS-Cloud version {version}")
 
 debug_setting = 1
@@ -19,6 +19,25 @@ 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
+from datetime import datetime, timedelta, timezone
+from copy import deepcopy
+import requests
+from requests.auth import HTTPBasicAuth
+import hashlib
+import math
+import matplotlib.pyplot as plt
+
+fox_domain = "https://www.foxesscloud.com"
+fox_client_id = "5245784"
+fox_user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+time_zone = 'Europe/London'
+
+# optional path to use for file storage 
+storage = ''
+
 # global plot parameters
 figure_width = 9       # width of plots
 legend_location = "upper right"
@@ -39,27 +58,6 @@ def plot_show():
     plt.show()
     return
 
-import os.path
-import json
-import time
-from datetime import datetime, timedelta, timezone
-from copy import deepcopy
-import requests
-from requests.auth import HTTPBasicAuth
-import hashlib
-#from random_user_agent.user_agent import UserAgent
-#from random_user_agent.params import SoftwareName, OperatingSystem
-import math
-import matplotlib.pyplot as plt
-
-#software_names = [SoftwareName.CHROME.value]
-#operating_systems = [OperatingSystem.WINDOWS.value, OperatingSystem.LINUX.value]
-#user_agent_rotator = UserAgent(software_names=software_names, operating_systems=operating_systems, limit=100)
-
-fox_domain = "https://www.foxesscloud.com"
-fox_client_id = "5245784"
-fox_user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-time_zone = 'Europe/London'
 
 ##################################################################################################
 ##################################################################################################
@@ -221,11 +219,11 @@ token_renewal = timedelta(hours=2).seconds       # interval before token needs t
 
 # login and get token if required. Check if token has expired and renew if required.
 def get_token():
-    global username, password, fox_user_agent, fox_client_id, time_zone, token_store, device_list, device, device_id, debug_setting, token_save, token_renewal, messages
+    global username, password, fox_user_agent, fox_client_id, time_zone, token_store, device_list, device, device_id, debug_setting, token_save, token_renewal, messages, storage
     if token_store is None:
         token_store = {'token': None, 'valid_from': None, 'valid_for': token_renewal, 'user_agent': fox_user_agent, 'lang': 'en', 'time_zone': time_zone, 'client_id': fox_client_id}
-    if token_store['token'] is None and os.path.exists(token_save):
-        file = open(token_save)
+    if token_store['token'] is None and os.path.exists(storage + token_save):
+        file = open(storage + token_save)
         token_store = json.load(file)
         file.close()
         if token_store.get('time_zone') is None:
@@ -260,7 +258,7 @@ def get_token():
         output(f"** no token  in result data")
     token_store['valid_from'] = time_now.isoformat()
     if token_save is not None :
-        file = open(token_save, 'w')
+        file = open(storage + token_save, 'w')
         json.dump(token_store, file, indent=4, ensure_ascii=False)
         file.close()
     return token_store['token']
@@ -834,13 +832,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',
@@ -849,6 +849,7 @@ merge_settings = {                  # keys to add
         'h115__': 'h115__17',
         'h116__': 'h116__18',
         'h117__': 'h117__18',
+#        'k106__': 'k106__xx',
         },
         'type': 'list',
         'valueType': 'int',
@@ -1372,7 +1373,7 @@ sample_time = 5.0       # 5 minutes default
 sample_rounding = 2     # round to 30 seconds
 
 def get_raw(time_span='hour', d=None, v=None, summary=1, save=None, load=None, plot=0, station=0):
-    global token, device_id, debug_setting, var_list, invert_ct2, tariff, max_power_kw, messages, sample_rounding, sample_time
+    global token, device_id, debug_setting, var_list, invert_ct2, tariff, max_power_kw, messages, sample_rounding, sample_time, storage
     if station == 0 and get_device() is None:
         return None
     elif station == 1 and get_site() is None:
@@ -1420,12 +1421,12 @@ def get_raw(time_span='hour', d=None, v=None, summary=1, save=None, load=None, p
             output(f"** get_raw(), no raw data, {errno_message(errno)}")
             return None
     else:
-        file = open(load)
+        file = open(storage + load)
         result = json.load(file)
         file.close()
     if save is not None:
         file_name = save + "_raw_" + 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:
@@ -1497,7 +1498,7 @@ def get_raw(time_span='hour', d=None, v=None, summary=1, save=None, load=None, p
                 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
@@ -1755,12 +1756,12 @@ def get_report(report_type='day', d=None, v=None, summary=1, save=None, load=Non
         for x in v:
             result.append({'variable': x, 'data': [], '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 + "_rep_" + report_type + "_" + 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:
@@ -2348,56 +2349,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)
@@ -2408,13 +2389,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:
-        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]
+    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
+    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"
@@ -2458,7 +2466,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]
@@ -2497,7 +2505,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
@@ -2561,12 +2569,12 @@ 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)
@@ -2652,7 +2660,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%
@@ -2691,7 +2699,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)
@@ -2706,10 +2714,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()
@@ -2758,17 +2766,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'])
@@ -2785,9 +2796,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
@@ -2941,8 +2949,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)
@@ -2951,15 +2959,12 @@ 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")
-    # get forecast.solar data and produce time line
+            solcast_from = time_hours(fsolcast.daily[today]['from']) if fsolcast.daily[today].get('from') is not None else 0
+            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
     if forecast is None and solar_arrays is not None and (system_time.hour in forecast_times or run_after == 0):
@@ -2967,10 +2972,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
@@ -2990,8 +2992,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
@@ -3070,24 +3072,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']:
-        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']:
+        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)
@@ -3104,7 +3105,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
@@ -3125,31 +3126,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 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 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))
@@ -3190,7 +3187,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
@@ -3216,13 +3213,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:
@@ -3242,7 +3239,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:
@@ -3277,17 +3274,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))
@@ -3486,15 +3483,16 @@ 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)")
     if save is not None:
-        print(f"Saving data to {save} ")
+        print(f"Saving data to {storage + save} ")
     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()
@@ -3835,17 +3833,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 = 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:
@@ -3886,7 +3885,7 @@ 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 = {}
@@ -3918,26 +3917,30 @@ class Solcast :
         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:
             for date in self.keys:
                 times = sorted(time_hours(t) for t in self.daily[date]['pt30'].keys())
                 if self.shading.get('adjust') is not None:
-                    loss = self.shading['adjust']
+                    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.get('am_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][0]) + self.shading['am_delay']
+                    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.get('pm_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][1]) - self.shading['pm_delay']
+                    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
@@ -4173,19 +4176,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 = None if shading is None else shading if shading.get('solar') is None else shading['solar'] 
         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):
@@ -4216,7 +4219,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 = {}
@@ -4245,16 +4248,18 @@ class Solar :
             for date in self.keys:
                 times = sorted(time_hours(t) for t in self.daily[date]['pt30'].keys())
                 if self.shading.get('adjust') is not None:
-                    loss = self.shading['adjust']
+                    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.get('am_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][0]) + self.shading['am_delay']
+                    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.get('pm_delay') is not None:
-                    shaded = time_hours(self.daily[date]['sun'][1]) - self.shading['pm_delay']
+                    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
@@ -4460,6 +4465,7 @@ class Solar :
         plot_show()
         return
 
+
 ##################################################################################################
 ##################################################################################################
 # Pushover API
@@ -4473,7 +4479,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:
@@ -4481,7 +4487,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}")