Verbrauchersteuerung

data/config/mosquitto/local/openwb_local.conf

@@ -1,4 +1,4 @@
-# openwb-version:20
+# openwb-version:21
 listener 1886 localhost
 allow_anonymous true
 
@@ -28,6 +28,15 @@ topic openWB/chargepoint/+/get/# out 2
 topic openWB/chargepoint/+/config/# out 2
 topic openWB/chargepoint/template/# out 2
 
+topic openWB/consumer/get/# out 2
+
+topic openWB/consumer/+/module out 2
+topic openWB/consumer/+/config out 2
+topic openWB/consumer/+/extra_meter out 2
+topic openWB/consumer/+/usage out 2
+topic openWB/consumer/+/get/# out 2
+topic openWB/consumer/+/set/# out 2
+
 topic openWB/internal_chargepoint/# out 2
 
 topic openWB/io/# out 2

data/config/mosquitto/public/default-dynamic-security.json

@@ -1109,6 +1109,24 @@
 					"priority": 0,
 					"allow": true
 				},
+				{
+					"acltype": "publishClientSend",
+					"topic": "openWB/set/general/chargemode_config/surplus/consumer/switch_on_delay",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientSend",
+					"topic": "openWB/set/general/chargemode_config/surplus/consumer/switch_off_delay",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientSend",
+					"topic": "openWB/set/general/chargemode_config/surplus/consumer/switch_off_threshold",
+					"priority": 0,
+					"allow": true
+				},
 				{
 					"acltype": "publishClientReceive",
 					"topic": "openWB/system/security/access/SurplusChargeConfiguration",
@@ -1168,6 +1186,24 @@
 					"topic": "openWB/general/chargemode_config/surplus/vehicle/switch_off_delay",
 					"priority": 0,
 					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/general/chargemode_config/surplus/consumer/switch_on_delay",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/general/chargemode_config/surplus/consumer/switch_off_delay",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/general/chargemode_config/surplus/consumer/switch_off_threshold",
+					"priority": 0,
+					"allow": true
 				}
 			]
 		},
@@ -1745,6 +1781,61 @@
 				}
 			]
 		},
+		{
+			"rolename": "consumer-configuration-access",
+			"textname": "Zugang zu den Verbrauchereinstellungen",
+			"textdescription": "Erlaubt den Zugang zu den Verbrauchereinstellungen.",
+			"acls": [
+				{
+					"acltype": "publishClientSend",
+					"topic": "openWB/consumer/+/config",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientSend",
+					"topic": "openWB/consumer/+/module",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientSend",
+					"topic": "openWB/consumer/+/usage",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/consumer/+/config",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/consumer/+/module",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/consumer/+/usage",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/system/configurable/consumers",
+					"priority": 0,
+					"allow": true
+				},
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/optional/ep/configured",
+					"priority": 0,
+					"allow": true
+				}
+			]
+		},
 		{
 			"rolename": "vehicle-configuration-access",
 			"textname": "Zugang zu den Fahrzeugeinstellungen",
@@ -2849,6 +2940,19 @@
 				}
 			]
 		},
+		{
+			"rolename": "consumer-sum-access",
+			"textname": "Leserechte für Verbrauchersummendaten",
+			"textdescription": "Erlaubt das Empfangen von Daten für die Summe aller Verbraucher.",
+			"acls": [
+				{
+					"acltype": "publishClientReceive",
+					"topic": "openWB/consumer/get/+",
+					"priority": 0,
+					"allow": true
+				}
+			]
+		},
 		{
 			"rolename": "tenant-energy-configuration-access",
 			"textname": "Leserechte für Mieterstromdaten",

data/config/mosquitto/public/role-templates.json

@@ -72,6 +72,62 @@
 				"allow": true
 			}
 		]
