Merge branch 'speleolontra:master' into master

Author: VarChar42

custom_components/daikin_residential_altherma/climate.py

@@ -84,7 +84,7 @@ class DaikinClimate(ClimateEntity):
 
     def __init__(self, device):
         """Initialize the climate device."""
-        print("DAMIANO Initializing CLIMATE...")
+        _LOGGER.info("DAMIANO Initializing CLIMATE...")
         self._device = device
         self._list = {
             ATTR_HVAC_MODE: list(HA_HVAC_TO_DAIKIN),
@@ -106,7 +106,7 @@ def __init__(self, device):
             if support_preset:
                 self._supported_preset_modes.append(mode)
                 self._supported_features |= SUPPORT_PRESET_MODE
-            print("DAMIANO support_preset_mode {}: {}".format(mode,support_preset))
+            _LOGGER.info("DAMIANO support_preset_mode {}: {}".format(mode,support_preset))
 
     async def _set(self, settings):
         """Set device settings using API."""

custom_components/daikin_residential_altherma/const.py

@@ -9,8 +9,11 @@
     CONF_UNIT_OF_MEASUREMENT,
     DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
     ENERGY_KILO_WATT_HOUR,
     TEMP_CELSIUS,
+    PERCENTAGE,
+    SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
 )
 
 DOMAIN = "daikin_residential_altherma"
@@ -24,7 +27,7 @@
 
 # MANAGEMENT POINTS
 MP_CLIMATE = "climateControlMainZone"
-MP_GATEWAY = "gateway" # NEW
+MP_GATEWAY = "gateway"
 MP_DOMESTIC_HWT = "domesticHotWaterTank"
 MP_INDOOR_UNIT = "indoorUnitHydro"
 MP_OUDOOR_UNIT = "outdoorUnit"
@@ -38,6 +41,11 @@
 DP_TEMPERATURE = "temperatureControl"
 DP_CONSUMPTION = "consumptionData"
 DP_CONTROL_MODE = "controlMode"
+DP_WIFI_STRENGTH = "wifiConnectionStrength"
+DP_WIFI_SSID = "wifiConnectionSSID"
+DP_LOCAL_SSID = "ssid"
+DP_MAC_ADDRESS = "macAddress"
+DP_SERIAL_NUMBER = "serialNumber"
 
 # DAMIANO HEAT PUMP ALTHERMA
 
@@ -77,9 +85,11 @@
 ATTR_TANK_IS_POWERFUL_MODE_ACTIVE = "isPowerfulModeActive"
 ATTR_TANK_ERROR_CODE = "@TankErrorCode"
 
-
-
-
+ATTR_WIFI_STRENGTH = "wifi_strength"
+ATTR_WIFI_SSID = "wifi_ssid"
+ATTR_LOCAL_SSID = "local_ssid"
+ATTR_MAC_ADDRESS = "mac_address"
+ATTR_SERIAL_NUMBER = "serial_number"
 
 DAIKIN_CMD_SETS = {
     #ATTR_ON_OFF: [MP_CLIMATE, DP_ON_OFF, "onOffMode"],
@@ -118,6 +128,12 @@
     ATTR_TANK_IS_IN_WARNING_STATE: [MP_DOMESTIC_HWT, "@TankisInWarningState", ""],
     ATTR_TANK_IS_POWERFUL_MODE_ACTIVE: [MP_DOMESTIC_HWT, "isPowerfulModeActive", ""],
     ATTR_TANK_ERROR_CODE: [MP_DOMESTIC_HWT, "errorCode", ""],
+    #  Gateway settings
+    ATTR_WIFI_STRENGTH: [MP_GATEWAY, DP_WIFI_STRENGTH, ""],
+    ATTR_WIFI_SSID: [MP_GATEWAY, DP_WIFI_SSID, ""],
+    ATTR_LOCAL_SSID: [MP_GATEWAY, DP_LOCAL_SSID, ""],
+    ATTR_MAC_ADDRESS: [MP_GATEWAY, DP_MAC_ADDRESS, ""],
+    ATTR_SERIAL_NUMBER: [MP_GATEWAY, DP_SERIAL_NUMBER, ""],
 }
 
 ATTR_STATE_ON = "on"
@@ -134,6 +150,7 @@
 SENSOR_TYPE_POWER = "power"
 SENSOR_TYPE_ENERGY = "energy"
 SENSOR_TYPE_INFO = None
