foxesscloud 2.6.4__py3-none-any.whl → 2.6.6__py3-none-any.whl

foxesscloud/foxesscloud.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud
-Updated:  13 October 2024
+Updated:  01 November 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2023
 ##################################################################################################
 
-version = "1.7.6"
+version = "1.7.8"
 print(f"FoxESS-Cloud version {version}")
 
 debug_setting = 1
@@ -583,7 +583,7 @@ battery = None
 batteries = None
 battery_settings = None
 
-# 1 = Residual Energy, 2 = Residual Capacity
+# 1 = Residual Energy, 2 = Residual Capacity (HV), 3 = Residual Capacity per battery (Mira)
 residual_handling = 1
 
 # charge rates based on residual_handling
@@ -593,13 +593,20 @@ battery_params = {
     1: {'table': [ 0, 2, 10, 15, 25, 50, 50, 50, 50, 50, 30, 20, 0],
         'step': 5,
         'offset': 5,
-        'charge_loss': 0.975,
-        'discharge_loss': 0.975},
+        'charge_loss': 0.974,
+        'discharge_loss': 0.974},
+    # HV BMS v2 with firmware 1.014 or later
     2: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
         'step': 5,
         'offset': 5,
         'charge_loss': 1.08,
-        'discharge_loss': 0.85},
+        'discharge_loss': 0.95},
+    # Mira BMS with firmware 1.014 or later
+    3: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
+        'step': 5,
+        'offset': 5,
+        'charge_loss': 0.974,
+        'discharge_loss': 0.974},
 }
 
 def get_battery(info=1):
@@ -632,10 +639,13 @@ def get_battery(info=1):
                 output(f"** get_battery().info, no result data, {errno_message(errno)}")
             else:
                 battery['info'] = result['batteries'][0]
-                if battery['info']['masterVersion'] >= '1.014' and battery['info']['masterSN'][:7] == '60BBHV2':
+                if battery['info'].get('slaveBatteries') is not None:
+                    battery['count'] = len(battery['info']['slaveBatteries'])
+                if battery['info']['masterSN'][:7] == '60BBHV2' and battery['info']['masterVersion'] >= '1.014':
                     residual_handling = 2
+                elif battery['info']['masterSN'][:7] == '60MBB01' and battery['info']['masterVersion'] >= '1.014':
+                    residual_handling = 3
     battery['residual_handling'] = residual_handling
-    battery['rated_capacity'] = None
     battery['soh'] = None
     battery['soh_supported'] = False
     if battery.get('residual') is not None:
@@ -644,6 +654,18 @@ def get_battery(info=1):
         capacity = battery.get('residual')
         soc = battery.get('soc')
         residual = capacity * soc / 100 if capacity is not None and soc is not None else capacity
+        if battery.get('count') is None:
+            battery['count'] = int(battery['volt'] / 49)
+        if battery.get('ratedCapacity') is None:
+            battery['ratedCapacity'] = 2560 * battery['count']
+    elif battery['residual_handling'] == 3:
+        if battery.get('count') is None:
+            battery['count'] = int(battery['volt'] / 49)
+        capacity = (battery['residual'] * battery['count']) if battery.get('residual') is not None else None
+        soc = battery.get('soc')
+        residual = capacity * soc / 100 if capacity is not None and soc is not None else capacity
+        if battery.get('ratedCapacity') is None:
+            battery['ratedCapacity'] = 2450 * battery['count']
     else:
         residual = battery.get('residual')
         soc = battery.get('soc')
@@ -654,6 +676,8 @@ def get_battery(info=1):
     params = battery_params[battery['residual_handling']]
     battery['charge_loss'] = params['charge_loss']
     battery['discharge_loss'] = params['discharge_loss']
+    if battery.get('ratedCapacity') is not None and battery.get('capacity') is not None:
+        battery['soh'] = round(battery['capacity'] * 1000 / battery['ratedCapacity'] * 100, 1)
     if battery.get('temperature') is not None:
         battery['charge_rate'] = params['table'][int((battery['temperature'] - params['offset']) / params['step'])]
     return battery
@@ -688,8 +712,13 @@ def get_batteries(info=1):
                     batteries[i]['info'] = result['batteries'][i]
     for b in batteries:
         b['residual_handling'] = residual_handling
-        if b.get('info') is not None and b['info']['masterVersion'] >= '1.014' and b['info']['masterSN'][:7] == '60BBHV2':
-            b['residual_handling'] = 2
+        if b.get('info') is not None:
+            if b['info'].get('slaveBatteries') is not None:
+                b['count'] = len(b['info']['slaveBatteries'])
+            if b['info']['masterVersion'] >= '1.014' and b['info']['masterSN'][:7] == '60BBHV2':
+                b['residual_handling'] = 2
+            elif battery['info']['masterSN'][:7] == '60MBB01' and battery['info']['masterVersion'] >= '1.014':
+                residual_handling = 3
         rated_capacity = b.get('ratedCapacity')
         b['ratedCapacity'] = rated_capacity if rated_capacity is not None and rated_capacity > 100 else None
         soh = b.get('soh')
@@ -708,7 +737,7 @@ def get_batteries(info=1):
             soc = b.get('soc')
             residual = b['capacity'] * b['soc'] / 100
             b['residual'] = round(residual, 3)
-        if b.get('capacity') is not None and b.get('ratedCapacity') is not None:
+        if b.get('ratedCapacity') is not None and b.get('capacity') is not None:
             b['soh'] = round(b['capacity'] * 1000 / b['ratedCapacity'] * 100, 1)
         b['charge_rate'] = 50
         params = battery_params[b['residual_handling']]
@@ -1022,7 +1051,7 @@ def get_remote_settings(key):
     result = response.json().get('result')
     if result is None:
         errno = response.json().get('errno')
-        output(f"** get_remote_settings(), no result data, {errno_message(errno)}")
+        output(f"** get_remote_settings(), no result data, {errno_message(response)}")
         return None
     values = result.get('values')
     if values is None:
