powers = [get_power(str(phase)) for phase in range(1, 4)]
counter_state = CounterState(
imported=sma_data['pconsumecounter'] * 1000,
exported=sma_data['psupplycounter'] * 1000,
power=get_power(),
voltages=[sma_data["u" + str(phase)] for phase in range(1, 4)],
# currents reported are always absolute values. We get the sign from power:
currents=[
copysign(sma_data["i" + str(phase)], powers[phase - 1])
for phase in range(1, 4)
],
powers=powers,
power_factors=[
sma_data["cosphi" + str(phase)] for phase in range(1, 4)
])
frequency = sma_data.get("frequency")
if frequency:
counter_state.frequency = frequency
return counter_state
def create_component(component_config: SmaHomeManagerCounterSetup):
return SpeedwireComponent(get_counter_value_store, parse_datagram,
component_config)
component_descriptor = ComponentDescriptor(
configuration_factory=SmaHomeManagerCounterSetup)
grid_power = grid_import_power - grid_export_power
topic_str = "openWB/set/system/device/" + str(
self.__device_id) + "/component/" + str(
self.component_config.id) + "/"
imported, exported = self.__sim_count.sim_count(grid_power,
topic=topic_str,
data=self.simulation,
prefix="bezug")
return CounterState(
power=grid_power,
imported=imported,
exported=exported,
)
def update(self) -> None:
log.debug("Variante: " + str(self.__device_variant))
if self.__device_variant == 0:
log.debug("Die Variante '0' bietet keine EVU Daten!")
elif self.__device_variant == 1:
state = self.__update_variant_1()
elif self.__device_variant == 2:
state = self.__update_variant_2()
else:
raise FaultState.error("Unbekannte Variante: " +
str(self.__device_variant))
self.__store.set(state)
component_descriptor = ComponentDescriptor(
configuration_factory=SonnenbatterieCounterSetup)
url, self.component_config.configuration.power_path)
self.__get_imported = create_request_function(
url, self.component_config.configuration.imported_path)
self.__get_exported = create_request_function(
url, self.component_config.configuration.exported_path)
self.__get_soc = create_request_function(
url, self.component_config.configuration.soc_path)
def update(self) -> None:
imported = self.__get_imported()
exported = self.__get_exported()
power = self.__get_power()
if imported is None or exported is None:
topic_str = "openWB/set/system/device/" + str(
self.__device_id) + "/component/" + str(
self.component_config.id) + "/"
imported, exported = self.__sim_count.sim_count(
power,
topic=topic_str,
data=self.simulation,
prefix="speicher")
bat_state = BatState(power=power,
soc=self.__get_soc(),
imported=imported,
exported=exported)
self.__store.set(bat_state)
component_descriptor = ComponentDescriptor(configuration_factory=HttpBatSetup)
power = self.__tcp_client.read_holding_registers(789, ModbusDataType.UINT_16, unit=modbus_id) / -10
except Exception as e:
if "GatewayPathUnavailable" in str(e):
power = 0
log.debug(self.component_config.name +
": Reg 789 konnte nicht gelesen werden, Power auf 0 gesetzt.")
else:
raise
else:
# Adresse 808-810 ac output connected pv
# Adresse 811-813 ac input connected pv
# Adresse 850 mppt Leistung
power_temp1 = self.__tcp_client.read_holding_registers(808, [ModbusDataType.UINT_16]*6, unit=100)
power_temp2 = self.__tcp_client.read_holding_registers(850, ModbusDataType.UINT_16, unit=100)
power = (sum(power_temp1)+power_temp2) * -1
topic_str = "openWB/set/system/device/" + str(self.__device_id)+"/component/" + \
str(self.component_config.id)+"/"
_, exported = self.__sim_count.sim_count(power,
topic=topic_str,
data=self.simulation,
prefix="pv%s" % ("" if self.component_config.id == 1 else "2"))
inverter_state = InverterState(
power=power,
exported=exported
)
self.__store.set(inverter_state)
component_descriptor = ComponentDescriptor(configuration_factory=VictronInverterSetup)
tcp_client: modbus.ModbusTcpClient_,
modbus_id: int) -> None:
self.__device_id = device_id
self.__modbus_id = modbus_id
self.component_config = dataclass_from_dict(HuaweiInverterSetup, component_config)
self.__tcp_client = tcp_client
self.__sim_count = simcount.SimCountFactory().get_sim_counter()()
self.simulation = {}
self.__store = get_inverter_value_store(self.component_config.id)
self.component_info = ComponentInfo.from_component_config(self.component_config)
def update(self) -> None:
time.sleep(0.1)
power = self.__tcp_client.read_holding_registers(32064, ModbusDataType.INT_32, unit=self.__modbus_id) * -1
topic_str = "openWB/set/system/device/" + \
str(self.__device_id)+"/component/" + \
str(self.component_config.id)+"/"
_, exported = self.__sim_count.sim_count(power,
topic=topic_str,
data=self.simulation,
prefix="pv%s" % ("" if self.component_config.id == 1 else "2"))
inverter_state = InverterState(
power=power,
exported=exported
)
self.__store.set(inverter_state)
component_descriptor = ComponentDescriptor(configuration_factory=HuaweiInverterSetup)
power_factors = self.__client.get_power_factors()
if isinstance(self.__client, Mpm3pm):
imported = self.__client.get_imported()
exported = self.__client.get_exported()
else:
currents = self.__client.get_currents()
if isinstance(self.__client, Mpm3pm):
currents = [powers[i] / voltages[i] for i in range(3)]
else:
if isinstance(self.__client, Lovato):
power = sum(powers)
topic_str = "openWB/set/system/device/{}/component/{}/".format(
self.__device_id, self.component_config.id)
imported, exported = self.__sim_count.sim_count(
power, topic=topic_str, data=self.simulation, prefix="bezug")
counter_state = CounterState(voltages=voltages,
currents=currents,
powers=powers,
power_factors=power_factors,
imported=imported,
exported=exported,
power=power,
frequency=frequency)
self.__store.set(counter_state)
component_descriptor = ComponentDescriptor(
configuration_factory=EvuKitFlexSetup)
self.component_config = dataclass_from_dict(JsonCounterSetup,
component_config)
self.__sim_count = simcount.SimCountFactory().get_sim_counter()()
self.simulation = {}
self.__store = get_counter_value_store(self.component_config.id)
self.component_info = ComponentInfo.from_component_config(
self.component_config)
def update(self, response):
config = self.component_config.configuration
power = jq.compile(config.jq_power).input(response).first()
# ToDo: add current or power per phase
if config.jq_imported == "" or config.jq_exported == "":
topic_str = "openWB/set/system/device/{}/component/{}/".format(
self.__device_id, self.component_config.id)
imported, exported = self.__sim_count.sim_count(
power, topic=topic_str, data=self.simulation, prefix="bezug")
else:
imported = jq.compile(config.jq_imported).input(response).first()
exported = jq.compile(config.jq_exported).input(response).first()
counter_state = CounterState(imported=imported,
exported=exported,
power=power)
self.__store.set(counter_state)
component_descriptor = ComponentDescriptor(
configuration_factory=JsonCounterSetup)
# 40222/40223/40224: Power factor by phase (unit=%)
# 40225: AC Power Factor Scale Factor
power_factors = [
power_factor / 100 for power_factor in read_scaled_int16(40222, 3)
]
# 40226: Total Exported Real Energy
# 40228/40230/40232: Total Exported Real Energy Phase (not used)
# 40234: Total Imported Real Energy
# 40236/40238/40240: Total Imported Real Energy Phase (not used)
# 40242: Real Energy Scale Factor
counter_values = read_scaled_uint32(40226, 8)
counter_exported, counter_imported = [
counter_values[i] for i in [0, 4]
]
counter_state = CounterState(imported=counter_imported,
exported=counter_exported,
power=powers[0],
powers=powers[1:],
voltages=voltages,
currents=currents,
power_factors=power_factors,
frequency=frequency)
self.__store.set(counter_state)
component_descriptor = ComponentDescriptor(
configuration_factory=SolaredgeCounterSetup)
self.__sim_count = simcount.SimCountFactory().get_sim_counter()()
self.simulation = {}
self.__store = get_bat_value_store(self.component_config.id)
self.component_info = ComponentInfo.from_component_config(self.component_config)
def update(self) -> None:
unit = 1
with self.__tcp_client:
soc = int(self.__tcp_client.read_input_registers(13022, ModbusDataType.INT_16, unit=unit) / 10)
resp = self.__tcp_client.delegate.read_input_registers(13000, 1, unit=unit)
binary = bin(resp.registers[0])[2:].zfill(8)
power = self.__tcp_client.read_input_registers(13021, ModbusDataType.INT_16, unit=unit)
if binary[5] == "1":
power = power * -1
topic_str = "openWB/set/system/device/" + str(
self.__device_id)+"/component/"+str(self.component_config.id)+"/"
imported, exported = self.__sim_count.sim_count(
power, topic=topic_str, data=self.simulation, prefix="speicher"
)
bat_state = BatState(
power=power,
soc=soc,
imported=imported,
exported=exported
)
self.__store.set(bat_state)
component_descriptor = ComponentDescriptor(configuration_factory=SungrowBatSetup)
