Genius hub

.coveragerc

@@ -174,6 +174,7 @@ omit =
     homeassistant/components/freebox/*
     homeassistant/components/fritzbox/*
     homeassistant/components/gc100/*
+    homeassistant/components/geniushub/*
     homeassistant/components/goalfeed/*
     homeassistant/components/google/*
     homeassistant/components/googlehome/*

homeassistant/components/geniushub/__init__.py

@@ -0,0 +1,43 @@
+"""This module connects to the Genius hub and shares the data."""
+import voluptuous as vol
+
+from homeassistant.const import (
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_SCAN_INTERVAL)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.discovery import async_load_platform
+
+REQUIREMENTS = ['geniushub==0.1']
+GENIUS_HUB = 'genius_hub'
+DOMAIN = 'geniushub'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASSWORD): cv.string,
+        vol.Required(CONF_HOST): cv.string,
+        vol.Optional(CONF_SCAN_INTERVAL, default=6): cv.positive_int,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+async def async_setup(hass, config):
+    """Try to start embedded Genius Hub broker."""
+    from geniushub.geniushub import GeniusHub
+
+    username = config[DOMAIN].get(CONF_USERNAME)
+    password = config[DOMAIN].get(CONF_PASSWORD)
+    host = config[DOMAIN].get(CONF_HOST)
+    scan_interval = config[DOMAIN].get(CONF_SCAN_INTERVAL)
+    hass.data[GENIUS_HUB] = GeniusHub(
+        host, username, password, scan_interval)
+
+    hass.async_create_task(async_load_platform(
+        hass, 'climate', DOMAIN, None, config))
+
+    hass.async_create_task(async_load_platform(
+        hass, 'switch', DOMAIN, None, config))
+
+    hass.async_create_task(async_load_platform(
+        hass, 'sensor', DOMAIN, None, config))
+
+    return True

homeassistant/components/geniushub/climate.py

@@ -0,0 +1,204 @@
+"""
+Supports Genius hub to provide climate controls.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/climate.geniushub/
+"""
+import logging
+
+from homeassistant.components.climate import ClimateDevice
+from homeassistant.components.climate.const import (
+    STATE_ECO, STATE_HEAT, STATE_AUTO, STATE_IDLE,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
+    SUPPORT_ON_OFF, SUPPORT_AWAY_MODE)
+from homeassistant.components.geniushub import GENIUS_HUB
+from homeassistant.const import (
+    ATTR_TEMPERATURE, STATE_OFF, STATE_ON, TEMP_CELSIUS)
+
+_LOGGER = logging.getLogger(__name__)
+DOMAIN = 'geniushub'
+
+
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE \
+    | SUPPORT_ON_OFF | SUPPORT_AWAY_MODE
+# Genius supports the operation modes: Off, Override, Footprint and Timer
+# To work with Alexa these MUST BE
+#
+#   climate.STATE_HEAT: 'HEAT',
+#   climate.STATE_COOL: 'COOL',
+#   climate.STATE_AUTO: 'AUTO',
+#   climate.STATE_ECO: 'ECO',
+#   climate.STATE_IDLE: 'OFF',
+#   climate.STATE_FAN_ONLY: 'OFF',
+#   climate.STATE_DRY: 'OFF',
+
+# These needed to be mapped into HA modes:
+# Off       => OFF      => STATE_IDLE   # Mode_Off: 1,
+# Override  => HEAT     => STATE_HEAT # Mode_Boost: 16,
+# Footprint => ECO      => STATE_ECO    # Mode_Footprint: 4,
+# Timer     => AUTO     => STATE_AUTO   # Mode_Timer: 2,
+# Away                      # Mode_Away: 8,
+#
+OPERATION_LIST = [STATE_IDLE, STATE_HEAT, STATE_ECO, STATE_AUTO]
+
+
+async def async_setup_platform(hass, config,
+                               async_add_entities, discovery_info=None):
+    """Set up the Genius hub climate devices."""
+    genius_hub = hass.data[GENIUS_HUB]
+    await genius_hub.getjson('/zones')
+
+    # Get the zones with a temperature
+    climate_list = genius_hub.getClimateList()
+
+    for zone in climate_list:
+        async_add_entities([GeniusClimate(genius_hub, zone)])
+
+
+class GeniusClimate(ClimateDevice):
+    """Representation of a Genius Hub climate device."""
+
+    def __init__(self, genius_hub, zone):
+        """Initialize the climate device."""
+        GeniusClimate._genius_hub = genius_hub
+        self._name = zone['name']
+        self._device_id = zone['iID']
+        self._current_temperature = zone['current_temperature']
+        self._target_temperature = zone['target_temperature']
+        self._mode = zone['mode']
+        self._is_active = zone['is_active']
+
+    @property
+    def state(self):
+        """Return the current state."""
+        if self._is_active:
+            return STATE_ON
+
+        return STATE_OFF
+
+    @property
+    def name(self):
+        """Return the name of the climate device."""
+        return self._name
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._current_temperature
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temperature
+
+    @property
+    def min_temp(self):
+        """Return max valid temperature that can be set."""
+        return 4.0
+
+    @property
+    def max_temp(self):
+        """Return max valid temperature that can be set."""
+        return 28.0
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        return TEMP_CELSIUS
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    @property
+    def operation_list(self):
+        """Return the list of available operation modes."""
+        return OPERATION_LIST
+
+    @property
+    def is_on(self):
+        """Return true if the device is on."""
+        if self._mode == "off":
+            return False
+
+        return True
+
+    @property
+    def is_away_mode_on(self):
+        """Return true if away mode is on."""
+        if self._mode == "away":
+            return True
+
+        return False
+
+    @property
+    def current_operation(self):
+        """Return the current operation mode."""
+        return self.get_current_operation_mode(self._mode)
+
+    @staticmethod
+    def get_current_operation_mode(mode):
+        """Return the current operational mode."""
+        mode_map = {
+            'override': STATE_HEAT,
+            'footprint': STATE_ECO,
+            'timer': STATE_AUTO,
+        }
+        return mode_map.get(mode, STATE_IDLE)
+
+    def get_operation_mode(self, operation_mode):
+        """Coverts operation mode from Home Assistant to Genius Hub."""
+        # These needed to be mapped into HA modes:
+        # Off       => OFF      => STATE_IDLE   # Mode_Off: 1,
+        # Override  => HEAT     => STATE_HEAT # Mode_Boost: 16,
+        # Footprint => ECO      => STATE_ECO    # Mode_Footprint: 4,
+        # Timer     => AUTO     => STATE_AUTO   # Mode_Timer: 2,
+        # Away                      # Mode_Away: 8,
+        #
+        # OPERATION_LIST = [STATE_IDLE, STATE_HEAT, STATE_ECO, STATE_AUTO]
+        operation_mode_map = {
+            STATE_IDLE: {'mode': 'off', 'data': {'iMode': 1}},
+            STATE_HEAT: {'mode': 'override', 'data':
+                         {'iBoostTimeRemaining': 3600,
+                          'iMode': 16,
+                          'fBoostSP': self._target_temperature}},
+            STATE_ECO: {'mode': 'footprint', 'data': {'iMode': 4}},
+            STATE_AUTO: {'mode': 'timer', 'data': {'iMode': 2}}, }
+        return operation_mode_map.get(operation_mode,
+                                      {'mode': 'off', 'data': None})
+
+    async def async_set_operation_mode(self, operation_mode):
+        """Set new operation mode."""
+        data = self.get_operation_mode(operation_mode)
+        self._mode = data['mode']
+        if data['data'] is None:
+            _LOGGER.error("Unknown mode")
+            return
+
+        await GeniusClimate._genius_hub.putjson(self._device_id, data['data'])
+
+    async def async_set_temperature(self, **kwargs):
+        """Set new target temperatures."""
+        if kwargs.get(ATTR_TEMPERATURE) is not None:
+            await self.async_set_operation_mode(STATE_HEAT)
+
+    async def async_update(self):
+        """Get the latest data from the hub."""
+        what_zone = GeniusClimate._genius_hub.getZone(self._device_id)
+        if what_zone:
+            zone = GeniusClimate._genius_hub.GET_CLIMATE(what_zone)
+            self._current_temperature = zone['current_temperature']
+            self._target_temperature = zone['target_temperature']
+            self._mode = zone['mode']
+            self._is_active = zone['is_active']
+
+    async def async_turn_on(self):
+        """Turn on."""
+        await self.async_set_operation_mode(STATE_AUTO)
+        self._mode = "on"
+
+    async def async_turn_off(self):
+        """Turn off."""
+        await self.async_set_operation_mode(STATE_IDLE)
+        self._mode = "off"

homeassistant/components/geniushub/sensor.py

@@ -0,0 +1,135 @@
+"""
+Supports Genius hub to provide room sensor and TRV information.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/sensor.geniushub/
+"""
+from homeassistant.components.geniushub import GENIUS_HUB
+from homeassistant.const import (
+    ATTR_BATTERY_LEVEL, ATTR_TEMPERATURE)
+from homeassistant.helpers.entity import Entity
+
+DOMAIN = 'geniushub'
+
+
+async def async_setup_platform(hass, config,
+                               async_add_entities, discovery_info=None):
+    """Set up the Demo climate devices."""
+    genius_hub = hass.data[GENIUS_HUB]
+    await genius_hub.getjson('/zones')
+
+    # Get sensors
+    for sensor in genius_hub.getSensorList():
+        async_add_entities([GeniusSensor(genius_hub, sensor)])
+
+    # Get TRVs
+    for trv in genius_hub.getTRVList():
+        async_add_entities([GeniusTRV(genius_hub, trv)])
+
+
+class GeniusSensor(Entity):
+    """Representation of a Wall Sensor."""
+
+    _genius_hub = None
+
+    def __init__(self, genius_hub, sensor):
+        """Initialize the Wall sensor."""
+        GeniusSensor._genius_hub = genius_hub
+        self._name = sensor['name'] + ' sensor ' + str(sensor['index'])
+        self._device_id = sensor['iID']
+        self._device_addr = sensor['addr']
+        self._battery = sensor['Battery']
+        self._temperature = sensor['TEMPERATURE']
+        self._luminance = sensor['LUMINANCE']
+        self._motion = sensor['Motion']
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self._temperature
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return "genius_wall_sensor"
+
+    @property
+    def force_update(self):
+        """Force update."""
+        return True
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_BATTERY_LEVEL: self._battery,
+            'luminance': self._luminance,
+            'motion': self._motion,
+            ATTR_TEMPERATURE: self._temperature
+        }
+
+    async def async_update(self):
+        """Get the latest data."""
+        device = GeniusSensor._genius_hub.getDevice(
+            self._device_id, self._device_addr)
+        data = GeniusSensor._genius_hub.getSensor(device)
+        self._battery = data['Battery']
+        self._temperature = data['TEMPERATURE']
+        self._luminance = data['LUMINANCE']
+        self._motion = data['Motion']
+
+
+class GeniusTRV(Entity):
+    """Representation of a TRV Sensor."""
+
+    _genius_hub = None
+
+    def __init__(self, genius_hub, trv):
+        """Initialize the TRV sensor."""
+        GeniusTRV._genius_hub = genius_hub
+        self._name = trv['name'] + ' TRV ' + str(trv['index'])
+        self._device_id = trv['iID']
+        self._device_addr = trv['addr']
+        self._battery = trv['Battery']
+        self._temperature = trv['TEMPERATURE']
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self._temperature
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return "genius_trv"
+
+    @property
+    def force_update(self):
+        """Force update."""
+        return True
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_BATTERY_LEVEL: self._battery,
+            ATTR_TEMPERATURE: self._temperature
+        }
+
+    async def async_update(self):
+        """Get the latest data."""
+        device = GeniusTRV._genius_hub.getDevice(
+            self._device_id, self._device_addr)
+        data = GeniusTRV._genius_hub.getTRV(device)
+        self._battery = data['Battery']
+        self._temperature = data['TEMPERATURE']