629 lines
21 KiB
Python
629 lines
21 KiB
Python
"""Support for power production statistics from GoodWe SEMS API.
|
|
|
|
For more details about this platform, please refer to the documentation at
|
|
https://github.com/TimSoethout/goodwe-sems-home-assistant
|
|
"""
|
|
|
|
from datetime import timedelta
|
|
import logging
|
|
# from typing import Coroutine
|
|
|
|
import homeassistant
|
|
from homeassistant.components.sensor import (
|
|
SensorDeviceClass,
|
|
SensorEntity,
|
|
SensorStateClass,
|
|
)
|
|
from homeassistant.components.switch import SwitchEntity
|
|
from homeassistant.const import CONF_SCAN_INTERVAL, UnitOfEnergy, UnitOfPower, Platform
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers import entity_registry
|
|
from homeassistant.helpers.device_registry import DeviceInfo
|
|
from homeassistant.helpers.update_coordinator import (
|
|
CoordinatorEntity,
|
|
DataUpdateCoordinator,
|
|
UpdateFailed,
|
|
)
|
|
|
|
from .const import CONF_STATION_ID, DEFAULT_SCAN_INTERVAL, DOMAIN
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
async def async_setup_entry(hass, config_entry, async_add_entities):
|
|
"""Add sensors for passed config_entry in HA."""
|
|
# _LOGGER.debug("hass.data[DOMAIN] %s", hass.data[DOMAIN])
|
|
# semsApi = hass.data[DOMAIN][config_entry.entry_id]
|
|
# stationId = config_entry.data[CONF_STATION_ID]
|
|
|
|
# _LOGGER.debug("config_entry %s", config_entry.data)
|
|
# update_interval = timedelta(
|
|
# seconds=config_entry.data.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
|
|
# )
|
|
|
|
# async def async_update_data():
|
|
# """Fetch data from API endpoint.
|
|
|
|
# This is the place to pre-process the data to lookup tables
|
|
# so entities can quickly look up their data.
|
|
# """
|
|
# try:
|
|
# # Note: asyncio.TimeoutError and aiohttp.ClientError are already
|
|
# # handled by the data update coordinator.
|
|
# # async with async_timeout.timeout(10):
|
|
# result = await hass.async_add_executor_job(semsApi.getData, stationId)
|
|
# _LOGGER.debug("Resulting result: %s", result)
|
|
|
|
# inverters = result["inverter"]
|
|
|
|
# # found = []
|
|
# # _LOGGER.debug("Found inverters: %s", inverters)
|
|
# data = {}
|
|
# if inverters is None:
|
|
# # something went wrong, probably token could not be fetched
|
|
# raise UpdateFailed(
|
|
# "Error communicating with API, probably token could not be fetched, see debug logs"
|
|
# )
|
|
# for inverter in inverters:
|
|
# name = inverter["invert_full"]["name"]
|
|
# # powerstation_id = inverter["invert_full"]["powerstation_id"]
|
|
# sn = inverter["invert_full"]["sn"]
|
|
# _LOGGER.debug("Found inverter attribute %s %s", name, sn)
|
|
# data[sn] = inverter["invert_full"]
|
|
|
|
# hasPowerflow = result["hasPowerflow"]
|
|
# hasEnergeStatisticsCharts = result["hasEnergeStatisticsCharts"]
|
|
|
|
# if hasPowerflow:
|
|
# if hasEnergeStatisticsCharts:
|
|
# StatisticsCharts = {
|
|
# f"Charts_{key}": val
|
|
# for key, val in result["energeStatisticsCharts"].items()
|
|
# }
|
|
# StatisticsTotals = {
|
|
# f"Totals_{key}": val
|
|
# for key, val in result["energeStatisticsTotals"].items()
|
|
# }
|
|
# powerflow = {
|
|
# **result["powerflow"],
|
|
# **StatisticsCharts,
|
|
# **StatisticsTotals,
|
|
# }
|
|
# else:
|
|
# powerflow = result["powerflow"]
|
|
|
|
# powerflow["sn"] = result["homKit"]["sn"]
|
|
|
|
# # Goodwe 'Power Meter' (not HomeKit) doesn't have a sn
|
|
# # Let's put something in, otherwise we can't see the data.
|
|
# if powerflow["sn"] is None:
|
|
# powerflow["sn"] = "GW-HOMEKIT-NO-SERIAL"
|
|
|
|
# #_LOGGER.debug("homeKit sn: %s", result["homKit"]["sn"])
|
|
# # This seems more accurate than the Chart_sum
|
|
# powerflow["all_time_generation"] = result["kpi"]["total_power"]
|
|
|
|
# data["homeKit"] = powerflow
|
|
|
|
# # _LOGGER.debug("Resulting data: %s", data)
|
|
# return data
|
|
# # except ApiError as err:
|
|
# except Exception as err:
|
|
# # logging.exception("Something awful happened!")
|
|
# raise UpdateFailed(f"Error communicating with API: {err}") from err
|
|
|
|
# coordinator = DataUpdateCoordinator(
|
|
# hass,
|
|
# _LOGGER,
|
|
# # Name of the data. For logging purposes.
|
|
# name="SEMS API",
|
|
# update_method=async_update_data,
|
|
# # Polling interval. Will only be polled if there are subscribers.
|
|
# update_interval=update_interval,
|
|
# )
|
|
coordinator = hass.data[DOMAIN][config_entry.entry_id]
|
|
|
|
#
|
|
# Fetch initial data so we have data when entities subscribe
|
|
#
|
|
# If the refresh fails, async_config_entry_first_refresh will
|
|
# raise ConfigEntryNotReady and setup will try again later
|
|
#
|
|
# If you do not want to retry setup on failure, use
|
|
# coordinator.async_refresh() instead
|
|
#
|
|
await coordinator.async_config_entry_first_refresh()
|
|
|
|
# _LOGGER.debug("Initial coordinator data: %s", coordinator.data)
|
|
|
|
for _idx, ent in enumerate(coordinator.data):
|
|
_migrate_to_new_unique_id(hass, ent)
|
|
|
|
async_add_entities(
|
|
SemsSensor(coordinator, ent)
|
|
for idx, ent in enumerate(coordinator.data)
|
|
# Don't make SemsSensor for homeKit, since it is not an inverter; unsure how this could work before...
|
|
if ent != "homeKit"
|
|
)
|
|
async_add_entities(
|
|
SemsStatisticsSensor(coordinator, ent)
|
|
for idx, ent in enumerate(coordinator.data)
|
|
# Don't make SemsStatisticsSensor for homeKit, since it is not an inverter; unsure how this could work before...
|
|
if ent != "homeKit"
|
|
)
|
|
async_add_entities(
|
|
SemsPowerflowSensor(coordinator, ent)
|
|
for idx, ent in enumerate(coordinator.data)
|
|
if ent == "homeKit"
|
|
)
|
|
async_add_entities(
|
|
SemsTotalImportSensor(coordinator, ent)
|
|
for idx, ent in enumerate(coordinator.data)
|
|
if ent == "homeKit"
|
|
)
|
|
async_add_entities(
|
|
SemsTotalExportSensor(coordinator, ent)
|
|
for idx, ent in enumerate(coordinator.data)
|
|
if ent == "homeKit"
|
|
)
|
|
|
|
|
|
# Migrate old power sensor unique ids to new unique ids (with `-power`)
|
|
def _migrate_to_new_unique_id(hass: HomeAssistant, sn: str) -> None:
|
|
"""Migrate old unique ids to new unique ids."""
|
|
ent_reg = entity_registry.async_get(hass)
|
|
|
|
old_unique_id = sn
|
|
new_unique_id = f"{old_unique_id}-power"
|
|
_LOGGER.debug("Old unique id: %s; new unique id: %s", old_unique_id, new_unique_id)
|
|
entity_id = ent_reg.async_get_entity_id(Platform.SENSOR, DOMAIN, old_unique_id)
|
|
_LOGGER.debug("Entity ID: %s", entity_id)
|
|
if entity_id is not None:
|
|
try:
|
|
ent_reg.async_update_entity(entity_id, new_unique_id=new_unique_id)
|
|
except ValueError:
|
|
_LOGGER.warning(
|
|
"Skip migration of id [%s] to [%s] because it already exists",
|
|
old_unique_id,
|
|
new_unique_id,
|
|
)
|
|
else:
|
|
_LOGGER.info(
|
|
"Migrating unique_id from [%s] to [%s]",
|
|
old_unique_id,
|
|
new_unique_id,
|
|
)
|
|
|
|
|
|
class SemsSensor(CoordinatorEntity, SensorEntity):
|
|
"""SemsSensor using CoordinatorEntity.
|
|
|
|
The CoordinatorEntity class provides:
|
|
should_poll
|
|
async_update
|
|
async_added_to_hass
|
|
available
|
|
"""
|
|
|
|
# Sensor has name determined by device class (e.g. Inverter 123456 Power)
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(self, coordinator, sn) -> None:
|
|
"""Pass coordinator to CoordinatorEntity."""
|
|
super().__init__(coordinator)
|
|
self.coordinator = coordinator
|
|
self.sn = sn
|
|
self._attr_unique_id = f"{self.coordinator.data[self.sn]['sn']}-power"
|
|
_LOGGER.debug("Creating SemsSensor with id %s", self.sn)
|
|
self._attr_unique_id = f"{self.coordinator.data[self.sn]['sn']}-power"
|
|
_LOGGER.debug(
|
|
"Creating SemsSensor with id %s and data %s",
|
|
self.sn,
|
|
self.coordinator.data[self.sn],
|
|
)
|
|
|
|
_attr_device_class = SensorDeviceClass.POWER
|
|
_attr_native_unit_of_measurement = UnitOfPower.WATT
|
|
_attr_should_poll = False
|
|
|
|
@property
|
|
def native_value(self):
|
|
"""Return the value reported by the sensor."""
|
|
data = self.coordinator.data[self.sn]
|
|
return data["pac"] if data["status"] == 1 else 0
|
|
|
|
def _statusText(self, status) -> str:
|
|
labels = {-1: "Offline", 0: "Waiting", 1: "Normal", 2: "Fault"}
|
|
return labels.get(status, "Unknown")
|
|
|
|
# For backwards compatibility
|
|
@property
|
|
def extra_state_attributes(self):
|
|
"""Return the state attributes of the monitored installation."""
|
|
data = self.coordinator.data[self.sn]
|
|
attributes = {k: v for k, v in data.items() if k is not None and v is not None}
|
|
attributes["statusText"] = self._statusText(data["status"])
|
|
return attributes
|
|
|
|
@property
|
|
def is_on(self) -> bool:
|
|
"""Return entity status."""
|
|
return self.coordinator.data[self.sn]["status"] == 1
|
|
|
|
@property
|
|
def available(self):
|
|
"""Return if entity is available."""
|
|
return self.coordinator.last_update_success
|
|
|
|
@property
|
|
def device_info(self) -> DeviceInfo:
|
|
"""Return device information."""
|
|
return DeviceInfo(
|
|
identifiers={(DOMAIN, self.sn)},
|
|
name=f"Inverter {self.coordinator.data[self.sn]['name']}",
|
|
manufacturer="GoodWe",
|
|
model=self.extra_state_attributes.get("model_type", "unknown"),
|
|
sw_version=self.extra_state_attributes.get("firmwareversion", "unknown"),
|
|
configuration_url=f"https://semsportal.com/PowerStation/PowerStatusSnMin/{self.coordinator.data[self.sn]['powerstation_id']}",
|
|
)
|
|
|
|
async def async_added_to_hass(self):
|
|
"""When entity is added to hass."""
|
|
self.async_on_remove(
|
|
self.coordinator.async_add_listener(self.async_write_ha_state)
|
|
)
|
|
|
|
async def async_update(self):
|
|
"""Update the entity.
|
|
|
|
Only used by the generic entity update service.
|
|
"""
|
|
await self.coordinator.async_request_refresh()
|
|
|
|
|
|
class SemsStatisticsSensor(CoordinatorEntity, SensorEntity):
|
|
"""Sensor in kWh to enable HA statistics, in the end usable in the power component."""
|
|
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(self, coordinator, sn) -> None:
|
|
"""Pass coordinator to CoordinatorEntity."""
|
|
super().__init__(coordinator)
|
|
self.coordinator = coordinator
|
|
self.sn = sn
|
|
_LOGGER.debug("Creating SemsStatisticsSensor with id %s", self.sn)
|
|
_LOGGER.debug(
|
|
"Creating SemsSensor with id %s and data %s",
|
|
self.sn,
|
|
self.coordinator.data[self.sn],
|
|
)
|
|
|
|
@property
|
|
def device_class(self):
|
|
return SensorDeviceClass.ENERGY
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
return UnitOfEnergy.KILO_WATT_HOUR
|
|
|
|
# @property
|
|
# def name(self) -> str:
|
|
# """Return the name of the sensor."""
|
|
# return f"Inverter {self.coordinator.data[self.sn]['name']} Energy"
|
|
|
|
@property
|
|
def unique_id(self) -> str:
|
|
return f"{self.coordinator.data[self.sn]['sn']}-energy"
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the device."""
|
|
_LOGGER.debug(
|
|
"SemsStatisticsSensor state, coordinator data: %s", self.coordinator.data
|
|
)
|
|
_LOGGER.debug("SemsStatisticsSensor self.sn: %s", self.sn)
|
|
_LOGGER.debug(
|
|
"SemsStatisticsSensor state, self data: %s", self.coordinator.data[self.sn]
|
|
)
|
|
data = self.coordinator.data[self.sn]
|
|
return data["etotal"]
|
|
|
|
@property
|
|
def should_poll(self) -> bool:
|
|
"""No need to poll. Coordinator notifies entity of updates."""
|
|
return False
|
|
|
|
@property
|
|
def device_info(self):
|
|
# _LOGGER.debug("self.device_state_attributes: %s", self.device_state_attributes)
|
|
data = self.coordinator.data[self.sn]
|
|
return {
|
|
"identifiers": {
|
|
# Serial numbers are unique identifiers within a specific domain
|
|
(DOMAIN, self.sn)
|
|
},
|
|
# "name": self.name,
|
|
"manufacturer": "GoodWe",
|
|
"model": data.get("model_type", "unknown"),
|
|
"sw_version": data.get("firmwareversion", "unknown"),
|
|
# "via_device": (DOMAIN, self.api.bridgeid),
|
|
}
|
|
|
|
@property
|
|
def state_class(self):
|
|
"""used by Metered entities / Long Term Statistics"""
|
|
return SensorStateClass.TOTAL_INCREASING
|
|
|
|
async def async_added_to_hass(self):
|
|
"""When entity is added to hass."""
|
|
self.async_on_remove(
|
|
self.coordinator.async_add_listener(self.async_write_ha_state)
|
|
)
|
|
|
|
async def async_update(self):
|
|
"""Update the entity.
|
|
|
|
Only used by the generic entity update service.
|
|
"""
|
|
await self.coordinator.async_request_refresh()
|
|
|
|
|
|
class SemsTotalImportSensor(CoordinatorEntity, SensorEntity):
|
|
"""Sensor in kWh to enable HA statistics, in the end usable in the power component."""
|
|
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(self, coordinator, sn):
|
|
"""Pass coordinator to CoordinatorEntity."""
|
|
super().__init__(coordinator)
|
|
self.coordinator = coordinator
|
|
self.sn = sn
|
|
_LOGGER.debug("Creating SemsStatisticsSensor with id %s", self.sn)
|
|
|
|
@property
|
|
def device_class(self):
|
|
return SensorDeviceClass.ENERGY
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
return UnitOfEnergy.KILO_WATT_HOUR
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Return the name of the sensor."""
|
|
return "HomeKit Import"
|
|
|
|
@property
|
|
def unique_id(self) -> str:
|
|
return f"{self.coordinator.data[self.sn]['sn']}-import-energy"
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the device."""
|
|
data = self.coordinator.data[self.sn]
|
|
return data["Charts_buy"]
|
|
|
|
def statusText(self, status) -> str:
|
|
labels = {-1: "Offline", 0: "Waiting", 1: "Normal", 2: "Fault"}
|
|
return labels[status] if status in labels else "Unknown"
|
|
|
|
@property
|
|
def should_poll(self) -> bool:
|
|
"""No need to poll. Coordinator notifies entity of updates."""
|
|
return False
|
|
|
|
@property
|
|
def device_info(self):
|
|
return {
|
|
"identifiers": {
|
|
# Serial numbers are unique identifiers within a specific domain
|
|
(DOMAIN, self.sn)
|
|
},
|
|
"name": "Homekit",
|
|
"manufacturer": "GoodWe",
|
|
}
|
|
|
|
@property
|
|
def state_class(self):
|
|
"""used by Metered entities / Long Term Statistics"""
|
|
return SensorStateClass.TOTAL_INCREASING
|
|
|
|
async def async_added_to_hass(self):
|
|
"""When entity is added to hass."""
|
|
self.async_on_remove(
|
|
self.coordinator.async_add_listener(self.async_write_ha_state)
|
|
)
|
|
|
|
async def async_update(self):
|
|
"""Update the entity.
|
|
|
|
Only used by the generic entity update service.
|
|
"""
|
|
await self.coordinator.async_request_refresh()
|
|
|
|
|
|
class SemsTotalExportSensor(CoordinatorEntity, SensorEntity):
|
|
"""Sensor in kWh to enable HA statistics, in the end usable in the power component."""
|
|
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(self, coordinator, sn):
|
|
"""Pass coordinator to CoordinatorEntity."""
|
|
super().__init__(coordinator)
|
|
self.coordinator = coordinator
|
|
self.sn = sn
|
|
_LOGGER.debug("Creating SemsStatisticsSensor with id %s", self.sn)
|
|
|
|
@property
|
|
def device_class(self):
|
|
return SensorDeviceClass.ENERGY
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
return UnitOfEnergy.KILO_WATT_HOUR
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Return the name of the sensor."""
|
|
return "HomeKit Export"
|
|
|
|
@property
|
|
def unique_id(self) -> str:
|
|
return f"{self.coordinator.data[self.sn]['sn']}-export-energy"
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the device."""
|
|
data = self.coordinator.data[self.sn]
|
|
return data["Charts_sell"]
|
|
|
|
def statusText(self, status) -> str:
|
|
labels = {-1: "Offline", 0: "Waiting", 1: "Normal", 2: "Fault"}
|
|
return labels[status] if status in labels else "Unknown"
|
|
|
|
@property
|
|
def should_poll(self) -> bool:
|
|
"""No need to poll. Coordinator notifies entity of updates."""
|
|
return False
|
|
|
|
@property
|
|
def device_info(self):
|
|
return {
|
|
"identifiers": {
|
|
# Serial numbers are unique identifiers within a specific domain
|
|
(DOMAIN, self.sn)
|
|
},
|
|
"name": "Homekit",
|
|
"manufacturer": "GoodWe",
|
|
}
|
|
|
|
@property
|
|
def state_class(self):
|
|
"""used by Metered entities / Long Term Statistics"""
|
|
return SensorStateClass.TOTAL_INCREASING
|
|
|
|
async def async_added_to_hass(self):
|
|
"""When entity is added to hass."""
|
|
self.async_on_remove(
|
|
self.coordinator.async_add_listener(self.async_write_ha_state)
|
|
)
|
|
|
|
async def async_update(self):
|
|
"""Update the entity.
|
|
|
|
Only used by the generic entity update service.
|
|
"""
|
|
await self.coordinator.async_request_refresh()
|
|
|
|
|
|
class SemsPowerflowSensor(CoordinatorEntity, SensorEntity):
|
|
"""SemsPowerflowSensor using CoordinatorEntity.
|
|
|
|
The CoordinatorEntity class provides:
|
|
should_poll
|
|
async_update
|
|
async_added_to_hass
|
|
available
|
|
"""
|
|
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(self, coordinator, sn):
|
|
"""Pass coordinator to CoordinatorEntity."""
|
|
super().__init__(coordinator)
|
|
self.coordinator = coordinator
|
|
self.sn = sn
|
|
|
|
@property
|
|
def device_class(self):
|
|
return SensorDeviceClass.POWER_FACTOR
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
return UnitOfPower.WATT
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Return the name of the sensor."""
|
|
return f"HomeKit {self.coordinator.data[self.sn]['sn']}"
|
|
|
|
@property
|
|
def unique_id(self) -> str:
|
|
return f"{self.coordinator.data[self.sn]['sn']}-homekit"
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the device."""
|
|
data = self.coordinator.data[self.sn]
|
|
load = data["load"]
|
|
|
|
if load:
|
|
load = load.replace("(W)", "")
|
|
|
|
return load if data["gridStatus"] == 1 else 0
|
|
|
|
def statusText(self, status) -> str:
|
|
labels = {-1: "Offline", 0: "Waiting", 1: "Normal", 2: "Fault"}
|
|
return labels[status] if status in labels else "Unknown"
|
|
|
|
# For backwards compatibility
|
|
@property
|
|
def extra_state_attributes(self):
|
|
"""Return the state attributes of the monitored installation."""
|
|
data = self.coordinator.data[self.sn]
|
|
|
|
attributes = {k: v for k, v in data.items() if k is not None and v is not None}
|
|
|
|
attributes["pv"] = data["pv"].replace("(W)", "")
|
|
attributes["bettery"] = data["bettery"].replace("(W)", "")
|
|
attributes["load"] = data["load"].replace("(W)", "")
|
|
attributes["grid"] = data["grid"].replace("(W)", "")
|
|
|
|
attributes["statusText"] = self.statusText(data["gridStatus"])
|
|
|
|
if data["loadStatus"] == -1:
|
|
attributes["PowerFlowDirection"] = "Export %s" % data["grid"]
|
|
if data["loadStatus"] == 1:
|
|
attributes["PowerFlowDirection"] = "Import %s" % data["grid"]
|
|
|
|
return attributes
|
|
|
|
@property
|
|
def is_on(self) -> bool:
|
|
"""Return entity status."""
|
|
self.coordinator.data[self.sn]["gridStatus"] == 1
|
|
|
|
@property
|
|
def should_poll(self) -> bool:
|
|
"""No need to poll. Coordinator notifies entity of updates."""
|
|
return False
|
|
|
|
@property
|
|
def available(self):
|
|
"""Return if entity is available."""
|
|
return self.coordinator.last_update_success
|
|
|
|
@property
|
|
def device_info(self):
|
|
return {
|
|
"identifiers": {
|
|
# Serial numbers are unique identifiers within a specific domain
|
|
(DOMAIN, self.sn)
|
|
},
|
|
"name": "Homekit",
|
|
"manufacturer": "GoodWe",
|
|
}
|
|
|
|
async def async_added_to_hass(self):
|
|
"""When entity is added to hass."""
|
|
self.async_on_remove(
|
|
self.coordinator.async_add_listener(self.async_write_ha_state)
|
|
)
|
|
|
|
async def async_update(self):
|
|
"""Update the entity.
|
|
|
|
Only used by the generic entity update service.
|
|
"""
|
|
await self.coordinator.async_request_refresh()
|