+SENSOR_TYPE_GATEWAY_DIAGNOSTIC = "gateway_diagnostic"
 SENSOR_PERIOD_DAILY = "d"
 SENSOR_PERIOD_WEEKLY = "w"
 SENSOR_PERIOD_YEARLY = "m"
@@ -316,6 +333,38 @@
         #CONF_DEVICE_CLASS: DEVICE_CLASS_ENERGY,
         CONF_UNIT_OF_MEASUREMENT: " ",
     },
+    ATTR_WIFI_STRENGTH: {
+        CONF_NAME: "WiFi Strength",
+        CONF_TYPE: SENSOR_TYPE_GATEWAY_DIAGNOSTIC,
+        CONF_DEVICE_CLASS: DEVICE_CLASS_SIGNAL_STRENGTH,
+        CONF_UNIT_OF_MEASUREMENT: SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+    },
+    ATTR_WIFI_SSID: {
+        CONF_NAME: "WiFi SSID",
+        CONF_TYPE: SENSOR_TYPE_GATEWAY_DIAGNOSTIC,
+        CONF_ICON: "mdi:access-point-network",
+        CONF_DEVICE_CLASS: None,
+        CONF_UNIT_OF_MEASUREMENT: None,
+    },
+    ATTR_LOCAL_SSID: {
+        CONF_NAME: "Internal SSID",
+        CONF_TYPE: SENSOR_TYPE_GATEWAY_DIAGNOSTIC,
+        CONF_DEVICE_CLASS: None,
+        CONF_UNIT_OF_MEASUREMENT: None,
+    },
+    ATTR_MAC_ADDRESS: {
+        CONF_NAME: "Mac Address",
+        CONF_TYPE: SENSOR_TYPE_GATEWAY_DIAGNOSTIC,
+        CONF_DEVICE_CLASS: None,
+        CONF_UNIT_OF_MEASUREMENT: None,
+    },
+    ATTR_SERIAL_NUMBER: {
+        CONF_NAME: "Serial Number",
+        CONF_TYPE: SENSOR_TYPE_GATEWAY_DIAGNOSTIC,
+        CONF_ICON: "mdi:numeric",
+        CONF_DEVICE_CLASS: None,
+        CONF_UNIT_OF_MEASUREMENT: None,
+    },
 }
 
 CONF_UUID = "uuid"

custom_components/daikin_residential_altherma/daikin_base.py

@@ -42,6 +42,11 @@
     ATTR_TANK_IS_IN_WARNING_STATE,
     ATTR_TANK_IS_POWERFUL_MODE_ACTIVE,
     ATTR_TANK_ERROR_CODE,