+	},
+		{
+		"rolename": "consumer-<id>-access",
+		"textname": "Leserechte für Verbraucher <id>",
+		"textdescription": "Erlaubt das Empfangen von Daten für Verbraucher <id>.",
+		"acls": [
+			{
+				"acltype": "publishClientSend",
+				"topic": "openWB/set/consumer/<id>/usage",
+				"priority": 0,
+				"allow": true
+			},
+			{
+				"acltype": "publishClientSend",
+				"topic": "openWB/set/command/+/todo/addConsumerSchedulePlan",
+				"priority": 0,
+				"allow": true
+			},
+			{
+				"acltype": "publishClientSend",
+				"topic": "openWB/set/command/+/todo/addConsumerTimePlan",
+				"priority": 0,
+				"allow": true
+			},
+			{
+				"acltype": "publishClientReceive",
+				"topic": "openWB/consumer/<id>/#",
+				"priority": 0,
+				"allow": true
+			}
+		]
+	},
+	{
+		"rolename": "consumer-<id>-write-access",
+		"textname": "Schreibrechte für MQTT-Verbraucher <id>",
+		"textdescription": "Erlaubt das Senden von Daten für Verbraucher <id>.",
+		"acls": [
+			{
+				"acltype": "publishClientSend",
+				"topic": "openWB/set/mqtt/consumer/<id>/get/#",
+				"priority": 0,
+				"allow": true
+			},
+			{
+				"acltype": "publishClientReceive",
+				"topic": "openWB/set/mqtt/consumer/<id>/get/#",
+				"priority": 0,
+				"allow": true
+			},
+			{
+				"acltype": "publishClientReceive",
+				"topic": "openWB/mqtt/consumer/<id>/#",
+				"priority": 0,
+				"allow": true
+			}
+		]
 	},
 	{
 		"rolename": "vehicle-<id>-access",

packages/conftest.py

@@ -224,8 +224,7 @@ def data_hc_counter_() -> None:
                                                 config=Mock(spec=Config, phase_1=1),
                                                 get=Mock(spec=Get, currents=[30, 0, 0], power=6900,
                                                          daily_imported=10000, daily_exported=0, imported=56000,
-                                                         fault_state=0),
-                                                set=Mock(spec=Set, loadmanagement_available=True)))}
+                                                         fault_state=0)))}
     data.data.pv_data.update({"pv1": Mock(spec=Pv, data=Mock(
         spec=PvData, get=Mock(spec=PvGet, power=-10000, daily_exported=6000, exported=27000, currents=None,
                               fault_state=0)))})

packages/control/algorithm/additional_current.py

@@ -1,13 +1,12 @@
 import logging
 
-from control import data
 from control.algorithm import common
 from control.algorithm.chargemodes import CONSIDERED_CHARGE_MODES_ADDITIONAL_CURRENT
 from control.limiting_value import LoadmanagementLimit
+from control.load_protocol import Load
 from control.loadmanagement import Loadmanagement
-from control.chargepoint.chargepoint import Chargepoint
-from control.algorithm.filter_chargepoints import (get_chargepoints_by_mode_and_counter,
-                                                   get_preferenced_chargepoint_charging)
+from control.algorithm.filter_chargepoints import (filtered_loads_to_str, get_grouped_loads_by_mode_and_counter,
+                                                   get_preferenced_load_charging)
 
 log = logging.getLogger(__name__)
 
@@ -19,44 +18,46 @@ def __init__(self) -> None:
 
     def set_additional_current(self) -> None:
         common.reset_current_by_chargemode(CONSIDERED_CHARGE_MODES_ADDITIONAL_CURRENT)
