Add Advantage Air Integration (#40159)

Co-authored-by: Robert Svensson <Kane610@users.noreply.github.com>
Co-authored-by: Martin Hjelmare <marhje52@gmail.com>
This commit is contained in:
authored and GitHub committed 2020-10-12 13:22:15 +02:00
1 parent cd21786536
commit 3e41c682f4
17 files changed
+930

No files matched your search

@@ -0,0 +1,74 @@
"""Advantage Air climate integration."""
from datetime import timedelta
import logging
from advantage_air import ApiError, advantage_air
from homeassistant.const import CONF_IP_ADDRESS, CONF_PORT
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import ADVANTAGE_AIR_RETRY, DOMAIN
ADVANTAGE_AIR_SYNC_INTERVAL = 15
ADVANTAGE_AIR_PLATFORMS = ["climate"]
_LOGGER = logging.getLogger(__name__)
async def async_setup(hass, config):
"""Set up AdvantageAir."""
hass.data[DOMAIN] = {}
return True
async def async_setup_entry(hass, config_entry):
"""Set up AdvantageAir Config."""
ip_address = config_entry.data[CONF_IP_ADDRESS]
port = config_entry.data[CONF_PORT]
api = advantage_air(
ip_address,
port=port,
session=async_get_clientsession(hass),
retry=ADVANTAGE_AIR_RETRY,
)
async def async_get():
try:
return await api.async_get()
except ApiError as err:
raise UpdateFailed(err) from err
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="Advantage Air",
update_method=async_get,
update_interval=timedelta(seconds=ADVANTAGE_AIR_SYNC_INTERVAL),
)
async def async_change(change):
try:
if await api.async_change(change):
await coordinator.async_refresh()
except ApiError as err:
_LOGGER.warning(err)
await coordinator.async_refresh()
if not coordinator.data:
raise ConfigEntryNotReady
hass.data[DOMAIN][config_entry.entry_id] = {
"coordinator": coordinator,
"async_change": async_change,
}
for platform in ADVANTAGE_AIR_PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(config_entry, platform)
)
return True
@@ -0,0 +1,297 @@
"""Climate platform for Advantage Air integration."""
import logging
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
FAN_AUTO,
FAN_HIGH,
FAN_LOW,
FAN_MEDIUM,
FAN_OFF,
HVAC_MODE_COOL,
HVAC_MODE_DRY,
HVAC_MODE_FAN_ONLY,
HVAC_MODE_HEAT,
HVAC_MODE_OFF,
SUPPORT_FAN_MODE,
SUPPORT_TARGET_TEMPERATURE,
)
from homeassistant.const import ATTR_TEMPERATURE, PRECISION_WHOLE, TEMP_CELSIUS
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import (
ADVANTAGE_AIR_STATE_CLOSE,
ADVANTAGE_AIR_STATE_OFF,
ADVANTAGE_AIR_STATE_ON,
ADVANTAGE_AIR_STATE_OPEN,
DOMAIN,
)
ADVANTAGE_AIR_HVAC_MODES = {
"heat": HVAC_MODE_HEAT,
"cool": HVAC_MODE_COOL,
"vent": HVAC_MODE_FAN_ONLY,
"dry": HVAC_MODE_DRY,
}
HASS_HVAC_MODES = {v: k for k, v in ADVANTAGE_AIR_HVAC_MODES.items()}
ADVANTAGE_AIR_FAN_MODES = {
"auto": FAN_AUTO,
"low": FAN_LOW,
"medium": FAN_MEDIUM,
"high": FAN_HIGH,
}
HASS_FAN_MODES = {v: k for k, v in ADVANTAGE_AIR_FAN_MODES.items()}
FAN_SPEEDS = {FAN_LOW: 30, FAN_MEDIUM: 60, FAN_HIGH: 100}
AC_HVAC_MODES = [
HVAC_MODE_OFF,
HVAC_MODE_COOL,
HVAC_MODE_HEAT,
HVAC_MODE_FAN_ONLY,
HVAC_MODE_DRY,
]
ZONE_HVAC_MODES = [HVAC_MODE_OFF, HVAC_MODE_FAN_ONLY]
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up AdvantageAir climate platform."""
instance = hass.data[DOMAIN][config_entry.entry_id]
entities = []
for ac_key in instance["coordinator"].data["aircons"]:
entities.append(AdvantageAirAC(instance, ac_key))
for zone_key in instance["coordinator"].data["aircons"][ac_key]["zones"]:
# Only add zone climate control when zone is in temperature control
if (
instance["coordinator"].data["aircons"][ac_key]["zones"][zone_key][
"type"
]
!= 0
):
entities.append(AdvantageAirZone(instance, ac_key, zone_key))
async_add_entities(entities)
class AdvantageAirClimateEntity(CoordinatorEntity, ClimateEntity):
"""AdvantageAir Climate class."""
def __init__(self, instance):
"""Initialize the base Advantage Air climate entity."""
super().__init__(instance["coordinator"])
self.async_change = instance["async_change"]
@property
def temperature_unit(self):
"""Return the temperature unit."""
return TEMP_CELSIUS
@property
def target_temperature_step(self):
"""Return the supported temperature step."""
return PRECISION_WHOLE
@property
def max_temp(self):
"""Return the maximum supported temperature."""
return 32
@property
def min_temp(self):
"""Return the minimum supported temperature."""
return 16
@property
def device_info(self):
"""Return parent device information."""
return {
"identifiers": {(DOMAIN, self.coordinator.data["system"]["rid"])},
"name": self.coordinator.data["system"]["name"],
"manufacturer": "Advantage Air",
"model": self.coordinator.data["system"]["sysType"],
"sw_version": self.coordinator.data["system"]["myAppRev"],
}
class AdvantageAirAC(AdvantageAirClimateEntity):
"""AdvantageAir AC unit."""
def __init__(self, instance, ac_key):
"""Initialize the Advantage Air AC climate entity."""
super().__init__(instance)
self.ac_key = ac_key
@property
def name(self):
"""Return the name."""
return self.coordinator.data["aircons"][self.ac_key]["info"]["name"]
@property
def unique_id(self):
"""Return a unique id."""
return f'{self.coordinator.data["system"]["rid"]}-{self.ac_key}'
@property
def target_temperature(self):
"""Return the current target temperature."""
return self.coordinator.data["aircons"][self.ac_key]["info"]["setTemp"]
@property
def hvac_mode(self):
"""Return the current HVAC modes."""
if (
self.coordinator.data["aircons"][self.ac_key]["info"]["state"]
== ADVANTAGE_AIR_STATE_ON
):
return ADVANTAGE_AIR_HVAC_MODES.get(
self.coordinator.data["aircons"][self.ac_key]["info"]["mode"]
)
return HVAC_MODE_OFF
@property
def hvac_modes(self):
"""Return the supported HVAC modes."""
return AC_HVAC_MODES
@property
def fan_mode(self):
"""Return the current fan modes."""
return ADVANTAGE_AIR_FAN_MODES.get(
self.coordinator.data["aircons"][self.ac_key]["info"]["fan"], FAN_OFF
)
@property
def fan_modes(self):
"""Return the supported fan modes."""
return [FAN_AUTO, FAN_LOW, FAN_MEDIUM, FAN_HIGH]
@property
def supported_features(self):
"""Return the supported features."""
return SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE
@property
def device_state_attributes(self):
"""Return additional attributes about AC unit."""
return self.coordinator.data["aircons"][self.ac_key]["info"]
async def async_set_hvac_mode(self, hvac_mode):
"""Set the HVAC Mode and State."""
if hvac_mode == HVAC_MODE_OFF:
await self.async_change(
{self.ac_key: {"info": {"state": ADVANTAGE_AIR_STATE_OFF}}}
)
else:
await self.async_change(
{
self.ac_key: {
"info": {
"state": ADVANTAGE_AIR_STATE_ON,
"mode": HASS_HVAC_MODES.get(hvac_mode),
}
}
}
)
async def async_set_fan_mode(self, fan_mode):
"""Set the Fan Mode."""
await self.async_change(
{self.ac_key: {"info": {"fan": HASS_FAN_MODES.get(fan_mode)}}}
)
async def async_set_temperature(self, **kwargs):
"""Set the Temperature."""
temp = kwargs.get(ATTR_TEMPERATURE)
await self.async_change({self.ac_key: {"info": {"setTemp": temp}}})
class AdvantageAirZone(AdvantageAirClimateEntity):
"""AdvantageAir Zone control."""
def __init__(self, instance, ac_key, zone_key):
"""Initialize the Advantage Air Zone climate entity."""
super().__init__(instance)
self.ac_key = ac_key
self.zone_key = zone_key
@property
def name(self):
"""Return the name."""
return self.coordinator.data["aircons"][self.ac_key]["zones"][self.zone_key][
"name"
]
@property
def unique_id(self):
"""Return a unique id."""
return f'{self.coordinator.data["system"]["rid"]}-{self.ac_key}-{self.zone_key}'
@property
def current_temperature(self):
"""Return the current temperature."""
return self.coordinator.data["aircons"][self.ac_key]["zones"][self.zone_key][
"measuredTemp"
]
@property
def target_temperature(self):
"""Return the target temperature."""
return self.coordinator.data["aircons"][self.ac_key]["zones"][self.zone_key][
"setTemp"
]
@property
def hvac_mode(self):
"""Return the current HVAC modes."""
if (
self.coordinator.data["aircons"][self.ac_key]["zones"][self.zone_key][
"state"
]
== ADVANTAGE_AIR_STATE_OPEN
):
return HVAC_MODE_FAN_ONLY
return HVAC_MODE_OFF
@property
def hvac_modes(self):
"""Return supported HVAC modes."""
return ZONE_HVAC_MODES
@property
def device_state_attributes(self):
"""Return additional attributes about Zone."""
return self.coordinator.data["aircons"][self.ac_key]["zones"][self.zone_key]
@property
def supported_features(self):
"""Return the supported features."""
return SUPPORT_TARGET_TEMPERATURE
async def async_set_hvac_mode(self, hvac_mode):
"""Set the HVAC Mode and State."""
if hvac_mode == HVAC_MODE_OFF:
await self.async_change(
{
self.ac_key: {
"zones": {self.zone_key: {"state": ADVANTAGE_AIR_STATE_CLOSE}}
}
}
)
else:
await self.async_change(
{
self.ac_key: {
"zones": {self.zone_key: {"state": ADVANTAGE_AIR_STATE_OPEN}}
}
}
)
async def async_set_temperature(self, **kwargs):
"""Set the Temperature."""
temp = kwargs.get(ATTR_TEMPERATURE)
await self.async_change(
{self.ac_key: {"zones": {self.zone_key: {"setTemp": temp}}}}
)
@@ -0,0 +1,61 @@
"""Config Flow for Advantage Air integration."""
import logging
from advantage_air import ApiError, advantage_air
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_IP_ADDRESS, CONF_PORT
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import ADVANTAGE_AIR_RETRY, DOMAIN
ADVANTAGE_AIR_DEFAULT_PORT = 2025
ADVANTAGE_AIR_SCHEMA = vol.Schema(
{
vol.Required(CONF_IP_ADDRESS): str,
vol.Optional(CONF_PORT, default=ADVANTAGE_AIR_DEFAULT_PORT): int,
}
)
_LOGGER = logging.getLogger(__name__)
class AdvantageAirConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Config Advantage Air API connection."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
DOMAIN = DOMAIN
async def async_step_user(self, user_input=None):
"""Get configuration from the user."""
errors = {}
if user_input:
ip_address = user_input[CONF_IP_ADDRESS]
port = user_input[CONF_PORT]
try:
data = await advantage_air(
ip_address,
port=port,
session=async_get_clientsession(self.hass),
retry=ADVANTAGE_AIR_RETRY,
).async_get(1)
except ApiError:
errors["base"] = "cannot_connect"
else:
await self.async_set_unique_id(data["system"]["rid"])
self._abort_if_unique_id_configured()
return self.async_create_entry(
title=data["system"]["name"],
data=user_input,
)
return self.async_show_form(
step_id="user",
data_schema=ADVANTAGE_AIR_SCHEMA,
errors=errors,
)
@@ -0,0 +1,7 @@
"""Constants used by Advantage Air integration."""
DOMAIN = "advantage_air"
ADVANTAGE_AIR_RETRY = 5
ADVANTAGE_AIR_STATE_OPEN = "open"
ADVANTAGE_AIR_STATE_CLOSE = "close"
ADVANTAGE_AIR_STATE_ON = "on"
ADVANTAGE_AIR_STATE_OFF = "off"
@@ -0,0 +1,12 @@
{
"domain": "advantage_air",
"name": "Advantage Air",
"config_flow": true,
"documentation": "https://www.home-assistant.io/integrations/advantage_air",
"codeowners": [
"@Bre77"
],
"requirements": [
"advantage_air==0.2.1"
]
}
@@ -0,0 +1,22 @@
{
"config": {
"flow_title": "Advantage Air Setup",
"error": {
"cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
},
"abort": {
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
},
"step": {
"user": {
"data": {
"ip_address": "[%key:common::config_flow::data::ip%]",
"port": "[%key:common::config_flow::data::port%]"
},
"description": "Connect to the API of your Advantage Air wall mounted tablet.",
"title": "Connect"
}
}
},
"title": "Advantage Air"
}
@@ -0,0 +1,22 @@
{
"config": {
"abort": {
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
},
"error": {
"cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
},
"flow_title": "Advantage Air Setup",
"step": {
"user": {
"data": {
"ip_address": "[%key:common::config_flow::data::ip%]",
"port": "[%key:common::config_flow::data::port%]"
},
"description": "Connect to the API of your Advantage Air wall mounted tablet.",
"title": "Connect"
}
}
},
"title": "Advantage Air"
}