@@ -1323,10 +1352,11 @@ def set_period(start=None, end=None, mode=None, min_soc=None, max_soc=None, fdso
         price = segment.get('price')
     start = time_hours(start)
     # adjust exclusive time to inclusive
-    end = round_time(time_hours(end) - 1/60)
+    end = time_hours(end)
     if start is None or end is None or start >= end:
         output(f"set_period(): ** invalid period times: {hours_time(start)}-{hours_time(end)}")
         return None
+    end = round_time(end - 1/60)
     mode = 'SelfUse' if mode is None else mode
     if mode not in work_modes:
         output(f"** mode must be one of {work_modes}")
@@ -1399,7 +1429,7 @@ def set_schedule(periods=None, template=None, enable=True):
             if len(periods) > 8:
                 output(f"** set_schedule(): maximum of 8 periods allowed, {len(periods)} provided")
                 return None
-            data = {'pollcy': periods, 'deviceSN': device_sn}
+            data = {'pollcy': periods[-8:], 'deviceSN': device_sn}
             schedule['pollcy'] = periods
             schedule['template_id'] = None
         elif template is not None:
@@ -1436,7 +1466,7 @@ def set_schedule(periods=None, template=None, enable=True):
 # d = day 'YYYY-MM-DD'. Can also include 'HH:MM' in 'hour' mode
 # v = list of variables to get
 # summary = 0: raw data, 1: add max, min, sum, 2: summarise and drop raw data, 3: calculate state
-# save = "xxxxx": save the raw results to xxxxx_raw_<time_span>_<d>.json
+# save = "xxxxx": save the raw results to xxxxx_history_<time_span>_<d>.json
 # load = "<file>": load the raw results from <file>
 # plot = 0: no plot, 1: plot variables separately, 2: combine variables 
 # station = 0: use device_id, 1: use station_id
@@ -1504,7 +1534,7 @@ def get_raw(time_span='hour', d=None, v=None, summary=1, save=None, load=None, p
         result = json.load(file)
         file.close()
     if save is not None:
-        file_name = save + "_raw_" + time_span + "_" + d[0:10].replace('-','') + ".txt"
+        file_name = save + "_history_" + time_span + "_" + d[0:10].replace('-','') + ".txt"
         file = open(storage + file_name, 'w', encoding='utf-8')
         json.dump(result, file, indent=4, ensure_ascii= False)
         file.close()
@@ -1709,7 +1739,7 @@ get_history = get_raw
 # d = day 'YYYY-MM-DD'
 # v = list of report variables to get
 # summary = 0, 1, 2: do a quick total energy report for a day
-# save = "xxxxx": save the report results to xxxxx_raw_<time_span>_<d>.json
+# save = "xxxxx": save the report results to xxxxx_report_<time_span>_<d>.json
 # load = "<file>": load the report results from <file>
 # plot = 0: no plot, 1 = plot variables separately, 2 = combine variables
 # station = 0: use device_id, 1 = use station_id
@@ -1839,7 +1869,7 @@ def get_report(report_type='day', d=None, v=None, summary=1, save=None, load=Non
         result = json.load(file)
         file.close()
     elif save is not None:
-        file_name = save + "_rep_" + report_type + "_" + d.replace('-','') + ".txt"
+        file_name = save + "_report_" + report_type + "_" + d.replace('-','') + ".txt"
         file = open(storage + file_name, 'w', encoding='utf-8')
         json.dump(result, file, indent=4, ensure_ascii= False)
         file.close()
@@ -2588,7 +2618,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.get('off_peak4')])
+        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
@@ -2665,15 +2695,15 @@ def forecast_value_timed(forecast, today, tomorrow, base_hour, run_time, time_of
     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):
+def strategy_timed(timed_mode, time_line, run_time, min_soc=10, max_soc=100, current_mode=None):
     global tariff, steps_per_hour
     work_mode_timed = []
     min_soc_now = min_soc
     max_soc_now = max_soc
     current_mode = 'SelfUse' if current_mode is None else current_mode
     strategy = get_strategy(timed_mode=timed_mode)
-    h = base_hour
     for i in range(0, run_time):
+        h = time_line[i]
         period = {'mode': current_mode, 'min_soc': min_soc_now, 'max_soc': max_soc, 'fdpwr': 0, 'fdsoc': min_soc_now, 'duration': 1.0, 'charge': 0.0,
             'pv': 0.0, 'discharge': 0.0, 'hold': 0, 'kwh': None}
         if strategy is not None:
@@ -2692,8 +2722,8 @@ def strategy_timed(timed_mode, base_hour, run_time, min_soc=10, max_soc=100, cur
                         if d.get('fdpwr') is not None:
                             period['fdpwr'] = d['fdpwr']
                     period['duration'] = duration_in(h, d, steps_per_hour) * steps_per_hour
+                    break
         work_mode_timed.append(period)
-        h = round_time(h + 1 / steps_per_hour)
     return work_mode_timed
 
 # build the timed battery residual from the charge / discharge, work mode and min_soc
@@ -2706,7 +2736,8 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
     discharge_loss = charge_config['discharge_loss']
     charge_limit = charge_config['charge_limit']
     float_charge = charge_config['float_charge']
-    for i in range(0, len(work_mode_timed)):
+    run_time = len(work_mode_timed)
+    for i in range(0, run_time):
         w = work_mode_timed[i]
         w['kwh'] = kwh_current
         max_now = w['max_soc'] * capacity / 100
@@ -2717,6 +2748,7 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
         if kwh_current > capacity:
             # battery is full
             kwh_current = capacity
+        w = work_mode_timed[i+1] if (i + 1) < run_time else w
         min_soc_now = w['fdsoc'] if w['mode'] =='ForceDischarge' else w['min_soc']
         reserve_now = capacity * min_soc_now / 100
         if kwh_current < reserve_now and (i < time_to_next or kwh_min is None):
@@ -2746,7 +2778,7 @@ def charge_periods(work_mode_timed, base_hour, min_soc, capacity):
         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']:
+        if h == 24 or period['mode'] != next_period['mode'] or period['hold'] != next_period['hold'] or period['min_soc'] != next_period['min_soc']:
             s = {'start': start % 24, 'end': h % 24, 'mode': period['mode'], 'min_soc': period['min_soc']}
             if period['mode'] == 'ForceDischarge':
                 s['fdsoc'] = period.get('fdsoc')
@@ -2838,7 +2870,7 @@ charge_needed_app_key = "awcr5gro2v13oher3v1qu6hwnovp28"
 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, battery, charge_rates
+    global timed_strategy, steps_per_hour, base_time, storage, battery, battery_params
     print(f"\n---------------- charge_needed ----------------")
     # validate parameters
     args = locals()
@@ -2945,8 +2977,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         bat_power = 0.0
         temperature = 30
         bms_charge_current = 15
-        charge_loss = charge_rates[2]['charge_loss']
-        discharge_loss = charge_rates[2]['discharge_loss']
+        charge_loss = battery_params[2]['charge_loss']
+        discharge_loss = battery_params[2]['discharge_loss']
         bat_current = 0.0
         device_power = 6.0
         device_current = 35
@@ -2968,8 +3000,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             output(f"Battery capacity could not be estimated. Please add the parameter 'capacity=xx' in kWh")
             return None
         bms_charge_current = battery.get('charge_rate')
-        charge_loss = battery['charge_loss'] if battery.get('charge_loss') is not None else 1.0
-        discharge_loss = battery['discharge_loss'] if battery.get('discharge_loss') is not None else 1.0
+        charge_loss = battery['charge_loss'] if battery.get('charge_loss') is not None else 0.974
+        discharge_loss = battery['discharge_loss'] if battery.get('discharge_loss') is not None else 0.974
         device_power = device.get('power')
         device_current = device.get('max_charge_current')
         model = device.get('deviceType')
@@ -3141,7 +3173,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     # produce time lines for charge, discharge and work mode
     charge_timed = [min([charge_limit, c_float(x) * pv_loss]) for x in generation_timed]
     discharge_timed = [min([discharge_limit, c_float(x) / dc_ac_loss]) + bms_loss for x in consumption_timed]
-    work_mode_timed = strategy_timed(timed_mode, base_hour, run_time, min_soc=min_soc, max_soc=max_soc, current_mode=current_mode)
+    work_mode_timed = strategy_timed(timed_mode, time_line, run_time, min_soc=min_soc, max_soc=max_soc, current_mode=current_mode)
     for i in range(0, len(work_mode_timed)):
         # get work mode
         work_mode = work_mode_timed[i]['mode']
@@ -3269,14 +3301,15 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         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")
+    start_t = 0 # int(hour_now % 1 + 0.5) * steps_per_hour
     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:"
         h = base_hour
-        t = 0
+        t = start_t
         while t < len(time_line) and bat_timed[t] is not None:
             col = h % data_wrap
-            s += f"\n  {hours_time(time_line[t])}" if t == 0 or col == 0 else ""
+            s += f"\n  {hours_time(time_line[t])}" if t == start_t 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
@@ -3284,8 +3317,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     if show_plot > 0:
         print()
         plt.figure(figsize=(figure_width, figure_width/2))
-        x_timed = [i for i in range(0, run_time)]
-        x_ticks = [i for i in range(0, run_time, steps_per_hour)]
+        x_timed = [i for i in range(start_t, run_time)]
+        x_ticks = [i for i in range(start_t, run_time, steps_per_hour)]
         plt.xticks(ticks=x_ticks, labels=[hours_time(time_line[x]) for x in x_ticks], rotation=90, fontsize=8, ha='center')
         if show_plot == 1:
             title = f"Predicted Battery SoC % at {base_time}({charge_message})"
@@ -3395,14 +3428,15 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3, d=None):
     for v in plots.keys():
         for i in range(0, run_time):
             plots[v][i] = plots[v][i] / count[v][i] if count[v][i] > 0 else None
+    start_t = 0 #int(hour_now % 1 + 0.5) * steps_per_hour
     if show_data > 0 and plots.get('SoC') is not None:
         data_wrap = 1 #charge_config['data_wrap'] if charge_config.get('data_wrap') is not None else 1
         s = f"\nBattery Energy kWh (predicted / actual):" if show_data == 2 else f"\nBattery SoC (predicted / actual):"
         h = base_hour
-        t = 0
+        t = start_t
         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])}" if t == 0 or col == 0 else ""
