Genius hub

.coveragerc

@@ -203,6 +203,7 @@ omit =
     homeassistant/components/futurenow/light.py
     homeassistant/components/garadget/cover.py
     homeassistant/components/gc100/*
+    homeassistant/components/geniushub/*
     homeassistant/components/gearbest/sensor.py
     homeassistant/components/geizhals/sensor.py
     homeassistant/components/github/sensor.py

homeassistant/components/geniushub/__init__.py

@@ -0,0 +1,38 @@
+"""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.time_period,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+async def async_setup(hass, config):
+    """Try to start embedded Genius Hub broker."""
+    from geniushub.geniushub import GeniusHub
+
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+    host = config.get(CONF_HOST)
+    scan_interval = config.get(CONF_SCAN_INTERVAL)
+
+    hass.data[GENIUS_HUB] = GeniusHub(
+        host, username, password, scan_interval)
+
+    hass.async_create_task(async_load_platform(
+        hass, 'climate', DOMAIN, {}, config))
+
+    return True

homeassistant/components/geniushub/climate.py

@@ -0,0 +1,200 @@
+"""
+Supports Genius hub to provide climate controls.
+"""
+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 . import (
+    DOMAIN, GENIUS_HUB)
+from homeassistant.const import (
+    ATTR_TEMPERATURE, TEMP_CELSIUS)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+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]
+
+"""Map between GeniusHub and Home Assistant"""
+MODE_MAP = {
+    'override': STATE_HEAT,
+    'footprint': STATE_ECO,
+    'timer': STATE_AUTO,
+}
+
+
+async def async_setup_platform(hass, config, async_add_entities,
+                               discovery_info=None):
+
+    """Set up the Genius hub climate devices."""
+    if discovery_info is None:
+        return
+
+    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 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."""
+        return self._mode != "off"
+
+    @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."""
+        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 %s", operation_mode)
+            return
+
+        await GeniusClimate._genius_hub.putjson(self._device_id, data['data'])
+
+    async def async_set_temperature(self, **kwargs):
+        """Set new target temperatures."""
+        temperature = kwargs.get(ATTR_TEMPERATURE)
+        if temperature is None:
+            return
+
+        self._target_temperature = temperature
+        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"

requirements_all.txt

@@ -463,6 +463,9 @@ gearbest_parser==1.0.7
 # homeassistant.components.geizhals.sensor
 geizhals==0.0.9
 
+# homeassistant.components.geniushub
+geniushub==0.1
+
 # homeassistant.components.geo_json_events.geo_location
 # homeassistant.components.nsw_rural_fire_service_feed.geo_location
 # homeassistant.components.usgs_earthquakes_feed.geo_location