-        for mode_tuple, counter in common.mode_and_counter_generator(CONSIDERED_CHARGE_MODES_ADDITIONAL_CURRENT):
-            preferenced_chargepoints, preferenced_cps_without_set_current = get_preferenced_chargepoint_charging(
-                get_chargepoints_by_mode_and_counter(mode_tuple, f"counter{counter.num}"))
-            if preferenced_chargepoints:
-                common.update_raw_data(preferenced_chargepoints)
-                log.info(f"Mode-Tuple {mode_tuple[0]} - {mode_tuple[1]} - {mode_tuple[2]}, Zähler {counter.num}")
-                for cp, group in data.data.counter_all_data.generator_cps_by_loadmanagement_prios(
-                        preferenced_chargepoints):
-                    missing_currents, counts = common.get_missing_currents_left(group)
-                    available_currents, limit = Loadmanagement().get_available_currents(missing_currents, counter, cp)
-                    log.debug(f"cp {cp.num} available currents {available_currents} missing currents "
+        for counter in common.counter_generator():
+            preferenced_loads_groups, preferenced_loads_without_set_current = get_preferenced_load_charging(
+                get_grouped_loads_by_mode_and_counter(CONSIDERED_CHARGE_MODES_ADDITIONAL_CURRENT,
+                                                      f"counter{counter.num}"))
+            for preferenced_loads in preferenced_loads_groups:
+                common.update_raw_data(preferenced_loads)
+                if len(preferenced_loads) > 0:
+                    log.info(f"Zähler {counter.num}, Verbraucher {filtered_loads_to_str(preferenced_loads)}")
+                while len(preferenced_loads):
+                    load = preferenced_loads[0]
+                    missing_currents, counts = common.get_missing_currents_left(preferenced_loads)
+                    available_currents, limit = Loadmanagement().get_available_currents(missing_currents, counter, load)
+                    log.debug(f"load {load.num} available currents {available_currents} missing currents "
                               f"{missing_currents} limit {limit.message}")
-                    if limit.limiting_value is not None:
-                        cp.data.control_parameter.limit = limit
-                    available_for_cp = common.available_current_for_cp(cp, counts, available_currents, missing_currents)
+                    load.data.control_parameter.limit = limit
+                    available_for_cp = common.available_current_for_load(
+                        load, counts, available_currents, missing_currents)
                     current = common.get_current_to_set(
-                        cp.data.set.current, available_for_cp, cp.data.set.target_current)
-                    self._set_loadmangement_message(current, limit, cp)
+                        load.data.set.current, available_for_cp, load.data.set.target_current)
+                    self._set_loadmangement_message(current, limit, load)
                     common.set_current_counterdiff(
-                        cp.data.control_parameter.min_current,
+                        load.data.control_parameter.min_current,
                         current,
-                        cp)
-            if preferenced_cps_without_set_current:
-                for cp in preferenced_cps_without_set_current:
-                    cp.data.set.current = cp.data.set.target_current
+                        load)
+                    preferenced_loads.pop(0)
+            for load in preferenced_loads_without_set_current:
+                load.data.set.current = load.data.set.target_current
 
     # tested
     def _set_loadmangement_message(self,
                                    current: float,
                                    limit: LoadmanagementLimit,
-                                   chargepoint: Chargepoint) -> None:
+                                   load: Load) -> None:
         # Strom muss an diesem Zähler geändert werden
         log.debug(
-            f"current {current} target {chargepoint.data.set.target_current} set current {chargepoint.data.set.current}"
-            f" required currents {chargepoint.data.control_parameter.required_currents}")
-        if (current != max(chargepoint.data.set.target_current, chargepoint.data.set.current or 0) and
+            f"current {current} target {load.data.set.target_current} set current {load.data.set.current}"
+            f" required currents {load.data.control_parameter.required_currents}")
+        if (current != max(load.data.set.target_current, load.data.set.current or 0) and
                 # Strom erreicht nicht die vorgegebene Stromstärke
                 round(current, 2) != round(max(
-                    chargepoint.data.control_parameter.required_currents), 2)):
-            chargepoint.set_state_and_log(f"Es kann nicht mit der vorgegebenen Stromstärke geladen werden"
-                                          f"{limit.message}")
+                    load.data.control_parameter.required_currents), 2)):
+            load.set_state_and_log(f"Es kann nicht mit der vorgegebenen Stromstärke geladen werden"
+                                   f"{limit.message}")

packages/control/algorithm/bidi_charging.py

@@ -1,7 +1,8 @@
 import logging
 from control import data
 from control.algorithm.chargemodes import CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE
-from control.algorithm.filter_chargepoints import get_chargepoints_with_required_current_by_chargemode
+from control.algorithm.filter_chargepoints import filtered_loads_to_str, get_loads_by_chargemodes
+from control.chargepoint.chargepoint import Chargepoint
 from helpermodules.phase_handling import voltages_mean
 
 log = logging.getLogger(__name__)