+            s += f"\n  {hours_time(time_line[t])}" if t == start_t or col == 0 else ""
             s += f" {bat_timed[t]:5.2f}" if show_data == 2 else f"  {bat_timed[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
@@ -3411,8 +3445,8 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3, d=None):
     if show_plot > 0:
         print()
         plt.figure(figsize=(figure_width, figure_width/2))
-        x_timed = [i for i in range(0, run_time)]
-        x_ticks = [i for i in range(0, run_time, steps_per_hour)]
+        x_timed = [i for i in range(start_t, run_time)]
+        x_ticks = [i for i in range(start_t, run_time, steps_per_hour)]
         plt.xticks(ticks=x_ticks, labels=[hours_time(time_line[x]) for x in x_ticks], rotation=90, fontsize=8, ha='center')
         if show_plot == 1:
             title = f"Predicted Battery SoC % at {base_time}({charge_message})"
@@ -3555,11 +3589,11 @@ def battery_info(log=0, plot=1, count=None, info=1, bat=None):
                     s +=f",{v:.0f}"
         return s
     output(f"Current SoC:         {current_soc}%")
-    output(f"Capacity:            {capacity:.2f}kWh" + (" (Residual / SoC x 100)" if bat['residual_handling'] == 1 else ""))
-    output(f"Residual:            {residual:.2f}kWh" + (" (SoC x Capacity / 100)" if bat['residual_handling'] == 2 else ""))
+    output(f"Capacity:            {capacity:.2f}kWh" + (" (calculated)" if bat['residual_handling'] in [1,3] else ""))
+    output(f"Residual:            {residual:.2f}kWh" + (" (calculated)" if bat['residual_handling'] in [2,3] else ""))
     if rated_capacity is not None and bat_soh is not None:
         output(f"Rated Capacity:      {rated_capacity / 1000:.2f}kWh")
-        output(f"SoH:                 {bat_soh:.1f}%" + (" (Capacity / Rated Capacity x 100)" if not bat['soh_supported'] else ""))
+        output(f"SoH:                 {bat_soh:.1f}%" + (" (calculated)" if not bat['soh_supported'] else ""))
     output(f"InvBatVolt:          {bat_volt:.1f}V")
     output(f"InvBatCurrent:       {bat_current:.1f}A")
     output(f"State:               {'Charging' if bat_power < 0 else 'Discharging'} ({abs(bat_power):.3f}kW)")
@@ -3968,7 +4002,6 @@ class Solcast :
         # 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 = convert_date(d)
         self.shading = None if shading is None else shading if shading.get('solcast') is None else shading['solcast'] 
         self.today = datetime.strftime(datetime.date(now), '%Y-%m-%d')
@@ -3976,6 +4009,8 @@ class Solcast :
         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('-','')))
+        self.data = {}
+        self.rids = []
         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):
@@ -3984,33 +4019,37 @@ class Solcast :
             file.close()
             if len(self.data) == 0:
                 print(f"No data in {self.save}")
-            elif reload == 2 and 'date' in self.data and self.data['date'] != self.today:
-                self.data = {}
-            elif debug_setting > 0 and not quiet:
-                print(f"Using data for {self.data['date']} from {self.save}")
-        if len(self.data) == 0 :
+            else:
+                self.rids = self.data['forecasts'].keys() if self.data.get('forecasts') is not None else []
+                if reload == 2 and self.data.get('date') is not None and self.data['date'] != self.today:
+                    self.data = {}
+                elif debug_setting > 0 and not quiet:
+                    print(f"Using data for {self.data['date']} from {self.save}")
+        if len(self.data) == 0:
             if solcast_api_key is None or solcast_api_key == 'my.solcast_api_key>':
                 print(f"\nSolcast: solcast_api_key not set, exiting")
                 return
             self.credentials = HTTPBasicAuth(solcast_api_key, '')
-            if debug_setting > 1 and not quiet:
-                print(f"Getting rids from solcast.com")
-            params = {'format' : 'json'}
-            response = requests.get(solcast_url + 'rooftop_sites', auth = self.credentials, params = params)
-            if response.status_code != 200:
-                if response.status_code == 429:
-                    print(f"\nSolcast API call limit reached for today")
-                else:
-                    print(f"Solcast: response code getting rooftop_sites was {response.status_code}: {response.reason}")
-                return
-            sites = response.json().get('sites')
+            if len(self.rids) == 0:
+                if debug_setting > 1 and not quiet:
+                    print(f"Getting rids from solcast.com")
+                params = {'format' : 'json'}
+                response = requests.get(solcast_url + 'rooftop_sites', auth = self.credentials, params = params)
+                if response.status_code != 200:
+                    if response.status_code == 429:
+                        print(f"\nSolcast API call limit reached for today")
+                    else:
+                        print(f"Solcast: response code getting rooftop_sites was {response.status_code}: {response.reason}")
+                    return
+                sites = response.json().get('sites')
+                self.rids = [s['resource_id'] for s in sites]
             if debug_setting > 0 and not quiet:
                 print(f"Getting forecast for {self.today} from solcast.com")
             self.data['date'] = self.today
             params = {'format' : 'json', 'hours' : 168, 'period' : 'PT30M'}     # always get 168 x 30 min values
             for t in ['forecasts'] if estimated == 0 else ['forecasts', 'estimated_actuals']:
                 self.data[t] = {}
