First Committ in Beta version

Author: speleolontra

.gitignore

@@ -0,0 +1,100 @@
+
+ * * * * * * INSERIMENTO DI UN NUOVO SENSORE  * * * * * * 
+
+
+ 
+
+
+1) const.py: Aggiungere una costante ATTR battezzandone il nuovo nome, es:
+
+
+	ATTR_TANK_TEMPERATURE = "tankTemperature"
+
+
+2) const.py: Aggiungere il CMD_SET con il percorso MP,DP e Value:
+
+
+	DAIKIN_CMD_SETS = {
+		...
+		ATTR_TANK_TEMPERATURE: [MP_DOMESTIC_HWT, DP_SENSORS, "/tankTemperature"],
+
+
+dove "/tankTemperature" deve corrispondere al JSON:
+
+
+                "sensoryData": {
+                    "ref": "#sensoryData",
+                    "settable": false,
+                    "value": {
+                        "tankTemperature": {
+                            "maxValue": 127,
+                            "minValue": -127,
+                            "requiresReboot": false,
+                            "settable": false,
+                            "stepValue": 1,
+                            "value": 38
+
+
+3) const.py: nei SENSOR_TYPES aggiungere la definizione del nuovo sensore:
+
+
+	SENSOR_TYPES = {
+		...
+		ATTR_TANK_TEMPERATURE: {
+			CONF_NAME: "Tank Temperature",
+			CONF_TYPE: SENSOR_TYPE_TEMPERATURE,
+			CONF_DEVICE_CLASS: DEVICE_CLASS_TEMPERATURE,
+			CONF_UNIT_OF_MEASUREMENT: TEMP_CELSIUS,
+		},
+
+
+4) daikin_base.py: aggiungere l'attributo all'import:
+
+
+		from .const import(
+			...,
+			ATTR_TANK_TEMPERATURE,
+
+
+5) daikin_base.py: definire le nuove property "support_xxx" e "xxx":
+
+
+    @property
+    def support_tank_temperature(self):
+        """Return True if the device supports outsite temperature measurement."""
+        return self.getData(ATTR_TANK_TEMPERATURE) is not None
+
+    @property
+    def tank_temperature(self):
+        """Return current outside temperature."""
+        return float(self.getValue(ATTR_TANK_TEMPERATURE))
+
+
+6) sensor.py: aggiungere l'attributo all'import:
+
+
+	from .const import (
+		...,
+		ATTR_TANK_TEMPERATURE,
+
+
+7) sensor.py: Append Se il sensore è supportato
+
+
+        if device.support_tank_temperature:
+            sensor = DaikinSensor.factory(device, ATTR_TANK_TEMPERATURE)
+            _LOGGER.debug("DAMIANO append sensor = %s", sensor)
+            sensors.append(sensor)
+
+
+8) sensor.py: Aggiungere la proprietà di stato
+
+
+		@property
+		def state(self):
+			"""Return the internal state of the sensor."""
+			...			
+			if self._device_attribute == ATTR_TANK_TEMPERATURE:
+				return self._device.tank_temperature
+			return None
+

custom_components/daikin_residential_altherma/NOTELONTRA.txt

@@ -0,0 +1,116 @@
+"""Platform for the Daikin AC."""
+import asyncio
+import datetime
+import logging
+import voluptuous as vol
+
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, SERVICE_RELOAD
+from homeassistant.helpers.typing import HomeAssistantType
+
+from .const import DOMAIN, DAIKIN_API, DAIKIN_DEVICES, CONF_TOKENSET
+
+from .daikin_api import DaikinApi
+
+_LOGGER = logging.getLogger(__name__)
+
+ENTRY_IS_SETUP = "daikin_entry_is_setup"
+_LOGGER.debug("DAMIANO daikin_entry_is_setup")
+
+PARALLEL_UPDATES = 0
+
+SERVICE_FORCE_UPDATE = "force_update"
+SERVICE_PULL_DEVICES = "pull_devices"
+
+SIGNAL_DELETE_ENTITY = "daikin_delete"
+SIGNAL_UPDATE_ENTITY = "daikin_update"
+
+TOKENSET_FILE = "altherma_tokenset.json"
+
+MIN_TIME_BETWEEN_UPDATES = datetime.timedelta(seconds=2)
+
+COMPONENT_TYPES = ["climate", "sensor", "switch"]
+
+
+CONFIG_SCHEMA = vol.Schema(
+    vol.All(
+        {
+            DOMAIN: vol.Schema(
+                {vol.Required(CONF_EMAIL): str, vol.Required(CONF_PASSWORD): str}
+            )
+        }
+    ),
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+async def async_setup(hass, config):
+    """Setup the Daikin Residential component."""
+
+    async def _handle_reload(service):
+        """Handle reload service call."""
+        _LOGGER.info("Reloading integration: retrieving new TokenSet.")
+        try:
+            daikin_api = hass.data[DOMAIN][DAIKIN_API]
+            data = daikin_api._config_entry.data.copy()
+            await daikin_api.retrieveAccessToken(data[CONF_EMAIL], data[CONF_PASSWORD])
+            data[CONF_TOKENSET] = daikin_api.tokenSet
+            hass.config_entries.async_update_entry(
+                entry=daikin_api._config_entry, data=data
+            )
+        except Exception as e:
+            _LOGGER.error("Failed to reload integration: %s", e)
+
+    hass.helpers.service.async_register_admin_service(
+        DOMAIN, SERVICE_RELOAD, _handle_reload
+    )
+
+    if DOMAIN not in config:
+        return True
+
+    conf = config.get(DOMAIN)
+    if conf is not None:
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN, context={"source": SOURCE_IMPORT}, data=conf
+            )
+        )
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry):
+    """Establish connection with Daikin."""
+
+    daikin_api = DaikinApi(hass, entry)
+    await daikin_api.getCloudDeviceDetails()
+
+    devices = await daikin_api.getCloudDevices()
+    hass.data[DOMAIN] = {DAIKIN_API: daikin_api, DAIKIN_DEVICES: devices}
+
+    for component in COMPONENT_TYPES:
+        #print("DAMIANO component %S", component)
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(entry, component)
+        )
+    return True
+
+
+async def async_unload_entry(hass, config_entry):
+    """Unload a config entry."""
+    _LOGGER.debug("Unloading integration...")
+    await asyncio.wait(
+        [
+            hass.config_entries.async_forward_entry_unload(config_entry, component)
+            for component in COMPONENT_TYPES
+        ]
+    )
+    hass.data[DOMAIN].clear()
+    if not hass.data[DOMAIN]:
+        hass.data.pop(DOMAIN)
+    return True
+
+
+async def daikin_api_setup(hass, host, key, uuid, password):
+    """Create a Daikin instance only once."""
+    return