+    ATTR_WIFI_STRENGTH,
+    ATTR_WIFI_SSID,
+    ATTR_LOCAL_SSID,
+    ATTR_MAC_ADDRESS,
+    ATTR_SERIAL_NUMBER,
 )
 
 from homeassistant.components.climate.const import (
@@ -478,6 +483,56 @@ def error_code(self):
         """Return current error code."""
         return self.getValue(ATTR_ERROR_CODE)
 
+    @property
+    def support_wifi_strength(self):
+        """Return True if the device supports wifi connection strength."""
+        return self.getData(ATTR_WIFI_STRENGTH) is not None
+
+    @property
+    def wifi_strength(self):
+        """Return current wifi connection strength."""
+        return self.getValue(ATTR_WIFI_STRENGTH) if self.support_wifi_strength else None
+
+    @property
+    def support_wifi_ssid(self):
+        """Return True if the device supports wifi connection ssid."""
+        return self.getData(ATTR_WIFI_SSID) is not None
+
+    @property
+    def wifi_ssid(self):
+        """Return current wifi connection ssid."""
+        return self.getValue(ATTR_WIFI_SSID) if self.support_wifi_ssid else None
+
+    @property
+    def support_local_ssid(self):
+        """Return True if the device supports internal ssid."""
+        return self.getData(ATTR_LOCAL_SSID) is not None
+
+    @property
+    def local_ssid(self):
+        """Return current internal ssid."""
+        return self.getValue(ATTR_LOCAL_SSID) if self.support_local_ssid else None
+
+    @property
+    def support_mac_address(self):
+        """Return True if the device reports its mac address."""
+        return self.getData(ATTR_MAC_ADDRESS) is not None
+
+    @property
+    def mac_address(self):
+        """Return device mac address."""
+        return self.getValue(ATTR_MAC_ADDRESS) if self.support_mac_address else None
+
+    @property
+    def support_serial_number(self):
+        """Return True if the device reports its serial number."""
+        return self.getData(ATTR_SERIAL_NUMBER) is not None
+
+    @property
+    def serial_number(self):
+        """Return device serial number."""
+        return self.getValue(ATTR_SERIAL_NUMBER) if self.support_serial_number else None
+
     @property   # ATTR_TANK_HEATUP_MODE
     def support_heatupMode(self):
         """Return True if the device supports heatupMode."""

custom_components/daikin_residential_altherma/device.py

@@ -166,7 +166,7 @@ def getDescription(self):
 
     def getLastUpdated(self):
         """Get the timestamp when data were last updated."""
-        print("DAMIANO {}: LAST UPDATE DEVICE".format(self))
+        _LOGGER.info("DAMIANO {}: LAST UPDATE DEVICE".format(self))
         return self.desc["lastUpdateReceived"]
         # return new Date(self.desc.lastUpdateReceived)
 
@@ -231,7 +231,7 @@ def get_data(self, managementPoint=None, dataPoint=None, dataPointPath=""):
 
     def get_value(self, managementPoint=None, dataPoint=None, dataPointPath=""):
         """Get the current value of a data object."""
-        print("  DAMIANO Get the current value of: {}-{}-{}".format(managementPoint,dataPoint,dataPointPath))
+        _LOGGER.info("  DAMIANO Get the current value of: {}-{}-{}".format(managementPoint,dataPoint,dataPointPath))
         data = self.get_data(managementPoint, dataPoint, dataPointPath)
         if data is None:
             return None
@@ -250,25 +250,25 @@ async def updateData(self):
         return
         # TODO: Enhance self method to also allow to get some partial data
         # like only one managementPoint or such; needs checking how to request
-        print("DEV UPDATE " + self.name)
+        _LOGGER.info("DEV UPDATE " + self.name)
         desc = await self.api.doBearerRequest("/v1/gateway-devices/" + self.getId())
         self.setJsonData(desc)
-        print("DEVICE: " + self.name)
-        print(
+        _LOGGER.info("DEVICE: " + self.name)
+        _LOGGER.info(
             "    temp: inner "
             + str(self.get_value("climateControl", "sensoryData", "/roomTemperature"))
             + " outer "
             + str(
                 self.get_value("climateControl", "sensoryData", "/outdoorTemperature")
             )
         )
-        print(
+        _LOGGER.info(
             "    current mode: "
             + str(self.get_value("climateControl", "operationMode"))
             + "  "
             + str(self.get_value("climateControl", "onOffMode"))
         )
-        print(
+        _LOGGER.info(
             "    target temp: "
             + str(
                 self.get_value(
@@ -278,7 +278,7 @@ async def updateData(self):
                 )
             )
         )
-        print(
+        _LOGGER.info(
             "    FAN: mode [{}] speed [{}]\n".format(
                 self.get_value(
                     "climateControl",

custom_components/daikin_residential_altherma/sensor.py

@@ -15,6 +15,8 @@
     STATE_CLASS_TOTAL_INCREASING,
 )
 
+from homeassistant.helpers.entity import EntityCategory
+
 from .daikin_base import Appliance
 
 from .const import (
@@ -50,8 +52,14 @@
     SENSOR_TYPE_POWER,
     SENSOR_TYPE_TEMPERATURE,
     SENSOR_TYPE_INFO,
+    SENSOR_TYPE_GATEWAY_DIAGNOSTIC,
     SENSOR_PERIODS,
     SENSOR_TYPES,
+    ATTR_WIFI_STRENGTH,
+    ATTR_WIFI_SSID,
+    ATTR_LOCAL_SSID,
+    ATTR_MAC_ADDRESS,
+    ATTR_SERIAL_NUMBER,
 )
 
 import logging
@@ -184,6 +192,26 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
         else:
             _LOGGER.info("DAIKIN RESIDENTIAL ALTHERMA: device NOT supports error code")
 
+        if device.support_wifi_strength:
+            _LOGGER.debug("DAIKIN RESIDENTIAL ALTHERMA: supports wifi signal strength")
+            sensor = DaikinSensor.factory(device, ATTR_WIFI_STRENGTH, "")
+            sensors.append(sensor)
+        if device.support_wifi_ssid:
+            _LOGGER.debug("DAIKIN RESIDENTIAL ALTHERMA: supports wifi ssid")
+            sensor = DaikinSensor.factory(device, ATTR_WIFI_SSID, "")
+            sensors.append(sensor)
+        if device.support_local_ssid:
+            _LOGGER.debug("DAIKIN RESIDENTIAL ALTHERMA: supports local ssid")
+            sensor = DaikinSensor.factory(device, ATTR_LOCAL_SSID, "")
+            sensors.append(sensor)
+        if device.support_mac_address:
+            _LOGGER.debug("DAIKIN RESIDENTIAL ALTHERMA: supports mac address")
+            sensor = DaikinSensor.factory(device, ATTR_MAC_ADDRESS, "")
+            sensors.append(sensor)
+        if device.support_serial_number:
+            _LOGGER.debug("DAIKIN RESIDENTIAL ALTHERMA: supports serial number")
+            sensor = DaikinSensor.factory(device, ATTR_SERIAL_NUMBER, "")
+            sensors.append(sensor)
 
         #heatup
         if device.support_heatupMode:
@@ -261,10 +289,11 @@ def factory(device: Appliance, monitored_state: str, type, period=""):
                 SENSOR_TYPE_POWER: DaikinEnergySensor,
                 SENSOR_TYPE_ENERGY: DaikinEnergySensor,
                 SENSOR_TYPE_INFO: DaikinInfoSensor,
+                SENSOR_TYPE_GATEWAY_DIAGNOSTIC: DaikinGatewaySensor,
             }[SENSOR_TYPES[monitored_state][CONF_TYPE]]
             return cls(device, monitored_state,type, period)
         except Exception as error:
-            print("error: " + error)
+            # print("error: " + error)
             _LOGGER.error("%s", format(error))
             return
 
@@ -285,7 +314,7 @@ def __init__(self, device: Appliance, monitored_state: str, type,  period="") ->
                 #self._name = f"{device.name} TANK {self._sensor[CONF_NAME]}"
                 self._name = f"{device.name} {self._sensor[CONF_NAME]}"
         self._device_attribute = monitored_state
-        print("  DAMIANO Initialized sensor: {}".format(self._name))
+        _LOGGER.info("  DAMIANO Initialized sensor: {}".format(self._name))
 
     @property
     def available(self):
@@ -365,6 +394,11 @@ def entity_category(self):
             ATTR_TANK_IS_IN_INSTALLER_STATE,
             ATTR_TANK_IS_IN_WARNING_STATE,
             ATTR_TANK_ERROR_CODE,
+            ATTR_WIFI_STRENGTH,
+            ATTR_WIFI_SSID,
+            ATTR_LOCAL_SSID,
+            ATTR_MAC_ADDRESS,
+            ATTR_SERIAL_NUMBER,
             ]
         try:
             if self._device_attribute in configList:
@@ -494,3 +528,37 @@ def state(self):
     @property
     def state_class(self):
         return STATE_CLASS_TOTAL_INCREASING
+
+class DaikinGatewaySensor(DaikinSensor):
+    """Representation of a WiFi Sensor."""
+
+    # set default category for these entities
+    _attr_entity_category = EntityCategory.DIAGNOSTIC
+
+    @property
+    def state(self):
+        """Return the internal state of the sensor."""
+        if self._device_attribute == ATTR_WIFI_STRENGTH:
+            return self._device.wifi_strength
+        if self._device_attribute == ATTR_WIFI_SSID:
+            return self._device.wifi_ssid
+        if self._device_attribute == ATTR_LOCAL_SSID:
+            return self._device.local_ssid
+        if self._device_attribute == ATTR_MAC_ADDRESS:
+            return self._device.mac_address
+        if self._device_attribute == ATTR_SERIAL_NUMBER:
+            return self._device.serial_number
+        return None
+
+    @property
+    def state_class(self):
+        if self._device_attribute == ATTR_WIFI_STRENGTH:
+            return STATE_CLASS_MEASUREMENT
+        else:
+            return None
+
+    @property
+    def entity_registry_enabled_default(self):
+        # auto disable these entities when added for the first time
+        # except the wifi signal
+        return self._device_attribute == ATTR_WIFI_STRENGTH