-                for rid in [s['resource_id'] for s in sites] :
+                for rid in self.rids:
                     response = requests.get(solcast_url + 'rooftop_sites/' + rid + '/' + t, auth = self.credentials, params = params)
                     if response.status_code != 200 :
                         if response.status_code == 429:

foxesscloud/openapi.py

@@ -1,7 +1,7 @@
 ##################################################################################################
 """
 Module:   Fox ESS Cloud using Open API
-Updated:  13 October 2024
+Updated:  01 November 2024
 By:       Tony Matthews
 """
 ##################################################################################################
@@ -10,7 +10,7 @@ By:       Tony Matthews
 # ALL RIGHTS ARE RESERVED © Tony Matthews 2024
 ##################################################################################################
 
-version = "2.6.4"
+version = "2.6.6"
 print(f"FoxESS-Cloud Open API version {version}")
 
 debug_setting = 1
@@ -281,7 +281,7 @@ var_table = None
 var_list = None
 
 def get_vars():
-    global var_table, var_list, debug_setting, messages, lang, token
+    global var_table, var_list, debug_setting, messages, lang
     if api_key is None:
         output(f"** please generate an API Key at foxesscloud.com and provide this (f.api_key='your API key')")
         return None
@@ -548,7 +548,7 @@ battery_settings = None
 battery_vars = ['SoC', 'invBatVolt', 'invBatCurrent', 'invBatPower', 'batTemperature', 'ResidualEnergy' ]
 battery_data = ['soc', 'volt', 'current', 'power', 'temperature', 'residual']
 
-# 1 = returns Residual Energy. 2 = resturns Residual Capacity
+# 1 = Residual Energy, 2 = Residual Capacity (HV), 3 = Residual Capacity per battery (Mira)
 residual_handling = 1
 
 # charge rates based on residual_handling
@@ -558,13 +558,20 @@ battery_params = {
     1: {'table': [ 0, 2, 10, 15, 25, 50, 50, 50, 50, 50, 30, 20, 0],
         'step': 5,
         'offset': 5,
-        'charge_loss': 0.975,
-        'discharge_loss': 0.975},
+        'charge_loss': 0.974,
+        'discharge_loss': 0.974},
+    # HV BMS v2 with firmware 1.014 or later
     2: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
         'step': 5,
         'offset': 5,
-        'charge_loss': 1.080,
-        'discharge_loss': 0.85},
+        'charge_loss': 1.08,
+        'discharge_loss': 0.95},
+    # Mira BMS with firmware 1.014 or later
+    3: {'table': [ 0, 2, 10, 10, 15, 15, 25, 50, 50, 50, 30, 20, 0],
+        'step': 5,
+        'offset': 5,
+        'charge_loss': 0.974,
+        'discharge_loss': 0.974},
 }
 
 def get_battery(info=0, v=None):
@@ -580,17 +587,28 @@ def get_battery(info=0, v=None):
     for i in range(0, len(battery_vars)):
         battery[battery_data[i]] = result[i].get('value')
     battery['residual_handling'] = residual_handling
-    battery['rated_capacity'] = None
     battery['soh'] = None
     battery['soh_supported'] = False
     if battery['residual_handling'] == 2:
         capacity = battery.get('residual')
         soc = battery.get('soc')
         residual = capacity * soc / 100 if capacity is not None and soc is not None else capacity
+        if battery.get('count') is None:
+            battery['count'] = int(battery['volt'] / 49)
+        if battery.get('ratedCapacity') is None:
+            battery['ratedCapacity'] = 2560 * battery['count']
+    elif battery['residual_handling'] == 3:
+        if battery.get('count') is None:
+            battery['count'] = int(battery['volt'] / 49)
+        capacity = (battery['residual'] * battery['count']) if battery.get('residual') is not None else None
+        soc = battery.get('soc')
+        residual = capacity * soc / 100 if capacity is not None and soc is not None else capacity
+        if battery.get('ratedCapacity') is None:
+            battery['ratedCapacity'] = 2450 * battery['count']
     else:
         residual = battery.get('residual')
         soc = battery.get('soc')
-        capacity = residual / soc * 100 if residual is not None and soc is not None and soc > 0 else None
+        capacity = residual / soc * 100 if residual is not None and soc is not None and soc > 0 else None 
     battery['capacity'] = round(capacity, 3)
     battery['residual'] = round(residual, 3)
     battery['status'] = 1
@@ -598,6 +616,8 @@ def get_battery(info=0, v=None):
     params = battery_params[battery['residual_handling']]
     battery['charge_loss'] = params['charge_loss']
     battery['discharge_loss'] = params['discharge_loss']
+    if battery.get('ratedCapacity') is not None and battery.get('capacity') is not None:
+        battery['soh'] = round(battery['capacity'] * 1000 / battery['ratedCapacity'] * 100, 1)
     if battery.get('temperature') is not None:
         battery['charge_rate'] = params['table'][int((battery['temperature'] - params['offset']) / params['step'])]
     return battery
@@ -615,7 +635,7 @@ def get_batteries(info=0):
 ##################################################################################################
 
 def get_charge():
-    global token, device_sn, battery_settings, debug_setting
+    global device_sn, battery_settings, debug_setting
     if get_device() is None:
         return None
     if battery_settings is None:
@@ -647,7 +667,7 @@ def time_period(t, n):
     return result
 
 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, time_period_vars
+    global device_sn, battery_settings, debug_setting, time_period_vars
     if get_device() is None:
         return None
     if battery_settings is None:
@@ -723,7 +743,7 @@ def set_charge(ch1=None, st1=None, en1=None, ch2=None, st2=None, en2=None, force
 ##################################################################################################
 
 def get_min():
-    global token, device_sn, battery_settings, debug_setting
+    global device_sn, battery_settings, debug_setting
     if get_device() is None:
         return None
     if battery_settings is None:
@@ -747,7 +767,7 @@ def get_min():
 ##################################################################################################
 
 def set_min(minSocOnGrid = None, minSoc = None, force = 0):
-    global token, device_sn, schedule, battery_settings, debug_setting
+    global device_sn, schedule, battery_settings, debug_setting
     if get_device() is None:
         return None
     if schedule['enable'] == True:
@@ -801,160 +821,71 @@ def get_settings():
 # get remote settings
 ##################################################################################################
 
-remote_settings = None              # raw UI info
-named_settings = None               # processed UI info
-merge_settings = {                  # keys to add
-    'WorkMode': {'keys': {
-        'h115__': 'operation_mode__work_mode',
-        'h116__': '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'],
-#        'k106__': ['k106__xx', 'k106__xx', 'k106__xx'],
-        },
-        'type': 'list',
-        'valueType': 'float',
-        'unit': 'V'},
-    'BatteryTemp': {'keys': {
-        'h115__': 'h115__17',
-        'h116__': 'h116__18',
-        'h117__': 'h117__18',
-#        'k106__': 'k106__xx',
-        },
-        'type': 'list',
-        'valueType': 'int',
-        'unit': '℃'},
-}
+# store for named settings info
+named_settings = {}
 