@@ -15,30 +16,30 @@ def set_bidi(self):
         grid_counter = data.data.counter_all_data.get_evu_counter()
         log.debug(f"Nullpunktanpassung {grid_counter.data.set.surplus_power_left}W")
         zero_point_adjustment = grid_counter
-        for mode_tuple in CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE:
-            preferenced_cps = get_chargepoints_with_required_current_by_chargemode(mode_tuple)
-            if preferenced_cps:
-                log.info(
-                    f"Mode-Tuple {mode_tuple[0]} - {mode_tuple[1]} - {mode_tuple[2]}, Zähler {grid_counter.num}")
-                for cp, group in data.data.counter_all_data.generator_cps_by_loadmanagement_prios(preferenced_cps):
-                    zero_point_adjustment = grid_counter.data.set.surplus_power_left / len(group)
-                    log.debug(f"Nullpunktanpassung für LP{cp.num}: verbleibende Leistung {zero_point_adjustment}W")
-                    missing_currents = [zero_point_adjustment / cp.data.get.phases_in_use /
-                                        230 for i in range(0, cp.data.get.phases_in_use)]
-                    missing_currents += [0] * (3 - len(missing_currents))
-                    if zero_point_adjustment > 0:
-                        if cp.data.set.charging_ev_data.charge_template.bidi_charging_allowed(
-                                cp.data.control_parameter.current_plan, cp.data.set.charging_ev_data.data.get.soc):
-                            for index in range(0, 3):
-                                missing_currents[index] = min(cp.data.control_parameter.required_current,
-                                                              missing_currents[index])
-                        else:
-                            log.info(f"LP{cp.num}: Nur bidirektional entladen erlaubt, da SoC-Limit erreicht.")
-                            missing_currents = [0, 0, 0]
-                    else:
+        preferenced_cps = get_loads_by_chargemodes(CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE)
+        if preferenced_cps:
+            log.info(f"Verbraucher {filtered_loads_to_str(preferenced_cps)}")
+            while len(preferenced_cps):
+                cp: Chargepoint = preferenced_cps[0]
+                zero_point_adjustment = grid_counter.data.set.surplus_power_left / len(preferenced_cps)
+                log.debug(f"Nullpunktanpassung für LP{cp.num}: verbleibende Leistung {zero_point_adjustment}W")
+                missing_currents = [zero_point_adjustment / cp.data.get.phases_in_use /
+                                    230 for i in range(0, cp.data.get.phases_in_use)]
+                missing_currents += [0] * (3 - len(missing_currents))
+                if zero_point_adjustment > 0:
+                    if cp.data.set.charging_ev_data.charge_template.bidi_charging_allowed(
+                            cp.data.control_parameter.current_plan, cp.data.set.charging_ev_data.data.get.soc):
                         for index in range(0, 3):
-                            missing_currents[index] = cp.check_min_max_current(missing_currents[index],
-                                                                               cp.data.get.phases_in_use)
-                    grid_counter.update_surplus_values_left(missing_currents, voltages_mean(cp.data.get.voltages))
-                    cp.data.set.current = missing_currents[0]
-                    log.info(f"LP{cp.num}: Stromstärke {missing_currents}A")
+                            missing_currents[index] = min(cp.data.control_parameter.required_current,
+                                                          missing_currents[index])
+                    else:
+                        log.info(f"LP{cp.num}: Nur bidirektional entladen erlaubt, da SoC-Limit erreicht.")
+                        missing_currents = [0, 0, 0]
+                else:
+                    for index in range(0, 3):
+                        missing_currents[index] = cp.check_min_max_current(missing_currents[index],
+                                                                           cp.data.get.phases_in_use)
+                grid_counter.update_surplus_values_left(missing_currents, voltages_mean(cp.data.get.voltages))
+                cp.data.set.current = missing_currents[0]
+                log.info(f"LP{cp.num}: Stromstärke {missing_currents}A")
+                preferenced_cps.pop(0)