-def get_ui():
-    global device_id, debug_setting, messages, remote_settings, named_settings, merge_settings
-    if get_device() is None:
-        return None
-    if remote_settings is None:
-        output(f"getting ui settings", 2)
-        params = {'id': device_id}
-        response = signed_get(path="/generic/v0/device/setting/ui", params=params)
-        if response.status_code != 200:
-            output(f"** get_ui() got response code {response.status_code}: {response.reason}")
-            return None
-        result = response.json().get('result')
-        if result is None:
-            errno = response.json().get('errno')
-            output(f"** get_ui(), no result data, {errno_message(errno)}")
-            return None
-        remote_settings = result
-        protocol = remote_settings['protocol'].lower().replace('xx','__')
-        named_settings = {'_protocol': protocol}
-        volt_n = 0
-        volt_keys = []
-        for p in remote_settings['parameters']:
-            if p['name'][:11] == 'BatteryVolt':    # merge BatteryVolts
-                output(f"  found {p['name']} with key {p['key']}", 2)
-                volt_n += 1
-                volt_keys.append(p['key'])
-                if volt_n == 3:
-                    named_settings['BatteryVolt'] = {'keys': volt_keys, 'type': 'list', 'valueType': 'float', 'unit': p['properties'][0]['unit']}
-                elif volt_n > 3:
-                    print(f"** get_ui(): more than 3 groups found for BatteryVolt, n={volt_n}")
-            elif p['name'][:11] == 'BatteryTemp':
-                output(f"  found {p['name']} with key {p['key']}", 2)
-                named_settings['BatteryTemp'] = {'keys': p['key'], 'type': 'list', 'valueType': 'int', 'unit': p['properties'][0]['unit']}
-            else:
-                items = []
-                block = p['block'] and len(p['properties']) > 1
-                for e in p['properties']:
-                    valueType = e['elemType']['valueType']
-                    item = {'name': e['key'].replace(protocol,'')} if block else {'key': e['key']} #, 'group': p['name']}
-                    if e['elemType'].get('uiItems') is not None:
-                        item['values'] = e['elemType']['uiItems']
-                    elif e.get('range') is not None:
-                        item['range'] = e['range']
-                        item['valueType'] = 'float' if type(e['range']['hi']) is float else 'int'
-                    else:
-                        item['type'] = valueType
-                    if e.get('unit') is not None and len(e['unit']) > 0:
-                        item['unit'] = e['unit']
-                    if block:
-                        items.append(item)
-                    else:
-                        named_settings[e['name']] = item
-                if block:
-                    named_settings[p['name']] = {'key': p['key'], 'type': 'block', 'items': items}
-        for name in merge_settings.keys():
-            if named_settings.get(name) is None and merge_settings[name]['keys'].get(protocol) is not None:
-                named_settings[name] = {'keys': merge_settings[name]['keys'][protocol]}
-                for k in merge_settings[name].keys():
-                    if k != 'keys':
-                        named_settings[name][k] = merge_settings[name][k]
-    return remote_settings
-
-def get_remote_settings(key):
-    global token, device_id, debug_setting, messages
+def get_remote_settings(name):
+    global device_sn, debug_setting, messages, name_data
     if get_device() is None:
         return None
     output(f"getting remote settings", 2)
-    if key is None:
+    if name is None:
         return None
-    if type(key) is list:
+    if type(name) is list:
         values = {}
-        for k in key:
-            v = get_remote_settings(k)
+        for n in name:
+            v = get_remote_settings(n)
             if v is None:
-                return
+                continue
             for x in v.keys():
                 values[x] = v[x]
         return values
-    params = {'id': device_id, 'hasVersionHead': 1, 'key': key}
-    response = signed_get(path="/c/v0/device/setting/get", params=params)
+    body = {'sn': device_sn, 'key': name}
+    response = signed_post(path="/op/v0/device/setting/get", body=body)
     if response.status_code != 200:
         output(f"** get_remote_settings() got response code {response.status_code}: {response.reason}")
         return None
     result = response.json().get('result')
     if result is None:
         errno = response.json().get('errno')
-        output(f"** get_remote_settings(), no result data, {errno_message(errno)}")
+        output(f"** get_remote_settings(), no result data, {errno_message(response)}")
         return None
-    values = result.get('values')
-    if values is None:
-        output(f"** get_remote_settings(), no values data")
+    named_settings[name] = result
+    value = result.get('value')
+    if value is None:
+        output(f"** get_remote_settings(), no value for {name}")
         return None
-    return values
+    return value
 
 def get_named_settings(name):
-    global named_settings
-    if type(name) is list:
-        result = []
-        for n in name:
-            result.append(get_named_settings(n))
-        return result
-    if named_settings is None or named_settings.get(name) is None:
-        output(f"** get_named_settings(): {name} was not recognised")
+    return get_remote_settings(name)
+
+def set_named_setting(name, value):
+    global device_sn, debug_setting
+    if get_device() is None:
         return None
-    keys = named_settings[name].get('keys')
-    if keys is None:
-        output(f"** get_named_settings(): no keys for name: {name}")
+    if type(name) is list:
+        count = 0
+        for (n, v) in name:
+            result = set_named_settings(name=n, value=v)
+            if result is not None:
+                count += 1
+        return count
+    output(f"\nSetting {name} to {value}", 1)
+    body = {'sn': device_sn, 'key': name, 'value': f"{value}"}
+    setting_delay()
+    response = signed_post(path="/op/v0/device/setting/set", body=body)
+    if response.status_code != 200:
+        output(f"** set_named_settings(): ({name}, {value}) got response code {response.status_code}: {response.reason}")
         return None
-    output(f"getting named_settings for {name} using {keys}", 2)
-    result = get_remote_settings(keys)
-    if result is None:
-        output(f"** get_named_settings(): no result for {name} using key: {keys}")
+    errno = response.json().get('errno')
+    if errno != 0:
+        if errno == 44096:
+            output(f"** cannot update settings when schedule is active")
+        else:
+            output(f"** set_named_settings(): ({name}, {value}) {errno_message(response)}")
         return None
-    result_type = named_settings[name].get('type')
-    value_type = named_settings[name].get('valueType')
-    if result_type is None:
-        v = result.get([k for k in result.keys()][0])
-        return v if value_type is None else c_float(v) if value_type == 'float' else c_int(v)
-    if result_type == 'list':
-        values = []
-        for k in sorted(result.keys()):
-            values.append(result[k] if value_type is None else c_float(result[k]) if value_type == 'float' else c_int(result[k]))
-        return values
-    return result
+    return 1
 
 ##################################################################################################
 # wrappers for named settings
@@ -964,10 +895,10 @@ work_mode = None
 
 def get_work_mode():
     global work_mode
-#    print(f"** get_work_mode(): not available via Open API")
-    return None
     if get_device() is None:
         return None
+    # not implemented by Open API, skip to avoid error
+    return None
     work_mode = get_named_settings('WorkMode')
     return work_mode
 
@@ -983,6 +914,8 @@ temp_slots_per_battery = 8
 
 def get_cell_temps(nbat=8):
     global temp_slots_per_battery
+    print(f"** get_cell_temps(): not available via Open API")
+    return None
     values = get_named_settings('BatteryTemp')
     if values is None:
         return None
@@ -1008,9 +941,7 @@ work_modes = ['SelfUse', 'Feedin', 'Backup', 'ForceCharge', 'ForceDischarge']
 settable_modes = work_modes[:3]
 
 def set_work_mode(mode, force = 0):
-    global token, device_sn, work_modes, work_mode, debug_setting
-    print(f"** set_work_mode(): not available via Open API")
-    return None
+    global device_sn, work_modes, work_mode, debug_setting
     if get_device() is None:
         return None
     if mode not in settable_modes:
@@ -1022,7 +953,7 @@ def set_work_mode(mode, force = 0):
             return None
         set_schedule(enable=0)
     output(f"\nSetting work mode: {mode}", 1)
-    body = {'sn': device_sn, 'key': 'operation_mode__work_mode', 'values': {'operation_mode__work_mode': mode}, 'raw': ''}
+    body = {'sn': device_sn, 'key': 'WorkMode', 'value': mode}
     setting_delay()
     response = signed_post(path="/op/v0/device/setting/set", body=body)
     if response.status_code != 200:
@@ -1140,10 +1071,11 @@ def set_period(start=None, end=None, mode=None, min_soc=None, max_soc=None, fdso
         price = segment.get('price')
     start = time_hours(start)
     # adjust exclusive time to inclusive
-    end = round_time(time_hours(end) - 1/60)
+    end = time_hours(end)
     if start is None or end is None or start >= end:
         output(f"set_period(): ** invalid period times: {hours_time(start)}-{hours_time(end)}")
         return None
+    end = round_time(end - 1/60)
     mode = 'SelfUse' if mode is None else mode
     if mode not in work_modes:
         output(f"** mode must be one of {work_modes}")
@@ -1180,7 +1112,7 @@ def set_period(start=None, end=None, mode=None, min_soc=None, max_soc=None, fdso
 
 # set a schedule from a period or list of time segment periods
 def set_schedule(periods=None, enable=True):
-    global token, device_sn, debug_setting, schedule
+    global device_sn, debug_setting, schedule
     if get_flag() is None:
         return None
     if schedule.get('support') == False:
@@ -1200,8 +1132,7 @@ def set_schedule(periods=None, enable=True):
             periods = [periods]
         if len(periods) > 8:
             output(f"** set_schedule(): maximum of 8 periods allowed, {len(periods)} provided")
-            return None
-        body = {'deviceSN': device_sn, 'groups': periods}
+        body = {'deviceSN': device_sn, 'groups': periods[-8:]}
         setting_delay()
         response = signed_post(path="/op/v0/device/scheduler/enable", body=body)
         if response.status_code != 200:
@@ -1279,7 +1210,7 @@ def get_real(v = None):
 # d = day 'YYYY-MM-DD'. Can also include 'HH:MM' in 'hour' mode
 # v = list of variables to get
 # summary = 0: raw data, 1: add max, min, sum, 2: summarise and drop raw data, 3: calculate state
-# save = "xxxxx": save the raw results to xxxxx_raw_<time_span>_<d>.json
+# save = "xxxxx": save the raw results to xxxxx_history_<time_span>_<d>.json
 # load = "<file>": load the raw results from <file>
 # plot = 0: no plot, 1: plot variables separately, 2: combine variables 
 ##################################################################################################
@@ -1294,7 +1225,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, storage
+    global 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()
@@ -1546,7 +1477,7 @@ def report_value_profile(result):
 # d = day 'YYYY-MM-DD'
 # v = list of report variables to get
 # summary = 0, 1, 2: do a quick total energy report for a day
-# save = "xxxxx": save the report results to xxxxx_raw_<time_span>_<d>.json
+# save = "xxxxx": save the report results to xxxxx_report_<time_span>_<d>.json
 # load = "<file>": load the report results from <file>
 # plot = 0: no plot, 1 = plot variables separately, 2 = combine variables
 ##################################################################################################
@@ -1560,7 +1491,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, storage
+    global device_sn, var_list, debug_setting, report_vars, storage
     if get_device() is None:
         return None
     # process list of days
@@ -2392,7 +2323,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.get('off_peak4')])
+        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
@@ -2469,15 +2400,15 @@ def forecast_value_timed(forecast, today, tomorrow, base_hour, run_time, time_of
     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):
+def strategy_timed(timed_mode, time_line, run_time, min_soc=10, max_soc=100, current_mode=None):
     global tariff, steps_per_hour
     work_mode_timed = []
     min_soc_now = min_soc
     max_soc_now = max_soc
     current_mode = 'SelfUse' if current_mode is None else current_mode
     strategy = get_strategy(timed_mode=timed_mode)
-    h = base_hour
     for i in range(0, run_time):
+        h = time_line[i]
         period = {'mode': current_mode, 'min_soc': min_soc_now, 'max_soc': max_soc, 'fdpwr': 0, 'fdsoc': min_soc_now, 'duration': 1.0, 'charge': 0.0,
             'pv': 0.0, 'discharge': 0.0, 'hold': 0, 'kwh': None}
         if strategy is not None:
@@ -2497,11 +2428,10 @@ def strategy_timed(timed_mode, base_hour, run_time, min_soc=10, max_soc=100, cur
                             period['fdpwr'] = d['fdpwr']
                     period['duration'] = duration_in(h, d) * steps_per_hour
         work_mode_timed.append(period)
-        h = round_time(h + 1 / steps_per_hour)
     return work_mode_timed
 
 # build the timed battery residual from the charge / discharge, work mode and min_soc
-# note: all power values are as measured at the inverter battery connection
+# 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
     allowed_drain = charge_config['allowed_drain'] if charge_config.get('allowed_drain') is not None else 4
@@ -2510,7 +2440,8 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
     discharge_loss = charge_config['discharge_loss']
     charge_limit = charge_config['charge_limit']
     float_charge = charge_config['float_charge']
-    for i in range(0, len(work_mode_timed)):
+    run_time = len(work_mode_timed)
+    for i in range(0, run_time):
         w = work_mode_timed[i]
         w['kwh'] = kwh_current
         max_now = w['max_soc'] * capacity / 100
@@ -2521,6 +2452,7 @@ def battery_timed(work_mode_timed, kwh_current, capacity, time_to_next, kwh_min=
         if kwh_current > capacity:
             # battery is full
             kwh_current = capacity
+        w = work_mode_timed[i+1] if (i + 1) < run_time else w
         min_soc_now = w['fdsoc'] if w['mode'] =='ForceDischarge' else w['min_soc']
         reserve_now = capacity * min_soc_now / 100
         if kwh_current < reserve_now and (i < time_to_next or kwh_min is None):
@@ -2550,7 +2482,7 @@ def charge_periods(work_mode_timed, base_hour, min_soc, capacity):
         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']:
+        if h == 24 or period['mode'] != next_period['mode'] or period['hold'] != next_period['hold'] or period['min_soc'] != next_period['min_soc']:
             s = {'start': start % 24, 'end': h % 24, 'mode': period['mode'], 'min_soc': period['min_soc']}
             if period['mode'] == 'ForceDischarge':
                 s['fdsoc'] = period.get('fdsoc')
@@ -2642,7 +2574,7 @@ charge_needed_app_key = "awcr5gro2v13oher3v1qu6hwnovp28"
 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, battery, charge_rates
+    global timed_strategy, steps_per_hour, base_time, storage, battery, battery_params
     print(f"\n---------------- charge_needed ----------------")
     # validate parameters
     args = locals()
@@ -2749,8 +2681,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         bat_power = 0.0
         temperature = 30
         bms_charge_current = 15
-        charge_loss = charge_rates[2]['charge_loss']
-        discharge_loss = charge_rates[2]['discharge_loss']
+        charge_loss = battery_params[2]['charge_loss']
+        discharge_loss = battery_params[2]['discharge_loss']
         bat_current = 0.0
         device_power = 6.0
         device_current = 35
@@ -2772,8 +2704,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
             output(f"Battery capacity could not be estimated. Please add the parameter 'capacity=xx' in kWh")
             return None
         bms_charge_current = battery.get('charge_rate')
-        charge_loss = battery['charge_loss'] if battery.get('charge_loss') is not None else 1.0
-        discharge_loss = battery['discharge_loss'] if battery.get('discharge_loss') is not None else 1.0
+        charge_loss = battery['charge_loss'] if battery.get('charge_loss') is not None else 0.974
+        discharge_loss = battery['discharge_loss'] if battery.get('discharge_loss') is not None else 0.974
         device_power = device.get('power')
         device_current = device.get('max_charge_current')
         model = device.get('deviceType')
@@ -2943,7 +2875,7 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     # produce time lines for charge, discharge and work mode
     charge_timed = [min([charge_limit, c_float(x) * pv_loss]) for x in generation_timed]
     discharge_timed = [min([discharge_limit, c_float(x) / dc_ac_loss]) + bms_loss for x in consumption_timed]
-    work_mode_timed = strategy_timed(timed_mode, base_hour, run_time, min_soc=min_soc, max_soc=max_soc, current_mode=current_mode)
+    work_mode_timed = strategy_timed(timed_mode, time_line, run_time, min_soc=min_soc, max_soc=max_soc, current_mode=current_mode)
     for i in range(0, len(work_mode_timed)):
         # get work mode
         work_mode = work_mode_timed[i]['mode']
@@ -3071,14 +3003,15 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
         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")
+    start_t = 0 #int(hour_now % 1 + 0.5) * steps_per_hour
     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:"
         h = base_hour
-        t = 0
+        t = start_t
         while t < len(time_line) and bat_timed[t] is not None:
             col = h % data_wrap
-            s += f"\n  {hours_time(time_line[t])}" if t == 0 or col == 0 else ""
+            s += f"\n  {hours_time(time_line[t])}" if t == start_t 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
@@ -3086,8 +3019,8 @@ def charge_needed(forecast=None, update_settings=0, timed_mode=None, show_data=N
     if show_plot > 0:
         print()
         plt.figure(figsize=(figure_width, figure_width/2))
-        x_timed = [i for i in range(0, run_time)]
-        x_ticks = [i for i in range(0, run_time, steps_per_hour)]
+        x_timed = [i for i in range(start_t, run_time)]
+        x_ticks = [i for i in range(start_t, run_time, steps_per_hour)]
         plt.xticks(ticks=x_ticks, labels=[hours_time(time_line[x]) for x in x_ticks], rotation=90, fontsize=8, ha='center')
         if show_plot == 1:
             title = f"Predicted Battery SoC % at {base_time}({charge_message})"
@@ -3196,14 +3129,15 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3):
     for v in plots.keys():
         for i in range(0, run_time):
             plots[v][i] = plots[v][i] / count[v][i] if count[v][i] > 0 else None
+    start_t = 0 #int(hour_now % 1 + 0.5) * steps_per_hour
     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:" if show_data == 2 else f"\nBattery SoC:"
         h = base_hour
-        t = 0
+        t = start_t
         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])}" if t == 0 or col == 0 else ""
+            s += f"\n  {hours_time(time_line[t])}" if t == start_t 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
@@ -3211,8 +3145,8 @@ def charge_compare(save=None, v=None, show_data=1, show_plot=3):
     if show_plot > 0:
         print()
         plt.figure(figsize=(figure_width, figure_width/2))
-        x_timed = [i for i in range(0, run_time)]
-        x_ticks = [i for i in range(0, run_time, steps_per_hour)]
+        x_timed = [i for i in range(start_t, run_time)]
+        x_ticks = [i for i in range(start_t, run_time, steps_per_hour)]
         plt.xticks(ticks=x_ticks, labels=[hours_time(time_line[x]) for x in x_ticks], rotation=90, fontsize=8, ha='center')
         if show_plot == 1:
             title = f"Predicted Battery SoC % at {base_time}({charge_message})"
@@ -3354,8 +3288,8 @@ def battery_info(log=0, plot=1, count=None, info=1, bat=None):
                     s +=f",{v:.0f}"
         return s
     output(f"Current SoC:         {current_soc}%")
-    output(f"Capacity:            {capacity:.2f}kWh" + (" (Residual / SoC x 100)" if bat['residual_handling'] == 1 else ""))
-    output(f"Residual:            {residual:.2f}kWh" + (" (SoC x Capacity / 100)" if bat['residual_handling'] == 2 else ""))
+    output(f"Capacity:            {capacity:.2f}kWh" + (" (calculated)" if bat['residual_handling'] in [1,3] else ""))
+    output(f"Residual:            {residual:.2f}kWh" + (" (calculated)" if bat['residual_handling'] in [2,3] else ""))
     if rated_capacity is not None and bat_soh is not None:
         output(f"Rated Capacity:      {rated_capacity / 1000:.2f}kWh")
         output(f"SoH:                 {bat_soh:.1f}%" + (" (Capacity / Rated Capacity x 100)" if not bat['soh_supported'] else ""))
@@ -3767,7 +3701,6 @@ class Solcast :
         # 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 = convert_date(d)
         self.shading = None if shading is None else shading if shading.get('solcast') is None else shading['solcast'] 
         self.today = datetime.strftime(datetime.date(now), '%Y-%m-%d')
@@ -3775,6 +3708,8 @@ class Solcast :
         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('-','')))
+        self.data = {}
+        self.rids = []
         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):
@@ -3783,33 +3718,37 @@ class Solcast :
             file.close()
             if len(self.data) == 0:
                 print(f"No data in {self.save}")
-            elif reload == 2 and 'date' in self.data and self.data['date'] != self.today:
-                self.data = {}
-            elif debug_setting > 0 and not quiet:
-                print(f"Using data for {self.data['date']} from {self.save}")
+            else:
+                self.rids = self.data['forecasts'].keys() if self.data.get('forecasts') is not None else []
+                if reload == 2 and self.data.get('date') is not None and self.data['date'] != self.today:
+                    self.data = {}
+                elif debug_setting > 0 and not quiet:
+                    print(f"Using data for {self.data['date']} from {self.save}")
         if len(self.data) == 0 :
             if solcast_api_key is None or solcast_api_key == 'my.solcast_api_key>':
                 print(f"\nSolcast: solcast_api_key not set, exiting")
                 return
             self.credentials = HTTPBasicAuth(solcast_api_key, '')
-            if debug_setting > 1 and not quiet:
-                print(f"Getting rids from solcast.com")
-            params = {'format' : 'json'}
-            response = requests.get(solcast_url + 'rooftop_sites', auth = self.credentials, params = params)
-            if response.status_code != 200:
-                if response.status_code == 429:
-                    print(f"\nSolcast API call limit reached for today")
-                else:
-                    print(f"Solcast: response code getting rooftop_sites was {response.status_code}: {response.reason}")
-                return
-            sites = response.json().get('sites')
+            if len(self.rids) == 0:
+                if debug_setting > 1 and not quiet:
+                    print(f"Getting rids from solcast.com")
+                params = {'format' : 'json'}
+                response = requests.get(solcast_url + 'rooftop_sites', auth = self.credentials, params = params)
+                if response.status_code != 200:
+                    if response.status_code == 429:
+                        print(f"\nSolcast API call limit reached for today")
+                    else:
+                        print(f"Solcast: response code getting rooftop_sites was {response.status_code}: {response.reason}")
+                    return
+                sites = response.json().get('sites')
+                self.rids = [s['resource_id'] for s in sites]
             if debug_setting > 0 and not quiet:
                 print(f"Getting forecast for {self.today} from solcast.com")
             self.data['date'] = self.today
             params = {'format' : 'json', 'hours' : 168, 'period' : 'PT30M'}     # always get 168 x 30 min values
             for t in ['forecasts'] if estimated == 0 else ['forecasts', 'estimated_actuals']:
                 self.data[t] = {}
-                for rid in [s['resource_id'] for s in sites] :
+                for rid in self.rids:
                     response = requests.get(solcast_url + 'rooftop_sites/' + rid + '/' + t, auth = self.credentials, params = params)
                     if response.status_code != 200 :
                         if response.status_code == 429:
@@ -3818,7 +3757,7 @@ class Solcast :
                             print(f"Solcast: response code getting {t} was {response.status_code}: {response.reason}")
                         return
                     self.data[t][rid] = response.json().get(t)
-            if self.save is not None :
+            if self.save is not None:
                 file = open(storage + self.save, 'w')
                 json.dump(self.data, file, sort_keys = True, indent=4, ensure_ascii= False)
                 file.close()

{foxesscloud-2.6.4.dist-info → foxesscloud-2.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxesscloud
-Version: 2.6.4
+Version: 2.6.6
 Summary: library for accessing Fox ESS cloud data using Open API
 Author-email: Tony Matthews <tony@quasair.co.uk>
 Project-URL: Homepage, https://github.com/TonyM1958/FoxESS-Cloud
@@ -111,6 +111,7 @@ f.get_charge()
 f.get_min()
 f.get_flag()
 f.get_schedule()
+f.get_named_settings(name)
 
 ```
 Each of these calls will return a dictionary or list containing the relevant information.
@@ -130,6 +131,10 @@ get_flag() returns the current scheduler enable / support / maxsoc flags
 
 get_schedule() returns the current work mode / soc schedule settings. The result is stored in f.schedule.
 
+get_named_settings() returns the value of a named setting. If 'name' is a list, it returns a list of values.
++ f.named_settings is updated. This is dictionary of information and current value, indexed by 'name.
++ the only name currently supported by Fox is 'ExportLimit' and this is only available for H3 inverters.
+
 
 ## Inverter Settings
 You can change inverter settings using:
@@ -140,6 +145,7 @@ f.set_charge(ch1, st1, en1, ch2, st2, en2, enable)
 f.set_period(start, end, mode, min_soc, max_soc, fdsoc, fdpwr, price, segment)
 f.charge_periods(st0, en0, st1, en1, st2, en2, min_soc, target_soc, start_soc)
 f.set_schedule(periods, enable)
+f.set_named_settings(name, value)
 ```
 
 set_min() applies new SoC settings to the inverter. The parameters update battery_settings:
@@ -180,6 +186,10 @@ set_schedule() configures a list of scheduled work mode / soc changes with enabl
 + periods: a time segment or list of time segments created using f.set_period().
 + enable: 1 to enable schedules, 0 to disable schedules. The default is 1.
 
+set_named_settings() sets the 'name' setting to 'value'.
++ 'name' may also be a list of (name, value) pairs.
++ the only 'name' currently supported by Fox is 'ExportLimit' on H3 inverters
+
 
 ## Real Time Data
 Real time data reports the latest values for inverter variables, collected every 5 minutes:
@@ -787,6 +797,21 @@ This setting can be:
 
 # Version Info
 
+2.6.6<br>
+Add residual_handling=3 for Mira BMS with firmware 1.014 or later that returns residual capacity per battery.
+Calculate 'ratedCapacity' in get_battery() and 'soh' for HV2600 and Mira.
+Allow unlimited periods in strategy, including overlap with charge periods but warn and limit if the periods sent to inverter would be more than 8.
+Improve behaviour prediction for schedules when clocks change due to day light saving.
+Improve schedule generation and prediction when Min Soc changes.
+Cache Solcast RIDS to reduce API usage (run with reload=1 if arrays are edited and cached RIDs need to be updated).
+Remove spurious error message when (failing) to get inverter work mode.
+
+2.6.5<br>
+Add get_named_settings() and set_named_settings().
+Update get_work_mode() and set_work_mode() to use named settings (still doesn't work though as blocked by Fox)
+Updated get_history() and get_report() saved filenames to use _history_ and _report_ for consistency.
+Update calibration of 'charge_loss' and 'discharge_loss'.
+
 2.6.4<br>
 Increase default plungs_slots from 6 to 8.
 Correct battery capacity in get_batteries().

foxesscloud-2.6.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+foxesscloud/foxesscloud.py,sha256=lmIa4uFTrwUSyRj2HWFMiuJ1UItOQzDfojqZQv_FjHY,219893
+foxesscloud/openapi.py,sha256=V7vlbq_Cynde-BMf13UziuKfni8a8aX_lQej1fC6cO0,204609
+foxesscloud-2.6.6.dist-info/LICENCE,sha256=-3xv8CElCJV8Bc8PbAsg3iyxMpAK8MoJneM3rXigxqI,1074
+foxesscloud-2.6.6.dist-info/METADATA,sha256=2upWkpfGnqFrpRN3dU9Snbpj1hPHdiCenTrHqlD1L74,59461
+foxesscloud-2.6.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+foxesscloud-2.6.6.dist-info/top_level.txt,sha256=IWOrKSNZCLU6IDXSX_b4_bqCfbZoWAT4CC0w0Lg7PuU,12
+foxesscloud-2.6.6.dist-info/RECORD,,

foxesscloud-2.6.4.dist-info/RECORD

@@ -1,7 +0,0 @@
-foxesscloud/foxesscloud.py,sha256=kfb3Ard_s3LZ1hN53RfwcRUyEeMGd6TviHtoFmQyYDY,217547
-foxesscloud/openapi.py,sha256=jFWMAlbhHAFqlKZlg8rALgU-jziUdrTjM0b4I0eTyAQ,207518
-foxesscloud-2.6.4.dist-info/LICENCE,sha256=-3xv8CElCJV8Bc8PbAsg3iyxMpAK8MoJneM3rXigxqI,1074
-foxesscloud-2.6.4.dist-info/METADATA,sha256=uNjXzpjeHGt65jOvDoLApHmb8-awuWtRg9BRfJKnzFU,57854
-foxesscloud-2.6.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-foxesscloud-2.6.4.dist-info/top_level.txt,sha256=IWOrKSNZCLU6IDXSX_b4_bqCfbZoWAT4CC0w0Lg7PuU,12
-foxesscloud-2.6.4.dist-info/RECORD,,