Merge pull request #9395 from home-assistant/release-0-53-1

0.53.1
Fixing foscam library dependency/requirements (#9387 )
2017-09-11 22:43:56 -07:00 · 2017-09-11 21:53:20 -07:00 · 2017-09-11 21:53:20 -07:00 · 2017-09-11 21:53:19 -07:00 · 2017-09-11 21:53:01 -07:00 · 2017-09-11 21:52:48 -07:00
585 changed files with 28896 additions and 6506 deletions
@@ -8,6 +8,9 @@ omit =
    homeassistant/helpers/signal.py

    # omit pieces of code that rely on external devices being present
+    homeassistant/components/abode.py
+    homeassistant/components/*/abode.py
+
    homeassistant/components/alarmdecoder.py
    homeassistant/components/*/alarmdecoder.py

@@ -29,6 +32,9 @@ omit =
    homeassistant/components/arlo.py
    homeassistant/components/*/arlo.py

+    homeassistant/components/asterisk_mbox.py
+    homeassistant/components/*/asterisk_mbox.py
+
    homeassistant/components/axis.py
    homeassistant/components/*/axis.py

@@ -164,6 +170,9 @@ omit =
    homeassistant/components/tellstick.py
    homeassistant/components/*/tellstick.py

+    homeassistant/components/tesla.py
+    homeassistant/components/*/tesla.py
+
    homeassistant/components/*/thinkingcleaner.py

    homeassistant/components/tradfri.py
@@ -173,6 +182,12 @@ omit =
    homeassistant/components/notify/twilio_sms.py
    homeassistant/components/notify/twilio_call.py

+    homeassistant/components/usps.py
+    homeassistant/components/*/usps.py
+
+    homeassistant/components/velbus.py
+    homeassistant/components/*/velbus.py
+
    homeassistant/components/velux.py
    homeassistant/components/*/velux.py

@@ -193,6 +208,13 @@ omit =
    homeassistant/components/wink.py
    homeassistant/components/*/wink.py

+    homeassistant/components/xiaomi.py
+    homeassistant/components/binary_sensor/xiaomi.py
+    homeassistant/components/cover/xiaomi.py
+    homeassistant/components/light/xiaomi.py
+    homeassistant/components/sensor/xiaomi.py
+    homeassistant/components/switch/xiaomi.py
+
    homeassistant/components/zabbix.py
    homeassistant/components/*/zabbix.py

@@ -208,6 +230,8 @@ omit =

    homeassistant/components/alarm_control_panel/alarmdotcom.py
    homeassistant/components/alarm_control_panel/concord232.py
+    homeassistant/components/alarm_control_panel/egardia.py
+    homeassistant/components/alarm_control_panel/manual_mqtt.py
    homeassistant/components/alarm_control_panel/nx584.py
    homeassistant/components/alarm_control_panel/simplisafe.py
    homeassistant/components/alarm_control_panel/totalconnect.py
@@ -257,6 +281,7 @@ omit =
    homeassistant/components/device_tracker/cisco_ios.py
    homeassistant/components/device_tracker/fritz.py
    homeassistant/components/device_tracker/gpslogger.py
+    homeassistant/components/device_tracker/huawei_router.py
    homeassistant/components/device_tracker/icloud.py
    homeassistant/components/device_tracker/linksys_ap.py
    homeassistant/components/device_tracker/linksys_smart.py
@@ -274,7 +299,6 @@ omit =
    homeassistant/components/device_tracker/tplink.py
    homeassistant/components/device_tracker/trackr.py
    homeassistant/components/device_tracker/ubus.py
-    homeassistant/components/device_tracker/xiaomi.py
    homeassistant/components/downloader.py
    homeassistant/components/emoncms_history.py
    homeassistant/components/emulated_hue/upnp.py
@@ -291,6 +315,7 @@ omit =
    homeassistant/components/light/blinkt.py
    homeassistant/components/light/blinksticklight.py
    homeassistant/components/light/decora.py
+    homeassistant/components/light/decora_wifi.py
    homeassistant/components/light/flux_led.py
    homeassistant/components/light/hue.py
    homeassistant/components/light/hyperion.py
@@ -303,18 +328,22 @@ omit =
    homeassistant/components/light/piglow.py
    homeassistant/components/light/sensehat.py
    homeassistant/components/light/tikteck.py
+    homeassistant/components/light/tplink.py
    homeassistant/components/light/tradfri.py
    homeassistant/components/light/x10.py
+    homeassistant/components/light/xiaomi_philipslight.py
    homeassistant/components/light/yeelight.py
    homeassistant/components/light/yeelightsunflower.py
    homeassistant/components/light/zengge.py
    homeassistant/components/lirc.py
+    homeassistant/components/lock/nello.py
    homeassistant/components/lock/nuki.py
    homeassistant/components/lock/lockitron.py
    homeassistant/components/lock/sesame.py
    homeassistant/components/media_extractor.py
    homeassistant/components/media_player/anthemav.py
    homeassistant/components/media_player/aquostv.py
+    homeassistant/components/media_player/bluesound.py
    homeassistant/components/media_player/braviatv.py
    homeassistant/components/media_player/cast.py
    homeassistant/components/media_player/clementine.py
@@ -344,6 +373,7 @@ omit =
    homeassistant/components/media_player/pioneer.py
    homeassistant/components/media_player/plex.py
    homeassistant/components/media_player/roku.py
+    homeassistant/components/media_player/russound_rio.py
    homeassistant/components/media_player/russound_rnet.py
    homeassistant/components/media_player/samsungtv.py
    homeassistant/components/media_player/snapcast.py
@@ -354,6 +384,8 @@ omit =
    homeassistant/components/media_player/vlc.py
    homeassistant/components/media_player/volumio.py
    homeassistant/components/media_player/yamaha.py
+    homeassistant/components/media_player/yamaha_musiccast.py
+    homeassistant/components/mycroft.py
    homeassistant/components/notify/aws_lambda.py
    homeassistant/components/notify/aws_sns.py
    homeassistant/components/notify/aws_sqs.py
@@ -364,14 +396,17 @@ omit =
    homeassistant/components/notify/free_mobile.py
    homeassistant/components/notify/gntp.py
    homeassistant/components/notify/group.py
+    homeassistant/components/notify/hipchat.py
    homeassistant/components/notify/instapush.py
    homeassistant/components/notify/kodi.py
    homeassistant/components/notify/lannouncer.py
    homeassistant/components/notify/llamalab_automate.py
    homeassistant/components/notify/matrix.py
    homeassistant/components/notify/message_bird.py
+    homeassistant/components/notify/mycroft.py
    homeassistant/components/notify/nfandroidtv.py
    homeassistant/components/notify/nma.py
+    homeassistant/components/notify/prowl.py
    homeassistant/components/notify/pushbullet.py
    homeassistant/components/notify/pushetta.py
    homeassistant/components/notify/pushover.py
@@ -392,6 +427,7 @@ omit =
    homeassistant/components/remote/itach.py
    homeassistant/components/scene/hunterdouglas_powerview.py
    homeassistant/components/scene/lifx_cloud.py
+    homeassistant/components/sensor/airvisual.py
    homeassistant/components/sensor/arest.py
    homeassistant/components/sensor/arwn.py
    homeassistant/components/sensor/bbox.py
@@ -417,6 +453,7 @@ omit =
    homeassistant/components/sensor/dovado.py
    homeassistant/components/sensor/dte_energy_bridge.py
    homeassistant/components/sensor/dublin_bus_transport.py
+    homeassistant/components/sensor/dwd_weather_warnings.py
    homeassistant/components/sensor/ebox.py
    homeassistant/components/sensor/eddystone_temperature.py
    homeassistant/components/sensor/eliqonline.py
@@ -430,6 +467,7 @@ omit =
    homeassistant/components/sensor/fixer.py
    homeassistant/components/sensor/fritzbox_callmonitor.py
    homeassistant/components/sensor/fritzbox_netmonitor.py
+    homeassistant/components/sensor/geizhals.py
    homeassistant/components/sensor/gitter.py
    homeassistant/components/sensor/glances.py
    homeassistant/components/sensor/google_travel_time.py
@@ -451,6 +489,7 @@ omit =
    homeassistant/components/sensor/metoffice.py
    homeassistant/components/sensor/miflora.py
    homeassistant/components/sensor/modem_callerid.py
+    homeassistant/components/sensor/mopar.py
    homeassistant/components/sensor/mqtt_room.py
    homeassistant/components/sensor/mvglive.py
    homeassistant/components/sensor/netdata.py
@@ -476,6 +515,7 @@ omit =
    homeassistant/components/sensor/scrape.py
    homeassistant/components/sensor/sensehat.py
    homeassistant/components/sensor/serial_pm.py
+    homeassistant/components/sensor/shodan.py
    homeassistant/components/sensor/skybeacon.py
    homeassistant/components/sensor/sma.py
    homeassistant/components/sensor/snmp.py
@@ -487,6 +527,7 @@ omit =
    homeassistant/components/sensor/swiss_public_transport.py
    homeassistant/components/sensor/synologydsm.py
    homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/tank_utility.py
    homeassistant/components/sensor/ted5000.py
    homeassistant/components/sensor/temper.py
    homeassistant/components/sensor/time_date.py
@@ -496,9 +537,9 @@ omit =
    homeassistant/components/sensor/uber.py
    homeassistant/components/sensor/upnp.py
    homeassistant/components/sensor/ups.py
-    homeassistant/components/sensor/usps.py
    homeassistant/components/sensor/vasttrafik.py
    homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/worldtidesinfo.py
    homeassistant/components/sensor/xbox_live.py
    homeassistant/components/sensor/yweather.py
    homeassistant/components/sensor/zamg.py
@@ -520,17 +561,18 @@ omit =
    homeassistant/components/switch/orvibo.py
    homeassistant/components/switch/pilight.py
    homeassistant/components/switch/pulseaudio_loopback.py
+    homeassistant/components/switch/rainmachine.py
    homeassistant/components/switch/rest.py
    homeassistant/components/switch/rpi_rf.py
    homeassistant/components/switch/tplink.py
    homeassistant/components/switch/transmission.py
    homeassistant/components/switch/wake_on_lan.py
-    homeassistant/components/switch/xiaomi_vacuum.py
    homeassistant/components/telegram_bot/*
    homeassistant/components/thingspeak.py
    homeassistant/components/tts/amazon_polly.py
    homeassistant/components/tts/picotts.py
    homeassistant/components/upnp.py
+    homeassistant/components/vacuum/roomba.py
    homeassistant/components/weather/bom.py
    homeassistant/components/weather/buienradar.py
    homeassistant/components/weather/metoffice.py
@@ -73,6 +73,7 @@ pyvenv.cfg
 pip-selfcheck.json
 venv
 .venv
+Pipfile*

 # vimmy stuff
 *.swp
@@ -93,3 +94,6 @@ docs/build

 # Windows Explorer
 desktop.ini
+/home-assistant.pyproj
+/home-assistant.sln
+/.vs/home-assistant/v14
@@ -4,11 +4,11 @@ Everybody is invited and welcome to contribute to Home Assistant. There is a lot

 The process is straight-forward.

- - Read [How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/faster_reviews.md) by Kubernetes (but skip step 0)
+ - Read [How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/pull-requests.md#best-practices-for-faster-reviews) by Kubernetes (but skip step 0)
 - Fork the Home Assistant [git repository](https://github.com/home-assistant/home-assistant).
 - Write the code for your device, notification service, sensor, or IoT thing.
 - Ensure tests work.
 - Create a Pull Request against the [**dev**](https://github.com/home-assistant/home-assistant/tree/dev) branch of Home Assistant.

-Still interested? Then you should take a peak at the [developer documentation](https://home-assistant.io/developers/) to get more details.
+Still interested? Then you should take a peek at the [developer documentation](https://home-assistant.io/developers/) to get more details.

@@ -29,8 +29,7 @@ COPY requirements_all.txt requirements_all.txt
 # Uninstall enum34 because some depenndecies install it but breaks Python 3.4+.
 # See PR #8103 for more info.
 RUN pip3 install --no-cache-dir -r requirements_all.txt && \
-    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet && \
-    pip3 uninstall -y enum34
+    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet

 # Copy source
 COPY . .
@@ -1,5 +1,5 @@
-Home Assistant |Build Status| |Coverage Status| |Join the chat at https://gitter.im/home-assistant/home-assistant| |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs|
-==============================================================================================================================================================================================
+Home Assistant |Build Status| |Coverage Status| |Chat Status|
+=============================================================

 Home Assistant is a home automation platform running on Python 3. It is able to track and control all devices at home and offer a platform for automating control.

@@ -31,10 +31,8 @@ of a component, check the `Home Assistant help section <https://home-assistant.i
   :target: https://travis-ci.org/home-assistant/home-assistant
 .. |Coverage Status| image:: https://img.shields.io/coveralls/home-assistant/home-assistant.svg
   :target: https://coveralls.io/r/home-assistant/home-assistant?branch=master
-.. |Join the chat at https://gitter.im/home-assistant/home-assistant| image:: https://img.shields.io/badge/gitter-general-blue.svg
-   :target: https://gitter.im/home-assistant/home-assistant?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-.. |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs| image:: https://img.shields.io/badge/gitter-development-yellowgreen.svg
-   :target: https://gitter.im/home-assistant/home-assistant/devs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+.. |Chat Status| image:: https://img.shields.io/discord/330944238910963714.svg
+   :target: https://discord.gg/c5DvZ4e
 .. |screenshot-states| image:: https://raw.github.com/home-assistant/home-assistant/master/docs/screenshots.png
   :target: https://home-assistant.io/demo/
 .. |screenshot-components| image:: https://raw.github.com/home-assistant/home-assistant/dev/docs/screenshot-components.png
@@ -19,6 +19,7 @@ from homeassistant.const import EVENT_HOMEASSISTANT_CLOSE
 from homeassistant.setup import async_setup_component
 import homeassistant.loader as loader
 from homeassistant.util.logging import AsyncHandler
+from homeassistant.util.package import async_get_user_site, get_user_site
 from homeassistant.util.yaml import clear_secret_cache
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.signal import async_register_signal_handling
@@ -39,7 +40,7 @@ def from_config_dict(config: Dict[str, Any],
                     skip_pip: bool=False,
                     log_rotate_days: Any=None) \
                     -> Optional[core.HomeAssistant]:
-    """Try to configure Home Assistant from a config dict.
+    """Try to configure Home Assistant from a configuration dictionary.

    Dynamically loads required components and its dependencies.
    """
@@ -48,7 +49,8 @@ def from_config_dict(config: Dict[str, Any],
        if config_dir is not None:
            config_dir = os.path.abspath(config_dir)
            hass.config.config_dir = config_dir
-            mount_local_lib_path(config_dir)
+            hass.loop.run_until_complete(
+                async_mount_local_lib_path(config_dir, hass.loop))

    # run task
    hass = hass.loop.run_until_complete(
@@ -69,7 +71,7 @@ def async_from_config_dict(config: Dict[str, Any],
                           skip_pip: bool=False,
                           log_rotate_days: Any=None) \
                           -> Optional[core.HomeAssistant]:
-    """Try to configure Home Assistant from a config dict.
+    """Try to configure Home Assistant from a configuration dictionary.

    Dynamically loads required components and its dependencies.
    This method is a coroutine.
@@ -90,8 +92,8 @@ def async_from_config_dict(config: Dict[str, Any],

    hass.config.skip_pip = skip_pip
    if skip_pip:
-        _LOGGER.warning('Skipping pip installation of required modules. '
-                        'This may cause issues.')
+        _LOGGER.warning("Skipping pip installation of required modules. "
+                        "This may cause issues")

    if not loader.PREPARED:
        yield from hass.async_add_job(loader.prepare, hass)
@@ -116,13 +118,13 @@ def async_from_config_dict(config: Dict[str, Any],
    # pylint: disable=not-an-iterable
    res = yield from core_components.async_setup(hass, config)
    if not res:
-        _LOGGER.error('Home Assistant core failed to initialize. '
-                      'Further initialization aborted.')
+        _LOGGER.error("Home Assistant core failed to initialize. "
+                      "further initialization aborted")
        return hass

    yield from persistent_notification.async_setup(hass, config)

-    _LOGGER.info('Home Assistant core initialized')
+    _LOGGER.info("Home Assistant core initialized")

    # stage 1
    for component in components:
@@ -141,7 +143,7 @@ def async_from_config_dict(config: Dict[str, Any],
    yield from hass.async_block_till_done()

    stop = time()
-    _LOGGER.info('Home Assistant initialized in %.2fs', stop-start)
+    _LOGGER.info("Home Assistant initialized in %.2fs", stop-start)

    async_register_signal_handling(hass)
    return hass
@@ -183,7 +185,7 @@ def async_from_config_file(config_path: str,
    # Set config dir to directory holding config file
    config_dir = os.path.abspath(os.path.dirname(config_path))
    hass.config.config_dir = config_dir
-    yield from hass.async_add_job(mount_local_lib_path, config_dir)
+    yield from async_mount_local_lib_path(config_dir, hass.loop)

    async_enable_logging(hass, verbose, log_rotate_days)

@@ -191,7 +193,7 @@ def async_from_config_file(config_path: str,
        config_dict = yield from hass.async_add_job(
            conf_util.load_yaml_config_file, config_path)
    except HomeAssistantError as err:
-        _LOGGER.error('Error loading %s: %s', config_path, err)
+        _LOGGER.error("Error loading %s: %s", config_path, err)
        return None
    finally:
        clear_secret_cache()
@@ -276,11 +278,23 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,


 def mount_local_lib_path(config_dir: str) -> str:
+    """Add local library to Python Path."""
+    deps_dir = os.path.join(config_dir, 'deps')
+    lib_dir = get_user_site(deps_dir)
+    if lib_dir not in sys.path:
+        sys.path.insert(0, lib_dir)
+    return deps_dir
+
+
+@asyncio.coroutine
+def async_mount_local_lib_path(config_dir: str,
+                               loop: asyncio.AbstractEventLoop) -> str:
    """Add local library to Python Path.

-    Async friendly.
+    This function is a coroutine.
    """
    deps_dir = os.path.join(config_dir, 'deps')
-    if deps_dir not in sys.path:
-        sys.path.insert(0, os.path.join(config_dir, 'deps'))
+    lib_dir = yield from async_get_user_site(deps_dir, loop=loop)
+    if lib_dir not in sys.path:
+        sys.path.insert(0, lib_dir)
    return deps_dir
@@ -15,7 +15,6 @@ import homeassistant.core as ha
 import homeassistant.config as conf_util
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.service import extract_entity_ids
-from homeassistant.loader import get_component
 from homeassistant.const import (
    ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_TOGGLE,
    SERVICE_HOMEASSISTANT_STOP, SERVICE_HOMEASSISTANT_RESTART,
@@ -33,25 +32,27 @@ def is_on(hass, entity_id=None):
    If there is no entity id given we will check all.
    """
    if entity_id:
-        group = get_component('group')
-
-        entity_ids = group.expand_entity_ids(hass, [entity_id])
+        entity_ids = hass.components.group.expand_entity_ids([entity_id])
    else:
        entity_ids = hass.states.entity_ids()

    for ent_id in entity_ids:
        domain = ha.split_entity_id(ent_id)[0]

-        module = get_component(domain)
-
        try:
-            if module.is_on(hass, ent_id):
-                return True
+            component = getattr(hass.components, domain)

-        except AttributeError:
-            # module is None or method is_on does not exist
-            _LOGGER.exception("Failed to call %s.is_on for %s",
-                              module, ent_id)
+        except ImportError:
+            _LOGGER.error('Failed to call %s.is_on: component not found',
+                          domain)
+            continue
+
+        if not hasattr(component, 'is_on'):
+            _LOGGER.warning("Component %s has no is_on method.", domain)
+            continue
+
+        if component.is_on(ent_id):
+            return True

    return False

@@ -100,6 +101,12 @@ def reload_core_config(hass):
    hass.services.call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)


+@asyncio.coroutine
+def async_reload_core_config(hass):
+    """Reload the core config."""
+    yield from hass.services.async_call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)
+
+
@asyncio.coroutine
 def async_setup(hass, config):
    """Set up general services related to Home Assistant."""
@@ -161,10 +168,9 @@ def async_setup(hass, config):
            return

        if errors:
-            notif = get_component('persistent_notification')
            _LOGGER.error(errors)
-            notif.async_create(
-                hass, "Config error. See dev-info panel for details.",
+            hass.components.persistent_notification.async_create(
+                "Config error. See dev-info panel for details.",
                "Config validating", "{0}.check_config".format(ha.DOMAIN))
            return

@@ -0,0 +1,126 @@
+"""
+This component provides basic support for Abode Home Security system.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/abode/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+from requests.exceptions import HTTPError, ConnectTimeout
+from homeassistant.helpers import discovery
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity import Entity
+from homeassistant.const import (ATTR_ATTRIBUTION,
+                                 CONF_USERNAME, CONF_PASSWORD,
+                                 CONF_NAME, EVENT_HOMEASSISTANT_STOP,
+                                 EVENT_HOMEASSISTANT_START)
+
+REQUIREMENTS = ['abodepy==0.9.0']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ATTRIBUTION = "Data provided by goabode.com"
+
+DOMAIN = 'abode'
+DEFAULT_NAME = 'Abode'
+DATA_ABODE = 'abode'
+
+NOTIFICATION_ID = 'abode_notification'
+NOTIFICATION_TITLE = 'Abode Security Setup'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASSWORD): cv.string,
+        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+ABODE_PLATFORMS = [
+    'alarm_control_panel', 'binary_sensor', 'lock', 'switch', 'cover'
+]
+
+
+def setup(hass, config):
+    """Set up Abode component."""
+    import abodepy
+
+    conf = config[DOMAIN]
+    username = conf.get(CONF_USERNAME)
+    password = conf.get(CONF_PASSWORD)
+
+    try:
+        hass.data[DATA_ABODE] = abode = abodepy.Abode(
+            username, password, auto_login=True, get_devices=True)
+
+    except (ConnectTimeout, HTTPError) as ex:
+        _LOGGER.error("Unable to connect to Abode: %s", str(ex))
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(ex),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+        return False
+
+    for platform in ABODE_PLATFORMS:
+        discovery.load_platform(hass, platform, DOMAIN, {}, config)
+
+    def logout(event):
+        """Logout of Abode."""
+        abode.stop_listener()
+        abode.logout()
+        _LOGGER.info("Logged out of Abode")
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, logout)
+
+    def startup(event):
+        """Listen for push events."""
+        abode.start_listener()
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, startup)
+
+    return True
+
+
+class AbodeDevice(Entity):
+    """Representation of an Abode device."""
+
+    def __init__(self, controller, device):
+        """Initialize a sensor for Abode device."""
+        self._controller = controller
+        self._device = device
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        self.hass.async_add_job(
+            self._controller.register, self._device,
+            self._update_callback
+        )
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._device.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._device.device_id,
+            'battery_low': self._device.battery_low,
+            'no_response': self._device.no_response
+        }
+
+    def _update_callback(self, device):
+        """Update the device state."""
+        self.schedule_update_ha_state()
@@ -13,8 +13,10 @@ import voluptuous as vol

 from homeassistant.const import (
    ATTR_CODE, ATTR_CODE_FORMAT, ATTR_ENTITY_ID, SERVICE_ALARM_TRIGGER,
-    SERVICE_ALARM_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY)
+    SERVICE_ALARM_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY,
+    SERVICE_ALARM_ARM_NIGHT)
 from homeassistant.config import load_yaml_config_file
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import Entity
@@ -30,6 +32,7 @@ SERVICE_TO_METHOD = {
    SERVICE_ALARM_DISARM: 'alarm_disarm',
    SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
    SERVICE_ALARM_ARM_AWAY: 'alarm_arm_away',
+    SERVICE_ALARM_ARM_NIGHT: 'alarm_arm_night',
    SERVICE_ALARM_TRIGGER: 'alarm_trigger'
 }

@@ -44,6 +47,7 @@ ALARM_SERVICE_SCHEMA = vol.Schema({
 })


+@bind_hass
 def alarm_disarm(hass, code=None, entity_id=None):
    """Send the alarm the command for disarm."""
    data = {}
@@ -55,6 +59,7 @@ def alarm_disarm(hass, code=None, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_ALARM_DISARM, data)


+@bind_hass
 def alarm_arm_home(hass, code=None, entity_id=None):
    """Send the alarm the command for arm home."""
    data = {}
@@ -66,6 +71,7 @@ def alarm_arm_home(hass, code=None, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_HOME, data)


+@bind_hass
 def alarm_arm_away(hass, code=None, entity_id=None):
    """Send the alarm the command for arm away."""
    data = {}
@@ -77,6 +83,19 @@ def alarm_arm_away(hass, code=None, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_AWAY, data)


+@bind_hass
+def alarm_arm_night(hass, code=None, entity_id=None):
+    """Send the alarm the command for arm night."""
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_NIGHT, data)
+
+
+@bind_hass
 def alarm_trigger(hass, code=None, entity_id=None):
    """Send the alarm the command for trigger."""
    data = {}
@@ -182,6 +201,17 @@ class AlarmControlPanel(Entity):
        """
        return self.hass.async_add_job(self.alarm_arm_away, code)

+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        raise NotImplementedError()
+
+    def async_alarm_arm_night(self, code=None):
+        """Send arm night command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.async_add_job(self.alarm_arm_night, code)
+
    def alarm_trigger(self, code=None):
        """Send alarm trigger command."""
        raise NotImplementedError()
@@ -0,0 +1,76 @@
+"""
+This component provides HA alarm_control_panel support for Abode System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.abode/
+"""
+import logging
+
+from homeassistant.components.abode import (
+    AbodeDevice, DATA_ABODE, DEFAULT_NAME, CONF_ATTRIBUTION)
+from homeassistant.components.alarm_control_panel import (AlarmControlPanel)
+from homeassistant.const import (ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY,
+                                 STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED)
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+ICON = 'mdi:security'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for an Abode device."""
+    abode = hass.data[DATA_ABODE]
+
+    add_devices([AbodeAlarm(abode, abode.get_alarm())])
+
+
+class AbodeAlarm(AbodeDevice, AlarmControlPanel):
+    """An alarm_control_panel implementation for Abode."""
+
+    def __init__(self, controller, device):
+        """Initialize the alarm control panel."""
+        AbodeDevice.__init__(self, controller, device)
+        self._name = "{0}".format(DEFAULT_NAME)
+
+    @property
+    def icon(self):
+        """Return icon."""
+        return ICON
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._device.is_standby:
+            state = STATE_ALARM_DISARMED
+        elif self._device.is_away:
+            state = STATE_ALARM_ARMED_AWAY
+        elif self._device.is_home:
+            state = STATE_ALARM_ARMED_HOME
+        else:
+            state = None
+        return state
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self._device.set_standby()
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        self._device.set_home()
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self._device.set_away()
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._device.device_id,
+            'battery_backup': self._device.battery,
+            'cellular_backup': self._device.is_cellular
+        }
@@ -0,0 +1,183 @@
+"""
+Interfaces with Egardia/Woonveilig alarm control panel.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.egardia/
+"""
+import logging
+
+import requests
+import voluptuous as vol
+
+import homeassistant.components.alarm_control_panel as alarm
+import homeassistant.exceptions as exc
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
+from homeassistant.const import (
+    CONF_PORT, CONF_HOST, CONF_PASSWORD, CONF_USERNAME, STATE_UNKNOWN,
+    CONF_NAME, STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_TRIGGERED)
+
+REQUIREMENTS = ['pythonegardia==1.0.20']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_REPORT_SERVER_CODES = 'report_server_codes'
+CONF_REPORT_SERVER_ENABLED = 'report_server_enabled'
+CONF_REPORT_SERVER_PORT = 'report_server_port'
+
+DEFAULT_NAME = 'Egardia'
+DEFAULT_PORT = 80
+DEFAULT_REPORT_SERVER_ENABLED = False
+DEFAULT_REPORT_SERVER_PORT = 52010
+DOMAIN = 'egardia'
+
+NOTIFICATION_ID = 'egardia_notification'
+NOTIFICATION_TITLE = 'Egardia'
+
+STATES = {
+    'ARM': STATE_ALARM_ARMED_AWAY,
+    'DAY HOME': STATE_ALARM_ARMED_HOME,
+    'DISARM': STATE_ALARM_DISARMED,
+    'HOME': STATE_ALARM_ARMED_HOME,
+    'TRIGGERED': STATE_ALARM_TRIGGERED,
+    'UNKNOWN': STATE_UNKNOWN,
+}
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_REPORT_SERVER_CODES): vol.All(cv.ensure_list),
+    vol.Optional(CONF_REPORT_SERVER_ENABLED,
+                 default=DEFAULT_REPORT_SERVER_ENABLED): cv.boolean,
+    vol.Optional(CONF_REPORT_SERVER_PORT, default=DEFAULT_REPORT_SERVER_PORT):
+        cv.port,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Egardia platform."""
+    from pythonegardia import egardiadevice
+
+    name = config.get(CONF_NAME)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    rs_enabled = config.get(CONF_REPORT_SERVER_ENABLED)
+    rs_port = config.get(CONF_REPORT_SERVER_PORT)
+    rs_codes = config.get(CONF_REPORT_SERVER_CODES)
+
+    try:
+        egardiasystem = egardiadevice.EgardiaDevice(
+            host, port, username, password, '')
+    except requests.exceptions.RequestException:
+        raise exc.PlatformNotReady()
+    except egardiadevice.UnauthorizedError:
+        _LOGGER.error("Unable to authorize. Wrong password or username")
+        return False
+
+    add_devices([EgardiaAlarm(
+        name, egardiasystem, hass, rs_enabled, rs_port, rs_codes)], True)
+
+
+class EgardiaAlarm(alarm.AlarmControlPanel):
+    """Representation of a Egardia alarm."""
+
+    def __init__(self, name, egardiasystem, hass, rs_enabled=False,
+                 rs_port=None, rs_codes=None):
+        """Initialize object."""
+        self._name = name
+        self._egardiasystem = egardiasystem
+        self._status = STATE_UNKNOWN
+        self._rs_enabled = rs_enabled
+        self._rs_port = rs_port
+        self._hass = hass
+
+        if rs_codes is not None:
+            self._rs_codes = rs_codes[0]
+        else:
+            self._rs_codes = rs_codes
+
+        if self._rs_enabled:
+            self.listen_to_system_status()
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._status
+
+    def handle_system_status_event(self, event):
+        """Handle egardia_system_status_event."""
+        if event.data.get('status') is not None:
+            statuscode = event.data.get('status')
+            status = self.lookupstatusfromcode(statuscode)
+            self.parsestatus(status)
+
+    def listen_to_system_status(self):
+        """Subscribe to egardia_system_status event."""
+        self._hass.bus.listen(
+            'egardia_system_status', self.handle_system_status_event)
+
+    def lookupstatusfromcode(self, statuscode):
+        """Look at the rs_codes and returns the status from the code."""
+        status = 'UNKNOWN'
+        if self._rs_codes is not None:
+            statuscode = str(statuscode).strip()
+            for i in self._rs_codes:
+                val = str(self._rs_codes[i]).strip()
+                if ',' in val:
+                    splitted = val.split(',')
+                    for code in splitted:
+                        code = str(code).strip()
+                        if statuscode == code:
+                            status = i.upper()
+                            break
+                elif statuscode == val:
+                    status = i.upper()
+                    break
+        return status
+
+    def parsestatus(self, status):
+        """Parse the status."""
+        newstatus = ([v for k, v in STATES.items()
+                      if status.upper() == k][0])
+        self._status = newstatus
+
+    def update(self):
+        """Update the alarm status."""
+        if not self._rs_enabled:
+            status = self._egardiasystem.getstate()
+            self.parsestatus(status)
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        try:
+            self._egardiasystem.alarm_disarm()
+        except requests.exceptions.RequestException as err:
+            _LOGGER.error("Egardia device exception occurred when "
+                          "sending disarm command: %s", err)
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        try:
+            self._egardiasystem.alarm_arm_home()
+        except requests.exceptions.RequestException as err:
+            _LOGGER.error("Egardia device exception occurred when "
+                          "sending arm home command: %s", err)
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        try:
+            self._egardiasystem.alarm_arm_away()
+        except requests.exceptions.RequestException as err:
+            _LOGGER.error("Egardia device exception occurred when "
+                          "sending arm away command: %s", err)
@@ -12,9 +12,10 @@ import voluptuous as vol
 import homeassistant.components.alarm_control_panel as alarm
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
-    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
-    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, CONF_PLATFORM, CONF_NAME,
-    CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME, CONF_DISARM_AFTER_TRIGGER)
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_DISARMED, STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED,
+    CONF_PLATFORM, CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
+    CONF_DISARM_AFTER_TRIGGER)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import track_point_in_time

@@ -23,6 +24,8 @@ DEFAULT_PENDING_TIME = 60
 DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False

+ATTR_POST_PENDING_STATE = 'post_pending_state'
+
 PLATFORM_SCHEMA = vol.Schema({
    vol.Required(CONF_PLATFORM): 'manual',
    vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
@@ -87,7 +90,8 @@ class ManualAlarm(alarm.AlarmControlPanel):
    def state(self):
        """Return the state of the device."""
        if self._state in (STATE_ALARM_ARMED_HOME,
-                           STATE_ALARM_ARMED_AWAY) and \
+                           STATE_ALARM_ARMED_AWAY,
+                           STATE_ALARM_ARMED_NIGHT) and \
           self._pending_time and self._state_ts + self._pending_time > \
           dt_util.utcnow():
            return STATE_ALARM_PENDING
@@ -99,7 +103,9 @@ class ManualAlarm(alarm.AlarmControlPanel):
                  self._trigger_time) < dt_util.utcnow():
                if self._disarm_after_trigger:
                    return STATE_ALARM_DISARMED
-                return self._pre_trigger_state
+                else:
+                    self._state = self._pre_trigger_state
+                    return self._state

        return self._state

@@ -145,6 +151,20 @@ class ManualAlarm(alarm.AlarmControlPanel):
                self._hass, self.async_update_ha_state,
                self._state_ts + self._pending_time)

+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_NIGHT):
+            return
+
+        self._state = STATE_ALARM_ARMED_NIGHT
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+        if self._pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time)
+
    def alarm_trigger(self, code=None):
        """Send alarm trigger command. No code needed."""
        self._pre_trigger_state = self._state
@@ -167,3 +187,13 @@ class ManualAlarm(alarm.AlarmControlPanel):
        if not check:
            _LOGGER.warning("Invalid code given for %s", state)
        return check
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        state_attr = {}
+
+        if self.state == STATE_ALARM_PENDING:
+            state_attr[ATTR_POST_PENDING_STATE] = self._state
+
+        return state_attr
@@ -0,0 +1,235 @@
+"""
+Support for manual alarms controllable via MQTT.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.manual_mqtt/
+"""
+import asyncio
+import datetime
+import logging
+
+import voluptuous as vol
+
+import homeassistant.components.alarm_control_panel as alarm
+import homeassistant.util.dt as dt_util
+from homeassistant.const import (
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
+    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, CONF_PLATFORM,
+    CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
+    CONF_DISARM_AFTER_TRIGGER)
+import homeassistant.components.mqtt as mqtt
+
+from homeassistant.helpers.event import async_track_state_change
+from homeassistant.core import callback
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.event import track_point_in_time
+
+CONF_PAYLOAD_DISARM = 'payload_disarm'
+CONF_PAYLOAD_ARM_HOME = 'payload_arm_home'
+CONF_PAYLOAD_ARM_AWAY = 'payload_arm_away'
+
+DEFAULT_ALARM_NAME = 'HA Alarm'
+DEFAULT_PENDING_TIME = 60
+DEFAULT_TRIGGER_TIME = 120
+DEFAULT_DISARM_AFTER_TRIGGER = False
+DEFAULT_ARM_AWAY = 'ARM_AWAY'
+DEFAULT_ARM_HOME = 'ARM_HOME'
+DEFAULT_DISARM = 'DISARM'
+
+DEPENDENCIES = ['mqtt']
+
+PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PLATFORM): 'manual_mqtt',
+    vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
+    vol.Optional(CONF_CODE): cv.string,
+    vol.Optional(CONF_PENDING_TIME, default=DEFAULT_PENDING_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=0)),
+    vol.Optional(CONF_TRIGGER_TIME, default=DEFAULT_TRIGGER_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+    vol.Optional(CONF_DISARM_AFTER_TRIGGER,
+                 default=DEFAULT_DISARM_AFTER_TRIGGER): cv.boolean,
+    vol.Required(mqtt.CONF_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Required(mqtt.CONF_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_PAYLOAD_ARM_AWAY, default=DEFAULT_ARM_AWAY): cv.string,
+    vol.Optional(CONF_PAYLOAD_ARM_HOME, default=DEFAULT_ARM_HOME): cv.string,
+    vol.Optional(CONF_PAYLOAD_DISARM, default=DEFAULT_DISARM): cv.string,
+})
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the manual MQTT alarm platform."""
+    add_devices([ManualMQTTAlarm(
+        hass,
+        config[CONF_NAME],
+        config.get(CONF_CODE),
+        config.get(CONF_PENDING_TIME, DEFAULT_PENDING_TIME),
+        config.get(CONF_TRIGGER_TIME, DEFAULT_TRIGGER_TIME),
+        config.get(CONF_DISARM_AFTER_TRIGGER, DEFAULT_DISARM_AFTER_TRIGGER),
+        config.get(mqtt.CONF_STATE_TOPIC),
+        config.get(mqtt.CONF_COMMAND_TOPIC),
+        config.get(mqtt.CONF_QOS),
+        config.get(CONF_PAYLOAD_DISARM),
+        config.get(CONF_PAYLOAD_ARM_HOME),
+        config.get(CONF_PAYLOAD_ARM_AWAY))])
+
+
+class ManualMQTTAlarm(alarm.AlarmControlPanel):
+    """
+    Representation of an alarm status.
+
+    When armed, will be pending for 'pending_time', after that armed.
+    When triggered, will be pending for 'trigger_time'. After that will be
+    triggered for 'trigger_time', after that we return to the previous state
+    or disarm if `disarm_after_trigger` is true.
+    """
+
+    def __init__(self, hass, name, code, pending_time,
+                 trigger_time, disarm_after_trigger,
+                 state_topic, command_topic, qos,
+                 payload_disarm, payload_arm_home, payload_arm_away):
+        """Init the manual MQTT alarm panel."""
+        self._state = STATE_ALARM_DISARMED
+        self._hass = hass
+        self._name = name
+        self._code = str(code) if code else None
+        self._pending_time = datetime.timedelta(seconds=pending_time)
+        self._trigger_time = datetime.timedelta(seconds=trigger_time)
+        self._disarm_after_trigger = disarm_after_trigger
+        self._pre_trigger_state = self._state
+        self._state_ts = None
+
+        self._state_topic = state_topic
+        self._command_topic = command_topic
+        self._qos = qos
+        self._payload_disarm = payload_disarm
+        self._payload_arm_home = payload_arm_home
+        self._payload_arm_away = payload_arm_away
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._state in (STATE_ALARM_ARMED_HOME,
+                           STATE_ALARM_ARMED_AWAY) and \
+           self._pending_time and self._state_ts + self._pending_time > \
+           dt_util.utcnow():
+            return STATE_ALARM_PENDING
+
+        if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
+            if self._state_ts + self._pending_time > dt_util.utcnow():
+                return STATE_ALARM_PENDING
+            elif (self._state_ts + self._pending_time +
+                  self._trigger_time) < dt_util.utcnow():
+                if self._disarm_after_trigger:
+                    return STATE_ALARM_DISARMED
+                return self._pre_trigger_state
+
+        return self._state
+
+    @property
+    def code_format(self):
+        """One or more characters."""
+        return None if self._code is None else '.+'
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        if not self._validate_code(code, STATE_ALARM_DISARMED):
+            return
+
+        self._state = STATE_ALARM_DISARMED
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
+            return
+
+        self._state = STATE_ALARM_ARMED_HOME
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+        if self._pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time)
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
+            return
+
+        self._state = STATE_ALARM_ARMED_AWAY
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+        if self._pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time)
+
+    def alarm_trigger(self, code=None):
+        """Send alarm trigger command. No code needed."""
+        self._pre_trigger_state = self._state
+        self._state = STATE_ALARM_TRIGGERED
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+        if self._trigger_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time)
+
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time + self._trigger_time)
+
+    def _validate_code(self, code, state):
+        """Validate given code."""
+        check = self._code is None or code == self._code
+        if not check:
+            _LOGGER.warning("Invalid code given for %s", state)
+        return check
+
+    def async_added_to_hass(self):
+        """Subscribe mqtt events.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        async_track_state_change(
+            self.hass, self.entity_id, self._async_state_changed_listener
+        )
+
+        @callback
+        def message_received(topic, payload, qos):
+            """Run when new MQTT message has been received."""
+            if payload == self._payload_disarm:
+                self.async_alarm_disarm(self._code)
+            elif payload == self._payload_arm_home:
+                self.async_alarm_arm_home(self._code)
+            elif payload == self._payload_arm_away:
+                self.async_alarm_arm_away(self._code)
+            else:
+                _LOGGER.warning("Received unexpected payload: %s", payload)
+                return
+
+        return mqtt.async_subscribe(
+            self.hass, self._command_topic, message_received, self._qos)
+
+    @asyncio.coroutine
+    def _async_state_changed_listener(self, entity_id, old_state, new_state):
+        """Publish state change to MQTT."""
+        mqtt.async_publish(self.hass, self._state_topic, new_state.state,
+                           self._qos, True)
@@ -31,6 +31,17 @@ alarm_arm_away:
      description: An optional code to arm away the alarm control panel with
      example: 1234

+alarm_arm_night:
+  description: Send the alarm the command for arm night
+
+  fields:
+    entity_id:
+      description: Name of alarm control panel to arm night
+      example: 'alarm_control_panel.downstairs'
+    code:
+      description: An optional code to arm night the alarm control panel with
+      example: 1234
+
 alarm_trigger:
  description: Send the alarm the command for trigger

@@ -15,9 +15,8 @@ from homeassistant.const import (
    STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY,
    EVENT_HOMEASSISTANT_STOP)
 import homeassistant.helpers.config_validation as cv
-import homeassistant.loader as loader

-REQUIREMENTS = ['simplisafe-python==1.0.2']
+REQUIREMENTS = ['simplisafe-python==1.0.5']

 _LOGGER = logging.getLogger(__name__)

@@ -42,7 +41,6 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)

-    persistent_notification = loader.get_component('persistent_notification')
    simplisafe = SimpliSafeApiInterface()
    status = simplisafe.set_credentials(username, password)
    if status:
@@ -53,8 +51,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    else:
        message = 'Failed to log into SimpliSafe. Check credentials.'
        _LOGGER.error(message)
-        persistent_notification.create(
-            hass, message,
+        hass.components.persistent_notification.create(
+            message,
            title=NOTIFICATION_TITLE,
            notification_id=NOTIFICATION_ID)
        return False
@@ -91,11 +89,11 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
    def state(self):
        """Return the state of the device."""
        status = self.simplisafe.state()
-        if status == 'Off':
+        if status == 'off':
            state = STATE_ALARM_DISARMED
-        elif status == 'Home':
+        elif status == 'home':
            state = STATE_ALARM_ARMED_HOME
-        elif status == 'Away':
+        elif status == 'away':
            state = STATE_ALARM_ARMED_AWAY
        else:
            state = STATE_UNKNOWN
@@ -13,8 +13,8 @@ import homeassistant.components.alarm_control_panel as alarm
 from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
 from homeassistant.const import (
    CONF_PASSWORD, CONF_USERNAME, STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED, STATE_UNKNOWN,
-    CONF_NAME)
+    STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED,
+    STATE_ALARM_ARMING, STATE_ALARM_DISARMING, STATE_UNKNOWN, CONF_NAME)

 REQUIREMENTS = ['total_connect_client==0.11']

@@ -74,6 +74,12 @@ class TotalConnect(alarm.AlarmControlPanel):
            state = STATE_ALARM_ARMED_HOME
        elif status == self._client.ARMED_AWAY:
            state = STATE_ALARM_ARMED_AWAY
+        elif status == self._client.ARMED_STAY_NIGHT:
+            state = STATE_ALARM_ARMED_NIGHT
+        elif status == self._client.ARMING:
+            state = STATE_ALARM_ARMING
+        elif status == self._client.DISARMING:
+            state = STATE_ALARM_DISARMING
        else:
            state = STATE_UNKNOWN

@@ -90,3 +96,7 @@ class TotalConnect(alarm.AlarmControlPanel):
    def alarm_arm_away(self, code=None):
        """Send arm away command."""
        self._client.arm_away()
+
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        self._client.arm_stay_night()
@@ -15,7 +15,7 @@ from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.helpers.discovery import async_load_platform
 from homeassistant.helpers.dispatcher import async_dispatcher_send

-REQUIREMENTS = ['alarmdecoder==0.12.1.0']
+REQUIREMENTS = ['alarmdecoder==0.12.3']

 _LOGGER = logging.getLogger(__name__)

@@ -15,8 +15,8 @@ import voluptuous as vol

 from homeassistant.core import callback
 from homeassistant.const import HTTP_BAD_REQUEST
-from homeassistant.helpers import template, script, config_validation as cv
-from homeassistant.components.http import HomeAssistantView
+from homeassistant.helpers import intent, template, config_validation as cv
+from homeassistant.components import http

 _LOGGER = logging.getLogger(__name__)

@@ -60,6 +60,12 @@ class SpeechType(enum.Enum):
    ssml = "SSML"


+SPEECH_MAPPINGS = {
+    'plain': SpeechType.plaintext,
+    'ssml': SpeechType.ssml,
+}
+
+
 class CardType(enum.Enum):
    """The Alexa card types."""

@@ -69,20 +75,6 @@ class CardType(enum.Enum):

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: {
-        CONF_INTENTS: {
-            cv.string: {
-                vol.Optional(CONF_ACTION): cv.SCRIPT_SCHEMA,
-                vol.Optional(CONF_CARD): {
-                    vol.Required(CONF_TYPE): cv.enum(CardType),
-                    vol.Required(CONF_TITLE): cv.template,
-                    vol.Required(CONF_CONTENT): cv.template,
-                },
-                vol.Optional(CONF_SPEECH): {
-                    vol.Required(CONF_TYPE): cv.enum(SpeechType),
-                    vol.Required(CONF_TEXT): cv.template,
-                }
-            }
-        },
        CONF_FLASH_BRIEFINGS: {
            cv.string: vol.All(cv.ensure_list, [{
                vol.Required(CONF_UID, default=str(uuid.uuid4())): cv.string,
@@ -96,40 +88,27 @@ CONFIG_SCHEMA = vol.Schema({
 }, extra=vol.ALLOW_EXTRA)


-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
    """Activate Alexa component."""
-    intents = config[DOMAIN].get(CONF_INTENTS, {})
    flash_briefings = config[DOMAIN].get(CONF_FLASH_BRIEFINGS, {})

-    hass.http.register_view(AlexaIntentsView(hass, intents))
+    hass.http.register_view(AlexaIntentsView)
    hass.http.register_view(AlexaFlashBriefingView(hass, flash_briefings))

    return True


-class AlexaIntentsView(HomeAssistantView):
+class AlexaIntentsView(http.HomeAssistantView):
    """Handle Alexa requests."""

    url = INTENTS_API_ENDPOINT
    name = 'api:alexa'

-    def __init__(self, hass, intents):
-        """Initialize Alexa view."""
-        super().__init__()
-
-        intents = copy.deepcopy(intents)
-        template.attach(hass, intents)
-
-        for name, intent in intents.items():
-            if CONF_ACTION in intent:
-                intent[CONF_ACTION] = script.Script(
-                    hass, intent[CONF_ACTION], "Alexa intent {}".format(name))
-
-        self.intents = intents
-
    @asyncio.coroutine
    def post(self, request):
        """Handle Alexa."""
+        hass = request.app['hass']
        data = yield from request.json()

        _LOGGER.debug('Received Alexa request: %s', data)
@@ -146,53 +125,61 @@ class AlexaIntentsView(HomeAssistantView):
        if req_type == 'SessionEndedRequest':
            return None

-        intent = req.get('intent')
-        response = AlexaResponse(request.app['hass'], intent)
+        alexa_intent_info = req.get('intent')
+        alexa_response = AlexaResponse(hass, alexa_intent_info)

-        if req_type == 'LaunchRequest':
-            response.add_speech(
-                SpeechType.plaintext,
-                "Hello, and welcome to the future. How may I help?")
-            return self.json(response)
-
-        if req_type != 'IntentRequest':
+        if req_type != 'IntentRequest' and req_type != 'LaunchRequest':
            _LOGGER.warning('Received unsupported request: %s', req_type)
            return self.json_message(
                'Received unsupported request: {}'.format(req_type),
                HTTP_BAD_REQUEST)

-        intent_name = intent['name']
-        config = self.intents.get(intent_name)
+        if req_type == 'LaunchRequest':
+            intent_name = data.get('session', {})       \
+                              .get('application', {})   \
+                              .get('applicationId')
+        else:
+            intent_name = alexa_intent_info['name']

-        if config is None:
+        try:
+            intent_response = yield from intent.async_handle(
+                hass, DOMAIN, intent_name,
+                {key: {'value': value} for key, value
+                 in alexa_response.variables.items()})
+        except intent.UnknownIntent as err:
            _LOGGER.warning('Received unknown intent %s', intent_name)
-            response.add_speech(
+            alexa_response.add_speech(
                SpeechType.plaintext,
                "This intent is not yet configured within Home Assistant.")
-            return self.json(response)
+            return self.json(alexa_response)

-        speech = config.get(CONF_SPEECH)
-        card = config.get(CONF_CARD)
-        action = config.get(CONF_ACTION)
+        except intent.InvalidSlotInfo as err:
+            _LOGGER.error('Received invalid slot data from Alexa: %s', err)
+            return self.json_message('Invalid slot data received',
+                                     HTTP_BAD_REQUEST)
+        except intent.IntentError:
+            _LOGGER.exception('Error handling request for %s', intent_name)
+            return self.json_message('Error handling intent', HTTP_BAD_REQUEST)

-        if action is not None:
-            yield from action.async_run(response.variables)
+        for intent_speech, alexa_speech in SPEECH_MAPPINGS.items():
+            if intent_speech in intent_response.speech:
+                alexa_response.add_speech(
+                    alexa_speech,
+                    intent_response.speech[intent_speech]['speech'])
+                break

-        # pylint: disable=unsubscriptable-object
-        if speech is not None:
-            response.add_speech(speech[CONF_TYPE], speech[CONF_TEXT])
+        if 'simple' in intent_response.card:
+            alexa_response.add_card(
+                CardType.simple, intent_response.card['simple']['title'],
+                intent_response.card['simple']['content'])

-        if card is not None:
-            response.add_card(card[CONF_TYPE], card[CONF_TITLE],
-                              card[CONF_CONTENT])
-
-        return self.json(response)
+        return self.json(alexa_response)


 class AlexaResponse(object):
    """Help generating the response for Alexa."""

-    def __init__(self, hass, intent=None):
+    def __init__(self, hass, intent_info):
        """Initialize the response."""
        self.hass = hass
        self.speech = None
@@ -201,8 +188,9 @@ class AlexaResponse(object):
        self.session_attributes = {}
        self.should_end_session = True
        self.variables = {}
-        if intent is not None and 'slots' in intent:
-            for key, value in intent['slots'].items():
+        # Intent is None if request was a LaunchRequest or SessionEndedRequest
+        if intent_info is not None:
+            for key, value in intent_info.get('slots', {}).items():
                if 'value' in value:
                    underscored_key = key.replace('.', '_')
                    self.variables[underscored_key] = value['value']
@@ -219,8 +207,8 @@ class AlexaResponse(object):
            self.card = card
            return

-        card["title"] = title.async_render(self.variables)
-        card["content"] = content.async_render(self.variables)
+        card["title"] = title
+        card["content"] = content
        self.card = card

    def add_speech(self, speech_type, text):
@@ -229,9 +217,6 @@ class AlexaResponse(object):

        key = 'ssml' if speech_type == SpeechType.ssml else 'text'

-        if isinstance(text, template.Template):
-            text = text.async_render(self.variables)
-
        self.speech = {
            'type': speech_type.value,
            key: text
@@ -272,7 +257,7 @@ class AlexaResponse(object):
        }


-class AlexaFlashBriefingView(HomeAssistantView):
+class AlexaFlashBriefingView(http.HomeAssistantView):
    """Handle Alexa Flash Briefing skill requests."""

    url = FLASH_BRIEFINGS_API_ENDPOINT
@@ -11,14 +11,13 @@ import aiohttp
 import voluptuous as vol
 from requests.exceptions import HTTPError, ConnectTimeout

-import homeassistant.loader as loader
 from homeassistant.const import (
    CONF_NAME, CONF_HOST, CONF_PORT, CONF_USERNAME, CONF_PASSWORD,
    CONF_SENSORS, CONF_SCAN_INTERVAL, HTTP_BASIC_AUTHENTICATION)
 from homeassistant.helpers import discovery
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['amcrest==1.2.0']
+REQUIREMENTS = ['amcrest==1.2.1']
 DEPENDENCIES = ['ffmpeg']

 _LOGGER = logging.getLogger(__name__)
@@ -92,7 +91,6 @@ def setup(hass, config):

    amcrest_cams = config[DOMAIN]

-    persistent_notification = loader.get_component('persistent_notification')
    for device in amcrest_cams:
        camera = AmcrestCamera(device.get(CONF_HOST),
                               device.get(CONF_PORT),
@@ -103,8 +101,8 @@ def setup(hass, config):

        except (ConnectTimeout, HTTPError) as ex:
            _LOGGER.error("Unable to connect to Amcrest camera: %s", str(ex))
-            persistent_notification.create(
-                hass, 'Error: {}<br />'
+            hass.components.persistent_notification.create(
+                'Error: {}<br />'
                'You will need to restart hass after fixing.'
                ''.format(ex),
                title=NOTIFICATION_TITLE,
@@ -5,13 +5,12 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/apiai/
 """
 import asyncio
-import copy
 import logging

 import voluptuous as vol

 from homeassistant.const import PROJECT_NAME, HTTP_BAD_REQUEST
-from homeassistant.helpers import template, script, config_validation as cv
+from homeassistant.helpers import intent, template
 from homeassistant.components.http import HomeAssistantView

 _LOGGER = logging.getLogger(__name__)
@@ -29,24 +28,14 @@ DOMAIN = 'apiai'
 DEPENDENCIES = ['http']

 CONFIG_SCHEMA = vol.Schema({
-    DOMAIN: {
-        CONF_INTENTS: {
-            cv.string: {
-                vol.Optional(CONF_SPEECH): cv.template,
-                vol.Optional(CONF_ACTION): cv.SCRIPT_SCHEMA,
-                vol.Optional(CONF_ASYNC_ACTION,
-                             default=DEFAULT_CONF_ASYNC_ACTION): cv.boolean
-            }
-        }
-    }
+    DOMAIN: {}
 }, extra=vol.ALLOW_EXTRA)


-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
    """Activate API.AI component."""
-    intents = config[DOMAIN].get(CONF_INTENTS, {})
-
-    hass.http.register_view(ApiaiIntentsView(hass, intents))
+    hass.http.register_view(ApiaiIntentsView)

    return True

@@ -57,24 +46,10 @@ class ApiaiIntentsView(HomeAssistantView):
    url = INTENTS_API_ENDPOINT
    name = 'api:apiai'

-    def __init__(self, hass, intents):
-        """Initialize API.AI view."""
-        super().__init__()
-
-        self.hass = hass
-        intents = copy.deepcopy(intents)
-        template.attach(hass, intents)
-
-        for name, intent in intents.items():
-            if CONF_ACTION in intent:
-                intent[CONF_ACTION] = script.Script(
-                    hass, intent[CONF_ACTION], "Apiai intent {}".format(name))
-
-        self.intents = intents
-
    @asyncio.coroutine
    def post(self, request):
        """Handle API.AI."""
+        hass = request.app['hass']
        data = yield from request.json()

        _LOGGER.debug("Received api.ai request: %s", data)
@@ -91,55 +66,41 @@ class ApiaiIntentsView(HomeAssistantView):
        if action_incomplete:
            return None

-        # use intent to no mix HASS actions with this parameter
-        intent = req.get('action')
+        action = req.get('action')
        parameters = req.get('parameters')
-        # contexts = req.get('contexts')
-        response = ApiaiResponse(parameters)
+        apiai_response = ApiaiResponse(parameters)

-        # Default Welcome Intent
-        # Maybe is better to handle this in api.ai directly?
-        #
-        # if intent == 'input.welcome':
-        #     response.add_speech(
-        #     "Hello, and welcome to the future. How may I help?")
-        #     return self.json(response)
-
-        if intent == "":
+        if action == "":
            _LOGGER.warning("Received intent with empty action")
-            response.add_speech(
+            apiai_response.add_speech(
                "You have not defined an action in your api.ai intent.")
-            return self.json(response)
+            return self.json(apiai_response)

-        config = self.intents.get(intent)
+        try:
+            intent_response = yield from intent.async_handle(
+                hass, DOMAIN, action,
+                {key: {'value': value} for key, value
+                 in parameters.items()})

-        if config is None:
-            _LOGGER.warning("Received unknown intent %s", intent)
-            response.add_speech(
-                "Intent '%s' is not yet configured within Home Assistant." %
-                intent)
-            return self.json(response)
+        except intent.UnknownIntent as err:
+            _LOGGER.warning('Received unknown intent %s', action)
+            apiai_response.add_speech(
+                "This intent is not yet configured within Home Assistant.")
+            return self.json(apiai_response)

-        speech = config.get(CONF_SPEECH)
-        action = config.get(CONF_ACTION)
-        async_action = config.get(CONF_ASYNC_ACTION)
+        except intent.InvalidSlotInfo as err:
+            _LOGGER.error('Received invalid slot data: %s', err)
+            return self.json_message('Invalid slot data received',
+                                     HTTP_BAD_REQUEST)
+        except intent.IntentError:
+            _LOGGER.exception('Error handling request for %s', action)
+            return self.json_message('Error handling intent', HTTP_BAD_REQUEST)

-        if action is not None:
-            # API.AI expects a response in less than 5s
-            if async_action:
-                # Do not wait for the action to be executed.
-                # Needed if the action will take longer than 5s to execute
-                self.hass.async_add_job(action.async_run(response.parameters))
-            else:
-                # Wait for the action to be executed so we can use results to
-                # render the answer
-                yield from action.async_run(response.parameters)
+        if 'plain' in intent_response.speech:
+            apiai_response.add_speech(
+                intent_response.speech['plain']['speech'])

-        # pylint: disable=unsubscriptable-object
-        if speech is not None:
-            response.add_speech(speech)
-
-        return self.json(response)
+        return self.json(apiai_response)


 class ApiaiResponse(object):
@@ -15,10 +15,9 @@ from homeassistant.config import load_yaml_config_file
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers import discovery
 from homeassistant.components.discovery import SERVICE_APPLE_TV
-from homeassistant.loader import get_component
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['pyatv==0.3.2']
+REQUIREMENTS = ['pyatv==0.3.4']

 _LOGGER = logging.getLogger(__name__)

@@ -66,27 +65,24 @@ APPLE_TV_AUTHENTICATE_SCHEMA = vol.Schema({

 def request_configuration(hass, config, atv, credentials):
    """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator

    @asyncio.coroutine
    def configuration_callback(callback_data):
        """Handle the submitted configuration."""
        from pyatv import exceptions
        pin = callback_data.get('pin')
-        notification = get_component('persistent_notification')

        try:
            yield from atv.airplay.finish_authentication(pin)
-            notification.async_create(
-                hass,
+            hass.components.persistent_notification.async_create(
                'Authentication succeeded!<br /><br />Add the following '
                'to credentials: in your apple_tv configuration:<br /><br />'
                '{0}'.format(credentials),
                title=NOTIFICATION_AUTH_TITLE,
                notification_id=NOTIFICATION_AUTH_ID)
        except exceptions.DeviceAuthenticationError as ex:
-            notification.async_create(
-                hass,
+            hass.components.persistent_notification.async_create(
                'Authentication failed! Did you enter correct PIN?<br /><br />'
                'Details: {0}'.format(ex),
                title=NOTIFICATION_AUTH_TITLE,
@@ -95,7 +91,7 @@ def request_configuration(hass, config, atv, credentials):
        hass.async_add_job(configurator.request_done, instance)

    instance = configurator.request_config(
-        hass, 'Apple TV Authentication', configuration_callback,
+        'Apple TV Authentication', configuration_callback,
        description='Please enter PIN code shown on screen.',
        submit_caption='Confirm',
        fields=[{'id': 'pin', 'name': 'PIN Code', 'type': 'password'}]
@@ -119,9 +115,7 @@ def scan_for_apple_tvs(hass):
    if not devices:
        devices = ['No device(s) found']

-    notification = get_component('persistent_notification')
-    notification.async_create(
-        hass,
+    hass.components.persistent_notification.async_create(
        'The following devices were found:<br /><br />' +
        '<br /><br />'.join(devices),
        title=NOTIFICATION_SCAN_TITLE,
@@ -9,7 +9,6 @@ import logging
 import voluptuous as vol
 from requests.exceptions import HTTPError, ConnectTimeout

-import homeassistant.loader as loader
 from homeassistant.helpers import config_validation as cv
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD

@@ -40,7 +39,6 @@ def setup(hass, config):
    username = conf.get(CONF_USERNAME)
    password = conf.get(CONF_PASSWORD)

-    persistent_notification = loader.get_component('persistent_notification')
    try:
        from pyarlo import PyArlo

@@ -50,8 +48,8 @@ def setup(hass, config):
        hass.data[DATA_ARLO] = arlo
    except (ConnectTimeout, HTTPError) as ex:
        _LOGGER.error("Unable to connect to Netgar Arlo: %s", str(ex))
-        persistent_notification.create(
-            hass, 'Error: {}<br />'
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
            'You will need to restart hass after fixing.'
            ''.format(ex),
            title=NOTIFICATION_TITLE,
@@ -0,0 +1,82 @@
+"""Support for Asterisk Voicemail interface."""
+
+import logging
+
+import voluptuous as vol
+
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import discovery
+from homeassistant.const import (CONF_HOST,
+                                 CONF_PORT, CONF_PASSWORD)
+
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import (async_dispatcher_connect,
+                                              async_dispatcher_send)
+
+REQUIREMENTS = ['asterisk_mbox==0.4.0']
+
+SIGNAL_MESSAGE_UPDATE = 'asterisk_mbox.message_updated'
+SIGNAL_MESSAGE_REQUEST = 'asterisk_mbox.message_request'
+
+DOMAIN = 'asterisk_mbox'
+
+_LOGGER = logging.getLogger(__name__)
+
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_HOST): cv.string,
+        vol.Required(CONF_PORT): int,
+        vol.Required(CONF_PASSWORD): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    """Set up for the Asterisk Voicemail box."""
+    conf = config.get(DOMAIN)
+
+    host = conf.get(CONF_HOST)
+    port = conf.get(CONF_PORT)
+    password = conf.get(CONF_PASSWORD)
+
+    hass.data[DOMAIN] = AsteriskData(hass, host, port, password)
+
+    discovery.load_platform(hass, "mailbox", DOMAIN, {}, config)
+
+    return True
+
+
+class AsteriskData(object):
+    """Store Asterisk mailbox data."""
+
+    def __init__(self, hass, host, port, password):
+        """Init the Asterisk data object."""
+        from asterisk_mbox import Client as asteriskClient
+
+        self.hass = hass
+        self.client = asteriskClient(host, port, password, self.handle_data)
+        self.messages = []
+
+        async_dispatcher_connect(
+            self.hass, SIGNAL_MESSAGE_REQUEST, self._request_messages)
+
+    @callback
+    def handle_data(self, command, msg):
+        """Handle changes to the mailbox."""
+        from asterisk_mbox.commands import CMD_MESSAGE_LIST
+
+        if command == CMD_MESSAGE_LIST:
+            _LOGGER.info("AsteriskVM sent updated message list")
+            self.messages = sorted(msg,
+                                   key=lambda item: item['info']['origtime'],
+                                   reverse=True)
+            async_dispatcher_send(self.hass, SIGNAL_MESSAGE_UPDATE,
+                                  self.messages)
+
+    @callback
+    def _request_messages(self):
+        """Handle changes to the mailbox."""
+        _LOGGER.info("Requesting message list")
+        self.client.messages()
@@ -13,6 +13,7 @@ import voluptuous as vol

 from homeassistant.setup import async_prepare_setup_platform
 from homeassistant.core import CoreState
+from homeassistant.loader import bind_hass
 from homeassistant import config as conf_util
 from homeassistant.const import (
    ATTR_ENTITY_ID, CONF_PLATFORM, STATE_ON, SERVICE_TURN_ON, SERVICE_TURN_OFF,
@@ -26,7 +27,6 @@ from homeassistant.helpers.restore_state import async_get_last_state
 from homeassistant.loader import get_platform
 from homeassistant.util.dt import utcnow
 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.frontend import register_built_in_panel

 DOMAIN = 'automation'
 DEPENDENCIES = ['group']
@@ -105,6 +105,7 @@ TRIGGER_SERVICE_SCHEMA = vol.Schema({
 RELOAD_SERVICE_SCHEMA = vol.Schema({})


+@bind_hass
 def is_on(hass, entity_id):
    """
    Return true if specified automation entity_id is on.
@@ -114,35 +115,41 @@ def is_on(hass, entity_id):
    return hass.states.is_state(entity_id, STATE_ON)


+@bind_hass
 def turn_on(hass, entity_id=None):
    """Turn on specified automation or all."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
    hass.services.call(DOMAIN, SERVICE_TURN_ON, data)


+@bind_hass
 def turn_off(hass, entity_id=None):
    """Turn off specified automation or all."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
    hass.services.call(DOMAIN, SERVICE_TURN_OFF, data)


+@bind_hass
 def toggle(hass, entity_id=None):
    """Toggle specified automation or all."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
    hass.services.call(DOMAIN, SERVICE_TOGGLE, data)


+@bind_hass
 def trigger(hass, entity_id=None):
    """Trigger specified automation or all."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
    hass.services.call(DOMAIN, SERVICE_TRIGGER, data)


+@bind_hass
 def reload(hass):
    """Reload the automation from config."""
    hass.services.call(DOMAIN, SERVICE_RELOAD)


+@bind_hass
 def async_reload(hass):
    """Reload the automation from config.

@@ -224,10 +231,6 @@ def async_setup(hass, config):
            DOMAIN, service, turn_onoff_service_handler,
            descriptions.get(service), schema=SERVICE_SCHEMA)

-    if 'frontend' in hass.config.components:
-        register_built_in_panel(hass, 'automation', 'Automations',
-                                'mdi:playlist-play')
-
    return True


@@ -12,16 +12,18 @@ import voluptuous as vol
 from homeassistant.core import callback
 from homeassistant.const import (
    CONF_VALUE_TEMPLATE, CONF_PLATFORM, CONF_ENTITY_ID,
-    CONF_BELOW, CONF_ABOVE)
-from homeassistant.helpers.event import async_track_state_change
+    CONF_BELOW, CONF_ABOVE, CONF_FOR)
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_same_state)
 from homeassistant.helpers import condition, config_validation as cv

 TRIGGER_SCHEMA = vol.All(vol.Schema({
    vol.Required(CONF_PLATFORM): 'numeric_state',
    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
-    CONF_BELOW: vol.Coerce(float),
-    CONF_ABOVE: vol.Coerce(float),
+    vol.Optional(CONF_BELOW): vol.Coerce(float),
+    vol.Optional(CONF_ABOVE): vol.Coerce(float),
    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+    vol.Optional(CONF_FOR): vol.All(cv.time_period, cv.positive_timedelta),
 }), cv.has_at_least_one_key(CONF_BELOW, CONF_ABOVE))

 _LOGGER = logging.getLogger(__name__)
@@ -33,15 +35,18 @@ def async_trigger(hass, config, action):
    entity_id = config.get(CONF_ENTITY_ID)
    below = config.get(CONF_BELOW)
    above = config.get(CONF_ABOVE)
+    time_delta = config.get(CONF_FOR)
    value_template = config.get(CONF_VALUE_TEMPLATE)
+    async_remove_track_same = None
+
    if value_template is not None:
        value_template.hass = hass

    @callback
-    def state_automation_listener(entity, from_s, to_s):
-        """Listen for state changes and calls action."""
+    def check_numeric_state(entity, from_s, to_s):
+        """Return True if they should trigger."""
        if to_s is None:
-            return
+            return False

        variables = {
            'trigger': {
@@ -55,17 +60,56 @@ def async_trigger(hass, config, action):
        # If new one doesn't match, nothing to do
        if not condition.async_numeric_state(
                hass, to_s, below, above, value_template, variables):
+            return False
+
+        return True
+
+    @callback
+    def state_automation_listener(entity, from_s, to_s):
+        """Listen for state changes and calls action."""
+        nonlocal async_remove_track_same
+
+        if not check_numeric_state(entity, from_s, to_s):
            return

+        variables = {
+            'trigger': {
+                'platform': 'numeric_state',
+                'entity_id': entity,
+                'below': below,
+                'above': above,
+                'from_state': from_s,
+                'to_state': to_s,
+            }
+        }
+
        # Only match if old didn't exist or existed but didn't match
        # Written as: skip if old one did exist and matched
        if from_s is not None and condition.async_numeric_state(
                hass, from_s, below, above, value_template, variables):
            return

-        variables['trigger']['from_state'] = from_s
-        variables['trigger']['to_state'] = to_s
+        @callback
+        def call_action():
+            """Call action with right context."""
+            hass.async_run_job(action, variables)

-        hass.async_run_job(action, variables)
+        if not time_delta:
+            call_action()
+            return

-    return async_track_state_change(hass, entity_id, state_automation_listener)
+        async_remove_track_same = async_track_same_state(
+            hass, True, time_delta, call_action, entity_ids=entity_id,
+            async_check_func=check_numeric_state)
+
+    unsub = async_track_state_change(
+        hass, entity_id, state_automation_listener)
+
+    @callback
+    def async_remove():
+        """Remove state listeners async."""
+        unsub()
+        if async_remove_track_same:
+            async_remove_track_same()  # pylint: disable=not-callable
+
+    return async_remove
@@ -8,32 +8,23 @@ import asyncio
 import voluptuous as vol

 from homeassistant.core import callback
-import homeassistant.util.dt as dt_util
-from homeassistant.const import MATCH_ALL, CONF_PLATFORM
+from homeassistant.const import MATCH_ALL, CONF_PLATFORM, CONF_FOR
 from homeassistant.helpers.event import (
-    async_track_state_change, async_track_point_in_utc_time)
-from homeassistant.helpers.deprecation import get_deprecated
+    async_track_state_change, async_track_same_state)
 import homeassistant.helpers.config_validation as cv

 CONF_ENTITY_ID = 'entity_id'
 CONF_FROM = 'from'
 CONF_TO = 'to'
-CONF_STATE = 'state'
-CONF_FOR = 'for'

-TRIGGER_SCHEMA = vol.All(
-    vol.Schema({
-        vol.Required(CONF_PLATFORM): 'state',
-        vol.Required(CONF_ENTITY_ID): cv.entity_ids,
-        # These are str on purpose. Want to catch YAML conversions
-        CONF_FROM: str,
-        CONF_TO: str,
-        CONF_STATE: str,
-        CONF_FOR: vol.All(cv.time_period, cv.positive_timedelta),
-    }),
-    vol.Any(cv.key_dependency(CONF_FOR, CONF_TO),
-            cv.key_dependency(CONF_FOR, CONF_STATE))
-)
+TRIGGER_SCHEMA = vol.All(vol.Schema({
+    vol.Required(CONF_PLATFORM): 'state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
+    # These are str on purpose. Want to catch YAML conversions
+    vol.Optional(CONF_FROM): str,
+    vol.Optional(CONF_TO): str,
+    vol.Optional(CONF_FOR): vol.All(cv.time_period, cv.positive_timedelta),
+}), cv.key_dependency(CONF_FOR, CONF_TO))


@asyncio.coroutine
@@ -41,30 +32,17 @@ def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    entity_id = config.get(CONF_ENTITY_ID)
    from_state = config.get(CONF_FROM, MATCH_ALL)
-    to_state = get_deprecated(config, CONF_TO, CONF_STATE, MATCH_ALL)
+    to_state = config.get(CONF_TO, MATCH_ALL)
    time_delta = config.get(CONF_FOR)
-    async_remove_state_for_cancel = None
-    async_remove_state_for_listener = None
    match_all = (from_state == MATCH_ALL and to_state == MATCH_ALL)
-
-    @callback
-    def clear_listener():
-        """Clear all unsub listener."""
-        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener
-
-        # pylint: disable=not-callable
-        if async_remove_state_for_listener is not None:
-            async_remove_state_for_listener()
-            async_remove_state_for_listener = None
-        if async_remove_state_for_cancel is not None:
-            async_remove_state_for_cancel()
-            async_remove_state_for_cancel = None
+    async_remove_track_same = None

    @callback
    def state_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
-        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener
+        nonlocal async_remove_track_same

+        @callback
        def call_action():
            """Call action with right context."""
            hass.async_run_job(action, {
@@ -82,33 +60,12 @@ def async_trigger(hass, config, action):
                from_s.last_changed == to_s.last_changed):
            return

-        if time_delta is None:
+        if not time_delta:
            call_action()
            return

-        @callback
-        def state_for_listener(now):
-            """Fire on state changes after a delay and calls action."""
-            nonlocal async_remove_state_for_listener
-            async_remove_state_for_listener = None
-            clear_listener()
-            call_action()
-
-        @callback
-        def state_for_cancel_listener(entity, inner_from_s, inner_to_s):
-            """Fire on changes and cancel for listener if changed."""
-            if inner_to_s.state == to_s.state:
-                return
-            clear_listener()
-
-        # cleanup previous listener
-        clear_listener()
-
-        async_remove_state_for_listener = async_track_point_in_utc_time(
-            hass, state_for_listener, dt_util.utcnow() + time_delta)
-
-        async_remove_state_for_cancel = async_track_state_change(
-            hass, entity, state_for_cancel_listener)
+        async_remove_track_same = async_track_same_state(
+            hass, to_s.state, time_delta, call_action, entity_ids=entity_id)

    unsub = async_track_state_change(
        hass, entity_id, state_automation_listener, from_state, to_state)
@@ -117,6 +74,7 @@ def async_trigger(hass, config, action):
    def async_remove():
        """Remove state listeners async."""
        unsub()
-        clear_listener()
+        if async_remove_track_same:
+            async_remove_track_same()  # pylint: disable=not-callable

    return async_remove
@@ -10,7 +10,7 @@ import logging
 import voluptuous as vol

 from homeassistant.core import callback
-from homeassistant.const import CONF_AT, CONF_PLATFORM, CONF_AFTER
+from homeassistant.const import CONF_AT, CONF_PLATFORM
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.event import async_track_time_change

@@ -23,12 +23,10 @@ _LOGGER = logging.getLogger(__name__)
 TRIGGER_SCHEMA = vol.All(vol.Schema({
    vol.Required(CONF_PLATFORM): 'time',
    CONF_AT: cv.time,
-    CONF_AFTER: cv.time,
    CONF_HOURS: vol.Any(vol.Coerce(int), vol.Coerce(str)),
    CONF_MINUTES: vol.Any(vol.Coerce(int), vol.Coerce(str)),
    CONF_SECONDS: vol.Any(vol.Coerce(int), vol.Coerce(str)),
-}), cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES,
-                            CONF_SECONDS, CONF_AT, CONF_AFTER))
+}), cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES, CONF_SECONDS, CONF_AT))


@asyncio.coroutine
@@ -37,11 +35,6 @@ def async_trigger(hass, config, action):
    if CONF_AT in config:
        at_time = config.get(CONF_AT)
        hours, minutes, seconds = at_time.hour, at_time.minute, at_time.second
-    elif CONF_AFTER in config:
-        _LOGGER.warning("'after' is deprecated for the time trigger. Please "
-                        "rename 'after' to 'at' in your configuration file.")
-        at_time = config.get(CONF_AFTER)
-        hours, minutes, seconds = at_time.hour, at_time.minute, at_time.second
    else:
        hours = config.get(CONF_HOURS)
        minutes = config.get(CONF_MINUTES)
@@ -21,7 +21,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import discovery
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.entity import Entity
-from homeassistant.loader import get_component


 REQUIREMENTS = ['axis==8']
@@ -79,7 +78,7 @@ SERVICE_SCHEMA = vol.Schema({

 def request_configuration(hass, name, host, serialnumber):
    """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator

    def configuration_callback(callback_data):
        """Called when config is submitted."""
@@ -111,7 +110,7 @@ def request_configuration(hass, name, host, serialnumber):

    title = '{} ({})'.format(name, host)
    request_id = configurator.request_config(
-        hass, title, configuration_callback,
+        title, configuration_callback,
        description='Functionality: ' + str(AXIS_INCLUDE),
        entity_picture="/static/images/logo_axis.png",
        link_name='Axis platform documentation',
@@ -242,12 +241,11 @@ def setup_device(hass, config):
    if enable_metadatastream:
        device.initialize_new_event = event_initialized
        if not device.initiate_metadatastream():
-            notification = get_component('persistent_notification')
-            notification.create(hass,
-                                'Dependency missing for sensors, '
-                                'please check documentation',
-                                title=DOMAIN,
-                                notification_id='axis_notification')
+            hass.components.persistent_notification.create(
+                'Dependency missing for sensors, '
+                'please check documentation',
+                title=DOMAIN,
+                notification_id='axis_notification')

    AXIS_DEVICES[device.serial_number] = device

@@ -14,7 +14,6 @@ from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.const import (STATE_ON, STATE_OFF)
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
-from homeassistant.helpers.deprecation import deprecated_substitute

 DOMAIN = 'binary_sensor'
 SCAN_INTERVAL = timedelta(seconds=30)
@@ -66,7 +65,6 @@ class BinarySensorDevice(Entity):
        return STATE_ON if self.is_on else STATE_OFF

    @property
-    @deprecated_substitute('sensor_class')
    def device_class(self):
        """Return the class of this device, from component DEVICE_CLASSES."""
        return None
@@ -0,0 +1,61 @@
+"""
+This component provides HA binary_sensor support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.abode/
+"""
+import logging
+
+from homeassistant.components.abode import AbodeDevice, DATA_ABODE
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for an Abode device."""
+    abode = hass.data[DATA_ABODE]
+
+    device_types = map_abode_device_class().keys()
+
+    sensors = []
+    for sensor in abode.get_devices(type_filter=device_types):
+        sensors.append(AbodeBinarySensor(abode, sensor))
+
+    add_devices(sensors)
+
+
+def map_abode_device_class():
+    """Map Abode device types to Home Assistant binary sensor class."""
+    import abodepy.helpers.constants as CONST
+
+    return {
+        CONST.DEVICE_GLASS_BREAK: 'connectivity',
+        CONST.DEVICE_KEYPAD: 'connectivity',
+        CONST.DEVICE_DOOR_CONTACT: 'opening',
+        CONST.DEVICE_STATUS_DISPLAY: 'connectivity',
+        CONST.DEVICE_MOTION_CAMERA: 'connectivity',
+        CONST.DEVICE_WATER_SENSOR: 'moisture'
+    }
+
+
+class AbodeBinarySensor(AbodeDevice, BinarySensorDevice):
+    """A binary sensor implementation for Abode device."""
+
+    def __init__(self, controller, device):
+        """Initialize a sensor for Abode device."""
+        AbodeDevice.__init__(self, controller, device)
+        self._device_class = map_abode_device_class().get(self._device.type)
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._device.is_on
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device_class
@@ -20,9 +20,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Set up an Online Status binary sensor."""
-    add_entities((OnlineStatus(config, apcupsd.DATA),))
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up an APCUPSd Online Status binary sensor."""
+    add_devices([OnlineStatus(config, apcupsd.DATA)], True)


 class OnlineStatus(BinarySensorDevice):
@@ -33,7 +33,6 @@ class OnlineStatus(BinarySensorDevice):
        self._config = config
        self._data = data
        self._state = None
-        self.update()

    @property
    def name(self):
@@ -13,10 +13,9 @@ import voluptuous as vol
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    CONF_RESOURCE, CONF_PIN, CONF_NAME, CONF_SENSOR_CLASS, CONF_DEVICE_CLASS)
+    CONF_RESOURCE, CONF_PIN, CONF_NAME, CONF_DEVICE_CLASS)
 from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated

 _LOGGER = logging.getLogger(__name__)

@@ -26,7 +25,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_RESOURCE): cv.url,
    vol.Optional(CONF_NAME): cv.string,
    vol.Required(CONF_PIN): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })

@@ -35,7 +33,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the aREST binary sensor."""
    resource = config.get(CONF_RESOURCE)
    pin = config.get(CONF_PIN)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)

    try:
        response = requests.get(resource, timeout=10).json()
@@ -0,0 +1,211 @@
+"""
+Use Bayesian Inference to trigger a binary sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.bayesian/
+"""
+import asyncio
+import logging
+from collections import OrderedDict
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (
+    CONF_ABOVE, CONF_BELOW, CONF_DEVICE_CLASS, CONF_ENTITY_ID, CONF_NAME,
+    CONF_PLATFORM, CONF_STATE, STATE_UNKNOWN)
+from homeassistant.core import callback
+from homeassistant.helpers import condition
+from homeassistant.helpers.event import async_track_state_change
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_OBSERVATIONS = 'observations'
+CONF_PRIOR = 'prior'
+CONF_PROBABILITY_THRESHOLD = 'probability_threshold'
+CONF_P_GIVEN_F = 'prob_given_false'
+CONF_P_GIVEN_T = 'prob_given_true'
+CONF_TO_STATE = 'to_state'
+
+DEFAULT_NAME = 'BayesianBinary'
+
+NUMERIC_STATE_SCHEMA = vol.Schema({
+    CONF_PLATFORM: 'numeric_state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Optional(CONF_ABOVE): vol.Coerce(float),
+    vol.Optional(CONF_BELOW): vol.Coerce(float),
+    vol.Required(CONF_P_GIVEN_T): vol.Coerce(float),
+    vol.Optional(CONF_P_GIVEN_F): vol.Coerce(float)
+}, required=True)
+
+STATE_SCHEMA = vol.Schema({
+    CONF_PLATFORM: CONF_STATE,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_TO_STATE): cv.string,
+    vol.Required(CONF_P_GIVEN_T): vol.Coerce(float),
+    vol.Optional(CONF_P_GIVEN_F): vol.Coerce(float)
+}, required=True)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME):
+        cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): cv.string,
+    vol.Required(CONF_OBSERVATIONS): vol.Schema(
+        vol.All(cv.ensure_list, [vol.Any(NUMERIC_STATE_SCHEMA,
+                                         STATE_SCHEMA)])
+    ),
+    vol.Required(CONF_PRIOR): vol.Coerce(float),
+    vol.Optional(CONF_PROBABILITY_THRESHOLD):
+        vol.Coerce(float),
+})
+
+
+def update_probability(prior, prob_true, prob_false):
+    """Update probability using Bayes' rule."""
+    numerator = prob_true * prior
+    denominator = numerator + prob_false * (1 - prior)
+
+    probability = numerator / denominator
+    return probability
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Threshold sensor."""
+    name = config.get(CONF_NAME)
+    observations = config.get(CONF_OBSERVATIONS)
+    prior = config.get(CONF_PRIOR)
+    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD, 0.5)
+    device_class = config.get(CONF_DEVICE_CLASS)
+
+    async_add_devices([
+        BayesianBinarySensor(name, prior, observations, probability_threshold,
+                             device_class)
+    ], True)
+
+
+class BayesianBinarySensor(BinarySensorDevice):
+    """Representation of a Bayesian sensor."""
+
+    def __init__(self, name, prior, observations, probability_threshold,
+                 device_class):
+        """Initialize the Bayesian sensor."""
+        self._name = name
+        self._observations = observations
+        self._probability_threshold = probability_threshold
+        self._device_class = device_class
+        self._deviation = False
+        self.prior = prior
+        self.probability = prior
+
+        self.current_obs = OrderedDict({})
+
+        self.entity_obs = {obs['entity_id']: obs for obs in self._observations}
+
+        self.watchers = {
+            'numeric_state': self._process_numeric_state,
+            'state': self._process_state
+        }
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Call when entity about to be added to hass."""
+        @callback
+        # pylint: disable=invalid-name
+        def async_threshold_sensor_state_listener(entity, old_state,
+                                                  new_state):
+            """Handle sensor state changes."""
+            if new_state.state == STATE_UNKNOWN:
+                return
+
+            entity_obs = self.entity_obs[entity]
+            platform = entity_obs['platform']
+
+            self.watchers[platform](entity_obs)
+
+            prior = self.prior
+            print(self.current_obs.values())
+            for obs in self.current_obs.values():
+                prior = update_probability(prior, obs['prob_true'],
+                                           obs['prob_false'])
+
+            self.probability = prior
+
+            self.hass.async_add_job(self.async_update_ha_state, True)
+
+        entities = [obs['entity_id'] for obs in self._observations]
+        async_track_state_change(
+            self.hass, entities, async_threshold_sensor_state_listener)
+
+    def _update_current_obs(self, entity_observation, should_trigger):
+        """Update current observation."""
+        entity = entity_observation['entity_id']
+
+        if should_trigger:
+            prob_true = entity_observation['prob_given_true']
+            prob_false = entity_observation.get(
+                'prob_given_false', 1 - prob_true)
+
+            self.current_obs[entity] = {
+                'prob_true': prob_true,
+                'prob_false': prob_false
+            }
+
+        else:
+            self.current_obs.pop(entity, None)
+
+    def _process_numeric_state(self, entity_observation):
+        """Add entity to current_obs if numeric state conditions are met."""
+        entity = entity_observation['entity_id']
+
+        should_trigger = condition.async_numeric_state(
+            self.hass, entity,
+            entity_observation.get('below'),
+            entity_observation.get('above'), None, entity_observation)
+
+        self._update_current_obs(entity_observation, should_trigger)
+
+    def _process_state(self, entity_observation):
+        """Add entity to current observations if state conditions are met."""
+        entity = entity_observation['entity_id']
+
+        should_trigger = condition.state(
+            self.hass, entity, entity_observation.get('to_state'))
+
+        self._update_current_obs(entity_observation, should_trigger)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._deviation
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the sensor class of the sensor."""
+        return self._device_class
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        return {
+            'observations': [val for val in self.current_obs.values()],
+            'probability': self.probability,
+            'probability_threshold': self._probability_threshold
+        }
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get the latest data and update the states."""
+        self._deviation = bool(self.probability > self._probability_threshold)
@@ -37,7 +37,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    for device in bloomsky.BLOOMSKY.devices.values():
        for variable in sensors:
-            add_devices([BloomSkySensor(bloomsky.BLOOMSKY, device, variable)])
+            add_devices(
+                [BloomSkySensor(bloomsky.BLOOMSKY, device, variable)], True)


 class BloomSkySensor(BinarySensorDevice):
@@ -50,7 +51,7 @@ class BloomSkySensor(BinarySensorDevice):
        self._sensor_name = sensor_name
        self._name = '{} {}'.format(device['DeviceName'], sensor_name)
        self._unique_id = 'bloomsky_binary_sensor {}'.format(self._name)
-        self.update()
+        self._state = None

    @property
    def name(self):
@@ -4,19 +4,18 @@ Support for custom shell commands to retrieve values.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.command_line/
 """
-from datetime import timedelta
 import logging
+from datetime import timedelta

 import voluptuous as vol

+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, DEVICE_CLASSES_SCHEMA, PLATFORM_SCHEMA)
 from homeassistant.components.sensor.command_line import CommandSensorData
 from homeassistant.const import (
    CONF_PAYLOAD_OFF, CONF_PAYLOAD_ON, CONF_NAME, CONF_VALUE_TEMPLATE,
-    CONF_SENSOR_CLASS, CONF_COMMAND, CONF_DEVICE_CLASS)
-import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
+    CONF_COMMAND, CONF_DEVICE_CLASS)

 _LOGGER = logging.getLogger(__name__)

@@ -31,7 +30,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
    vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
 })
@@ -44,15 +42,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    command = config.get(CONF_COMMAND)
    payload_off = config.get(CONF_PAYLOAD_OFF)
    payload_on = config.get(CONF_PAYLOAD_ON)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
    value_template = config.get(CONF_VALUE_TEMPLATE)
    if value_template is not None:
        value_template.hass = hass
-    data = CommandSensorData(command)
+    data = CommandSensorData(hass, command)

    add_devices([CommandBinarySensor(
        hass, data, name, device_class, payload_on, payload_off,
-        value_template)])
+        value_template)], True)


 class CommandBinarySensor(BinarySensorDevice):
@@ -69,7 +67,6 @@ class CommandBinarySensor(BinarySensorDevice):
        self._payload_on = payload_on
        self._payload_off = payload_off
        self._value_template = value_template
-        self.update()

    @property
    def name(self):
@@ -72,9 +72,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                )
            )

-        add_devices(sensors)
-
-    return True
+        add_devices(sensors, True)


 def get_opening_type(zone):
@@ -100,7 +98,6 @@ class Concord232ZoneSensor(BinarySensorDevice):
        self._zone = zone
        self._number = zone['number']
        self._zone_type = zone_type
-        self.update()

    @property
    def device_class(self):
@@ -130,7 +127,7 @@ class Concord232ZoneSensor(BinarySensorDevice):
        if last_update > datetime.timedelta(seconds=1):
            self._client.zones = self._client.list_zones()
            self._client.last_zone_update = datetime.datetime.now()
-            _LOGGER.debug("Updated from Zone: %s", self._zone['name'])
+            _LOGGER.debug("Updated from zone: %s", self._zone['name'])

        if hasattr(self._client, 'zones'):
            self._zone = next((x for x in self._client.zones
@@ -19,7 +19,7 @@ from homeassistant.components.digital_ocean import (
 _LOGGER = logging.getLogger(__name__)

 DEFAULT_NAME = 'Droplet'
-DEFAULT_SENSOR_CLASS = 'moving'
+DEFAULT_DEVICE_CLASS = 'moving'
 DEPENDENCIES = ['digital_ocean']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -69,7 +69,7 @@ class DigitalOceanBinarySensor(BinarySensorDevice):
    @property
    def device_class(self):
        """Return the class of this sensor."""
-        return DEFAULT_SENSOR_CLASS
+        return DEFAULT_DEVICE_CLASS

    @property
    def device_state_attributes(self):
@@ -26,7 +26,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

                dev.append(EcobeeBinarySensor(sensor['name'], index))

-    add_devices(dev)
+    add_devices(dev, True)


 class EcobeeBinarySensor(BinarySensorDevice):
@@ -39,7 +39,6 @@ class EcobeeBinarySensor(BinarySensorDevice):
        self.index = sensor_index
        self._state = None
        self._device_class = 'occupancy'
-        self.update()

    @property
    def name(self):
@@ -12,9 +12,8 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
 from homeassistant.components import enocean
 from homeassistant.const import (
-    CONF_NAME, CONF_ID, CONF_SENSOR_CLASS, CONF_DEVICE_CLASS)
+    CONF_NAME, CONF_ID, CONF_DEVICE_CLASS)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated

 _LOGGER = logging.getLogger(__name__)

@@ -24,7 +23,6 @@ DEFAULT_NAME = 'EnOcean binary sensor'
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })

@@ -33,7 +31,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Binary Sensor platform for EnOcean."""
    dev_id = config.get(CONF_ID)
    devname = config.get(CONF_NAME)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)

    add_devices([EnOceanBinarySensor(dev_id, devname, device_class)])

@@ -18,7 +18,7 @@ from homeassistant.const import (
    CONF_SSL, EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START,
    ATTR_LAST_TRIP_TIME, CONF_CUSTOMIZE)

-REQUIREMENTS = ['pyhik==0.1.3']
+REQUIREMENTS = ['pyhik==0.1.4']
 _LOGGER = logging.getLogger(__name__)

 CONF_IGNORED = 'ignored'
@@ -47,6 +47,7 @@ DEVICE_CLASS_MAP = {
    'PIR Alarm': 'motion',
    'Face Detection': 'motion',
    'Scene Change Detection': 'motion',
+    'I/O': None,
 }

 CUSTOMIZE_SCHEMA = vol.Schema({
@@ -35,8 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    devices = []
    for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMBinarySensor(hass, conf)
-        new_device.link_homematic()
+        new_device = HMBinarySensor(conf)
        devices.append(new_device)

    add_devices(devices)
@@ -64,7 +64,6 @@ class IssBinarySensor(BinarySensorDevice):
        self._state = None
        self._name = name
        self._show_on_map = show
-        self.update()

    @property
    def name(self):
@@ -1,21 +1,145 @@
 """
-Contains functionality to use a KNX group address as a binary.
+Support for KNX/IP binary sensors.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.knx/
 """
-from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.knx import (KNXConfig, KNXGroupAddress)
+import asyncio
+import voluptuous as vol

+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES, \
+    KNXAutomation
+from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, \
+    BinarySensorDevice
+from homeassistant.const import CONF_NAME
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+
+CONF_ADDRESS = 'address'
+CONF_DEVICE_CLASS = 'device_class'
+CONF_SIGNIFICANT_BIT = 'significant_bit'
+CONF_DEFAULT_SIGNIFICANT_BIT = 1
+CONF_AUTOMATION = 'automation'
+CONF_HOOK = 'hook'
+CONF_DEFAULT_HOOK = 'on'
+CONF_COUNTER = 'counter'
+CONF_DEFAULT_COUNTER = 1
+CONF_ACTION = 'action'
+
+CONF__ACTION = 'turn_off_action'
+
+DEFAULT_NAME = 'KNX Binary Sensor'
 DEPENDENCIES = ['knx']

+AUTOMATION_SCHEMA = vol.Schema({
+    vol.Optional(CONF_HOOK, default=CONF_DEFAULT_HOOK): cv.string,
+    vol.Optional(CONF_COUNTER, default=CONF_DEFAULT_COUNTER): cv.port,
+    vol.Required(CONF_ACTION, default=None): cv.SCRIPT_SCHEMA
+})

-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the KNX binary sensor platform."""
-    add_devices([KNXSwitch(hass, KNXConfig(config))])
+AUTOMATIONS_SCHEMA = vol.All(
+    cv.ensure_list,
+    [AUTOMATION_SCHEMA]
+)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ADDRESS): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): cv.string,
+    vol.Optional(CONF_SIGNIFICANT_BIT, default=CONF_DEFAULT_SIGNIFICANT_BIT):
+        cv.positive_int,
+    vol.Optional(CONF_AUTOMATION, default=None): AUTOMATIONS_SCHEMA,
+})


-class KNXSwitch(KNXGroupAddress, BinarySensorDevice):
-    """Representation of a KNX binary sensor device."""
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up binary sensor(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False

-    pass
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True
+
+
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up binary sensors for KNX platform configured via xknx.yaml."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXBinarySensor(hass, device))
+    add_devices(entities)
+
+
+@callback
+def async_add_devices_config(hass, config, add_devices):
+    """Set up binary senor for KNX platform configured within plattform."""
+    name = config.get(CONF_NAME)
+    import xknx
+    binary_sensor = xknx.devices.BinarySensor(
+        hass.data[DATA_KNX].xknx,
+        name=name,
+        group_address=config.get(CONF_ADDRESS),
+        device_class=config.get(CONF_DEVICE_CLASS),
+        significant_bit=config.get(CONF_SIGNIFICANT_BIT))
+    hass.data[DATA_KNX].xknx.devices.add(binary_sensor)
+
+    entity = KNXBinarySensor(hass, binary_sensor)
+    automations = config.get(CONF_AUTOMATION)
+    if automations is not None:
+        for automation in automations:
+            counter = automation.get(CONF_COUNTER)
+            hook = automation.get(CONF_HOOK)
+            action = automation.get(CONF_ACTION)
+            entity.automations.append(KNXAutomation(
+                hass=hass, device=binary_sensor, hook=hook,
+                action=action, counter=counter))
+    add_devices([entity])
+
+
+class KNXBinarySensor(BinarySensorDevice):
+    """Representation of a KNX binary sensor."""
+
+    def __init__(self, hass, device):
+        """Initialization of KNXBinarySensor."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
+        self.automations = []
+
+    @callback
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name
+
+    @property
+    def should_poll(self):
+        """No polling needed within KNX."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return self.device.device_class
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.device.is_on()
@@ -15,10 +15,9 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDevice, DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
    CONF_NAME, CONF_VALUE_TEMPLATE, CONF_PAYLOAD_ON, CONF_PAYLOAD_OFF,
-    CONF_SENSOR_CLASS, CONF_DEVICE_CLASS)
+    CONF_DEVICE_CLASS)
 from homeassistant.components.mqtt import (CONF_STATE_TOPIC, CONF_QOS)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated

 _LOGGER = logging.getLogger(__name__)

@@ -31,7 +30,6 @@ PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
    vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })

@@ -49,7 +47,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    async_add_devices([MqttBinarySensor(
        config.get(CONF_NAME),
        config.get(CONF_STATE_TOPIC),
-        get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS),
+        config.get(CONF_DEVICE_CLASS),
        config.get(CONF_QOS),
        config.get(CONF_PAYLOAD_ON),
        config.get(CONF_PAYLOAD_OFF),
@@ -4,62 +4,27 @@ Support for MySensors binary sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
-from homeassistant.components.binary_sensor import (DEVICE_CLASSES,
+from homeassistant.components.binary_sensor import (DEVICE_CLASSES, DOMAIN,
                                                    BinarySensorDevice)
 from homeassistant.const import STATE_ON

-_LOGGER = logging.getLogger(__name__)
-DEPENDENCIES = []
-

 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the MySensors platform for sensors."""
-    # Only act if loaded via mysensors by discovery event.
-    # Otherwise gateway is not setup.
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        # Define the S_TYPES and V_TYPES that the platform should handle as
-        # states. Map them in a dict of lists.
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_DOOR: [set_req.V_TRIPPED],
-            pres.S_MOTION: [set_req.V_TRIPPED],
-            pres.S_SMOKE: [set_req.V_TRIPPED],
-        }
-        if float(gateway.protocol_version) >= 1.5:
-            map_sv_types.update({
-                pres.S_SPRINKLER: [set_req.V_TRIPPED],
-                pres.S_WATER_LEAK: [set_req.V_TRIPPED],
-                pres.S_SOUND: [set_req.V_TRIPPED],
-                pres.S_VIBRATION: [set_req.V_TRIPPED],
-                pres.S_MOISTURE: [set_req.V_TRIPPED],
-            })
-
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsBinarySensor, add_devices))
+    """Setup the mysensors platform for binary sensors."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsBinarySensor,
+        add_devices=add_devices)


 class MySensorsBinarySensor(
-        mysensors.MySensorsDeviceEntity, BinarySensorDevice):
+        mysensors.MySensorsEntity, BinarySensorDevice):
    """Represent the value of a MySensors Binary Sensor child node."""

    @property
    def is_on(self):
        """Return True if the binary sensor is on."""
-        if self.value_type in self._values:
-            return self._values[self.value_type] == STATE_ON
-        return False
+        return self._values.get(self.value_type) == STATE_ON

    @property
    def device_class(self):
@@ -44,18 +44,19 @@ CONF_WELCOME_SENSORS = 'welcome_sensors'
 CONF_PRESENCE_SENSORS = 'presence_sensors'
 CONF_TAG_SENSORS = 'tag_sensors'

+DEFAULT_TIMEOUT = 15
+DEFAULT_OFFSET = 90
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_HOME): cv.string,
-    vol.Optional(CONF_TIMEOUT): cv.positive_int,
-    vol.Optional(CONF_OFFSET): cv.positive_int,
    vol.Optional(CONF_CAMERAS, default=[]):
        vol.All(cv.ensure_list, [cv.string]),
-    vol.Optional(
-        CONF_WELCOME_SENSORS, default=WELCOME_SENSOR_TYPES.keys()):
-        vol.All(cv.ensure_list, [vol.In(WELCOME_SENSOR_TYPES)]),
-    vol.Optional(
-        CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES.keys()):
+    vol.Optional(CONF_HOME): cv.string,
+    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): cv.positive_int,
+    vol.Optional(CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES):
        vol.All(cv.ensure_list, [vol.In(PRESENCE_SENSOR_TYPES)]),
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
+    vol.Optional(CONF_WELCOME_SENSORS, default=WELCOME_SENSOR_TYPES):
+        vol.All(cv.ensure_list, [vol.In(WELCOME_SENSOR_TYPES)]),
 })


@@ -63,16 +64,16 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the access to Netatmo binary sensor."""
    netatmo = get_component('netatmo')
-    home = config.get(CONF_HOME, None)
-    timeout = config.get(CONF_TIMEOUT, 15)
-    offset = config.get(CONF_OFFSET, 90)
+    home = config.get(CONF_HOME)
+    timeout = config.get(CONF_TIMEOUT)
+    offset = config.get(CONF_OFFSET)

    module_name = None

    import lnetatmo
    try:
        data = CameraData(netatmo.NETATMO_AUTH, home)
-        if data.get_camera_names() == []:
+        if not data.get_camera_names():
            return None
    except lnetatmo.NoDevice:
        return None
@@ -93,7 +94,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            for variable in welcome_sensors:
                add_devices([NetatmoBinarySensor(
                    data, camera_name, module_name, home, timeout,
-                    offset, camera_type, variable)])
+                    offset, camera_type, variable)], True)
        if camera_type == 'NOC':
            if CONF_CAMERAS in config:
                if config[CONF_CAMERAS] != [] and \
@@ -102,14 +103,14 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            for variable in presence_sensors:
                add_devices([NetatmoBinarySensor(
                    data, camera_name, module_name, home, timeout, offset,
-                    camera_type, variable)])
+                    camera_type, variable)], True)

        for module_name in data.get_module_names(camera_name):
            for variable in tag_sensors:
                camera_type = None
                add_devices([NetatmoBinarySensor(
                    data, camera_name, module_name, home, timeout, offset,
-                    camera_type, variable)])
+                    camera_type, variable)], True)


 class NetatmoBinarySensor(BinarySensorDevice):
@@ -137,7 +138,7 @@ class NetatmoBinarySensor(BinarySensorDevice):
        self._unique_id = "Netatmo_binary_sensor {0} - {1}".format(
            self._name, camera_id)
        self._cameratype = camera_type
-        self.update()
+        self._state = None

    @property
    def name(self):
@@ -48,7 +48,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            name, SENSOR_TYPES[octo_type][3], SENSOR_TYPES[octo_type][0],
            SENSOR_TYPES[octo_type][1], 'flags')
        devices.append(new_sensor)
-    add_devices(devices)
+    add_devices(devices, True)


 class OctoPrintBinarySensor(BinarySensorDevice):
@@ -69,8 +69,6 @@ class OctoPrintBinarySensor(BinarySensorDevice):
        self.api_endpoint = endpoint
        self.api_group = group
        self.api_tool = tool
-        # Set initial state
-        self.update()
        _LOGGER.debug("Created OctoPrint binary sensor %r", self)

    @property
@@ -28,13 +28,16 @@ CONF_PING_COUNT = 'count'

 DEFAULT_NAME = 'Ping Binary sensor'
 DEFAULT_PING_COUNT = 5
-DEFAULT_SENSOR_CLASS = 'connectivity'
+DEFAULT_DEVICE_CLASS = 'connectivity'

 SCAN_INTERVAL = timedelta(minutes=5)

 PING_MATCHER = re.compile(
    r'(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)\/(?P<mdev>\d+.\d+)')

+PING_MATCHER_BUSYBOX = re.compile(
+    r'(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)')
+
 WIN32_PING_MATCHER = re.compile(
    r'(?P<min>\d+)ms.+(?P<max>\d+)ms.+(?P<avg>\d+)ms')

@@ -70,7 +73,7 @@ class PingBinarySensor(BinarySensorDevice):
    @property
    def device_class(self):
        """Return the class of this sensor."""
-        return DEFAULT_SENSOR_CLASS
+        return DEFAULT_DEVICE_CLASS

    @property
    def is_on(self):
@@ -126,7 +129,14 @@ class PingData(object):
                    'avg': rtt_avg,
                    'max': rtt_max,
                    'mdev': ''}
-
+            if 'max/' not in str(out):
+                match = PING_MATCHER_BUSYBOX.search(str(out).split('\n')[-1])
+                rtt_min, rtt_avg, rtt_max = match.groups()
+                return {
+                    'min': rtt_min,
+                    'avg': rtt_avg,
+                    'max': rtt_max,
+                    'mdev': ''}
            match = PING_MATCHER.search(str(out).split('\n')[-1])
            rtt_min, rtt_avg, rtt_max, rtt_mdev = match.groups()
            return {
@@ -14,11 +14,10 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.components.sensor.rest import RestData
 from homeassistant.const import (
    CONF_PAYLOAD, CONF_NAME, CONF_VALUE_TEMPLATE, CONF_METHOD, CONF_RESOURCE,
-    CONF_SENSOR_CLASS, CONF_VERIFY_SSL, CONF_USERNAME, CONF_PASSWORD,
+    CONF_VERIFY_SSL, CONF_USERNAME, CONF_PASSWORD,
    CONF_HEADERS, CONF_AUTHENTICATION, HTTP_BASIC_AUTHENTICATION,
    HTTP_DIGEST_AUTHENTICATION, CONF_DEVICE_CLASS)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated

 _LOGGER = logging.getLogger(__name__)

@@ -35,7 +34,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_PASSWORD): cv.string,
    vol.Optional(CONF_PAYLOAD): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_USERNAME): cv.string,
    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
@@ -53,7 +51,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)
    headers = config.get(CONF_HEADERS)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
    value_template = config.get(CONF_VALUE_TEMPLATE)
    if value_template is not None:
        value_template.hass = hass
@@ -74,7 +72,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        return False

    add_devices([RestBinarySensor(
-        hass, rest, name, device_class, value_template)])
+        hass, rest, name, device_class, value_template)], True)


 class RestBinarySensor(BinarySensorDevice):
@@ -89,7 +87,6 @@ class RestBinarySensor(BinarySensorDevice):
        self._state = False
        self._previous_data = None
        self._value_template = value_template
-        self.update()

    @property
    def name(self):
@@ -107,6 +104,8 @@ class RestBinarySensor(BinarySensorDevice):
        if self.rest.data is None:
            return False

+        response = self.rest.data
+
        if self._value_template is not None:
            response = self._value_template.\
                async_render_with_possible_json_value(self.rest.data, False)
@@ -62,6 +62,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                                    entity[CONF_COMMAND_ON],
                                    entity[CONF_COMMAND_OFF])
        device.hass = hass
+        device.is_lighting4 = (packet_id[2:4] == '13')
        sensors.append(device)
        rfxtrx.RFX_DEVICES[device_id] = device

@@ -94,6 +95,8 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):

            pkt_id = "".join("{0:02x}".format(x) for x in event.data)
            sensor = RfxtrxBinarySensor(event, pkt_id)
+            sensor.hass = hass
+            sensor.is_lighting4 = (pkt_id[2:4] == '13')
            rfxtrx.RFX_DEVICES[device_id] = sensor
            add_devices_callback([sensor])
            _LOGGER.info("Added binary sensor %s "
@@ -111,12 +114,12 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                         slugify(event.device.id_string.lower()),
                         event.device.__class__.__name__,
                         event.device.subtype)
-
-        if sensor.is_pt2262:
-            cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
-            _LOGGER.info("applying cmd %s to device_id: %s)",
-                         cmd, sensor.masked_id)
-            sensor.apply_cmd(int(cmd, 16))
+        if sensor.is_lighting4:
+            if sensor.data_bits is not None:
+                cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
+                sensor.apply_cmd(int(cmd, 16))
+            else:
+                sensor.update_state(True)
        else:
            rfxtrx.apply_received_command(event)

@@ -151,6 +154,7 @@ class RfxtrxBinarySensor(BinarySensorDevice):
        self._device_class = device_class
        self._off_delay = off_delay
        self._state = False
+        self.is_lighting4 = False
        self.delay_listener = None
        self._data_bits = data_bits
        self._cmd_on = cmd_on
@@ -170,11 +174,6 @@ class RfxtrxBinarySensor(BinarySensorDevice):
        """Return the device name."""
        return self._name

-    @property
-    def is_pt2262(self):
-        """Return true if the device is PT2262-based."""
-        return self._data_bits is not None
-
    @property
    def masked_id(self):
        """Return the masked device id (isolated address bits)."""
@@ -103,7 +103,8 @@ class RingBinarySensor(BinarySensorDevice):
        self._data.check_alerts()

        if self._data.alert:
-            self._state = (self._sensor_type ==
-                           self._data.alert.get('kind'))
+            if self._sensor_type == self._data.alert.get('kind') and \
+               self._data.account_id == self._data.alert.get('doorbot_id'):
+                self._state = True
        else:
            self._state = False
@@ -15,23 +15,28 @@ from homeassistant.components.binary_sensor import (
    DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_VALUE_TEMPLATE,
-    CONF_SENSOR_CLASS, CONF_SENSORS, CONF_DEVICE_CLASS,
-    EVENT_HOMEASSISTANT_START, STATE_ON)
+    CONF_SENSORS, CONF_DEVICE_CLASS, EVENT_HOMEASSISTANT_START, STATE_ON)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
 from homeassistant.helpers.entity import async_generate_entity_id
-from homeassistant.helpers.event import async_track_state_change
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_same_state)
 from homeassistant.helpers.restore_state import async_get_last_state

 _LOGGER = logging.getLogger(__name__)

+CONF_DELAY_ON = 'delay_on'
+CONF_DELAY_OFF = 'delay_off'
+
 SENSOR_SCHEMA = vol.Schema({
    vol.Required(CONF_VALUE_TEMPLATE): cv.template,
    vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_DELAY_ON):
+        vol.All(cv.time_period, cv.positive_timedelta),
+    vol.Optional(CONF_DELAY_OFF):
+        vol.All(cv.time_period, cv.positive_timedelta),
 })

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -49,8 +54,9 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        entity_ids = (device_config.get(ATTR_ENTITY_ID) or
                      value_template.extract_entities())
        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
-        device_class = get_deprecated(
-            device_config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+        device_class = device_config.get(CONF_DEVICE_CLASS)
+        delay_on = device_config.get(CONF_DELAY_ON)
+        delay_off = device_config.get(CONF_DELAY_OFF)

        if value_template is not None:
            value_template.hass = hass
@@ -58,13 +64,13 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        sensors.append(
            BinarySensorTemplate(
                hass, device, friendly_name, device_class, value_template,
-                entity_ids)
+                entity_ids, delay_on, delay_off)
            )
    if not sensors:
        _LOGGER.error("No sensors added")
        return False

-    async_add_devices(sensors, True)
+    async_add_devices(sensors)
    return True


@@ -72,7 +78,7 @@ class BinarySensorTemplate(BinarySensorDevice):
    """A virtual binary sensor that triggers from another sensor."""

    def __init__(self, hass, device, friendly_name, device_class,
-                 value_template, entity_ids):
+                 value_template, entity_ids, delay_on, delay_off):
        """Initialize the Template binary sensor."""
        self.hass = hass
        self.entity_id = async_generate_entity_id(
@@ -82,6 +88,8 @@ class BinarySensorTemplate(BinarySensorDevice):
        self._template = value_template
        self._state = None
        self._entities = entity_ids
+        self._delay_on = delay_on
+        self._delay_off = delay_off

    @asyncio.coroutine
    def async_added_to_hass(self):
@@ -93,7 +101,7 @@ class BinarySensorTemplate(BinarySensorDevice):
        @callback
        def template_bsensor_state_listener(entity, old_state, new_state):
            """Handle the target device state changes."""
-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.async_check_state()

        @callback
        def template_bsensor_startup(event):
@@ -101,7 +109,7 @@ class BinarySensorTemplate(BinarySensorDevice):
            async_track_state_change(
                self.hass, self._entities, template_bsensor_state_listener)

-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.hass.async_add_job(self.async_check_state)

        self.hass.bus.async_listen_once(
            EVENT_HOMEASSISTANT_START, template_bsensor_startup)
@@ -126,11 +134,11 @@ class BinarySensorTemplate(BinarySensorDevice):
        """No polling needed."""
        return False

-    @asyncio.coroutine
-    def async_update(self):
-        """Update the state from the template."""
+    @callback
+    def _async_render(self, *args):
+        """Get the state of template."""
        try:
-            self._state = self._template.async_render().lower() == 'true'
+            return self._template.async_render().lower() == 'true'
        except TemplateError as ex:
            if ex.args and ex.args[0].startswith(
                    "UndefinedError: 'None' has no attribute"):
@@ -139,4 +147,29 @@ class BinarySensorTemplate(BinarySensorDevice):
                                "the state is unknown", self._name)
                return
            _LOGGER.error("Could not render template %s: %s", self._name, ex)
-            self._state = False
+
+    @callback
+    def async_check_state(self):
+        """Update the state from the template."""
+        state = self._async_render()
+
+        # return if the state don't change or is invalid
+        if state is None or state == self.state:
+            return
+
+        @callback
+        def set_state():
+            """Set state of template binary sensor."""
+            self._state = state
+            self.hass.async_add_job(self.async_update_ha_state())
+
+        # state without delay
+        if (state and not self._delay_on) or \
+                (not state and not self._delay_off):
+            set_state()
+            return
+
+        period = self._delay_on if state else self._delay_off
+        async_track_same_state(
+            self.hass, state, period, set_state, entity_ids=self._entities,
+            async_check_func=self._async_render)
@@ -0,0 +1,57 @@
+"""
+Support for Tesla binary sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.tesla/
+"""
+import logging
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, ENTITY_ID_FORMAT)
+from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Tesla binary sensor."""
+    devices = [
+        TeslaBinarySensor(
+            device, hass.data[TESLA_DOMAIN]['controller'], 'connectivity')
+        for device in hass.data[TESLA_DOMAIN]['devices']['binary_sensor']]
+    add_devices(devices, True)
+
+
+class TeslaBinarySensor(TeslaDevice, BinarySensorDevice):
+    """Implement an Tesla binary sensor for parking and charger."""
+
+    def __init__(self, tesla_device, controller, sensor_type):
+        """Initialisation of binary sensor."""
+        super().__init__(tesla_device, controller)
+        self._name = self.tesla_device.name
+        self._state = False
+        self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
+        self._sensor_type = sensor_type
+
+    @property
+    def device_class(self):
+        """Return the class of this binary sensor."""
+        return self._sensor_type
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the binary sensor."""
+        return self._state
+
+    def update(self):
+        """Update the state of the device."""
+        _LOGGER.debug("Updating sensor: %s", self._name)
+        self.tesla_device.update()
+        self._state = self.tesla_device.get_value()
@@ -13,10 +13,9 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    CONF_NAME, CONF_ENTITY_ID, CONF_TYPE, STATE_UNKNOWN, CONF_SENSOR_CLASS,
+    CONF_NAME, CONF_ENTITY_ID, CONF_TYPE, STATE_UNKNOWN,
    ATTR_ENTITY_ID, CONF_DEVICE_CLASS)
 from homeassistant.core import callback
-from homeassistant.helpers.deprecation import get_deprecated
 from homeassistant.helpers.event import async_track_state_change

 _LOGGER = logging.getLogger(__name__)
@@ -38,7 +37,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_THRESHOLD): vol.Coerce(float),
    vol.Required(CONF_TYPE): vol.In(SENSOR_TYPES),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })

@@ -50,7 +48,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    name = config.get(CONF_NAME)
    threshold = config.get(CONF_THRESHOLD)
    limit_type = config.get(CONF_TYPE)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)

    async_add_devices(
        [ThresholdSensor(hass, entity_id, name, threshold, limit_type,
@@ -16,9 +16,7 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDevice, ENTITY_ID_FORMAT, PLATFORM_SCHEMA,
    DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_SENSOR_CLASS,
-    CONF_DEVICE_CLASS, STATE_UNKNOWN,)
-from homeassistant.helpers.deprecation import get_deprecated
+    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_DEVICE_CLASS, STATE_UNKNOWN)
 from homeassistant.helpers.entity import generate_entity_id
 from homeassistant.helpers.event import track_state_change

@@ -32,7 +30,6 @@ SENSOR_SCHEMA = vol.Schema({
    vol.Optional(CONF_ATTRIBUTE): cv.string,
    vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
    vol.Optional(CONF_INVERT, default=False): cv.boolean,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })

@@ -50,8 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        entity_id = device_config[ATTR_ENTITY_ID]
        attribute = device_config.get(CONF_ATTRIBUTE)
        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
-        device_class = get_deprecated(
-            device_config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+        device_class = device_config.get(CONF_DEVICE_CLASS)
        invert = device_config[CONF_INVERT]

        sensors.append(
@@ -0,0 +1,96 @@
+"""
+Support for Velbus Binary Sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.velbus/
+"""
+import asyncio
+import logging
+
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_NAME, CONF_DEVICES
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.binary_sensor import PLATFORM_SCHEMA
+from homeassistant.components.velbus import DOMAIN
+import homeassistant.helpers.config_validation as cv
+
+
+DEPENDENCIES = ['velbus']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_DEVICES): vol.All(cv.ensure_list, [
+        {
+            vol.Required('module'): cv.positive_int,
+            vol.Required('channel'): cv.positive_int,
+            vol.Required(CONF_NAME): cv.string,
+            vol.Optional('is_pushbutton'): cv.boolean
+        }
+    ])
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Velbus binary sensors."""
+    velbus = hass.data[DOMAIN]
+
+    add_devices(VelbusBinarySensor(sensor, velbus)
+                for sensor in config[CONF_DEVICES])
+
+
+class VelbusBinarySensor(BinarySensorDevice):
+    """Representation of a Velbus Binary Sensor."""
+
+    def __init__(self, binary_sensor, velbus):
+        """Initialize a Velbus light."""
+        self._velbus = velbus
+        self._name = binary_sensor[CONF_NAME]
+        self._module = binary_sensor['module']
+        self._channel = binary_sensor['channel']
+        self._is_pushbutton = 'is_pushbutton' in binary_sensor \
+                              and binary_sensor['is_pushbutton']
+        self._state = False
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Add listener for Velbus messages on bus."""
+        yield from self.hass.async_add_job(
+            self._velbus.subscribe, self._on_message)
+
+    def _on_message(self, message):
+        import velbus
+        if isinstance(message, velbus.PushButtonStatusMessage):
+            if message.address == self._module and \
+               self._channel in message.get_channels():
+                if self._is_pushbutton:
+                    if self._channel in message.closed:
+                        self._toggle()
+                    else:
+                        pass
+                else:
+                    self._toggle()
+
+    def _toggle(self):
+        if self._state is True:
+            self._state = False
+        else:
+            self._state = True
+        self.schedule_update_ha_state()
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def name(self):
+        """Return the display name of this sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if the sensor is on."""
+        return self._state
@@ -34,5 +34,5 @@ class VolvoSensor(VolvoEntity, BinarySensorDevice):

    @property
    def device_class(self):
-        """Return the class of this sensor, from SENSOR_CLASSES."""
+        """Return the class of this sensor, from DEVICE_CLASSES."""
        return 'safety'
@@ -6,13 +6,12 @@ https://home-assistant.io/components/binary_sensor.workday/
 """
 import asyncio
 import logging
-import datetime
+from datetime import datetime, timedelta

 import voluptuous as vol

 from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.const import CONF_NAME, WEEKDAYS
-import homeassistant.util.dt as dt_util
 from homeassistant.components.binary_sensor import BinarySensorDevice
 import homeassistant.helpers.config_validation as cv

@@ -39,11 +38,14 @@ CONF_EXCLUDES = 'excludes'
 DEFAULT_EXCLUDES = ['sat', 'sun', 'holiday']
 DEFAULT_NAME = 'Workday Sensor'
 ALLOWED_DAYS = WEEKDAYS + ['holiday']
+CONF_OFFSET = 'days_offset'
+DEFAULT_OFFSET = 0

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_COUNTRY): vol.In(ALL_COUNTRIES),
    vol.Optional(CONF_PROVINCE, default=None): cv.string,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): vol.Coerce(int),
    vol.Optional(CONF_WORKDAYS, default=DEFAULT_WORKDAYS):
        vol.All(cv.ensure_list, [vol.In(ALLOWED_DAYS)]),
    vol.Optional(CONF_EXCLUDES, default=DEFAULT_EXCLUDES):
@@ -60,8 +62,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    province = config.get(CONF_PROVINCE)
    workdays = config.get(CONF_WORKDAYS)
    excludes = config.get(CONF_EXCLUDES)
+    days_offset = config.get(CONF_OFFSET)

-    year = datetime.datetime.now().year
+    year = (datetime.now() + timedelta(days=days_offset)).year
    obj_holidays = getattr(holidays, country)(years=year)

    if province:
@@ -85,7 +88,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        _LOGGER.debug("%s %s", date, name)

    add_devices([IsWorkdaySensor(
-        obj_holidays, workdays, excludes, sensor_name)], True)
+        obj_holidays, workdays, excludes, days_offset, sensor_name)], True)


 def day_to_string(day):
@@ -99,12 +102,13 @@ def day_to_string(day):
 class IsWorkdaySensor(BinarySensorDevice):
    """Implementation of a Workday sensor."""

-    def __init__(self, obj_holidays, workdays, excludes, name):
+    def __init__(self, obj_holidays, workdays, excludes, days_offset, name):
        """Initialize the Workday sensor."""
        self._name = name
        self._obj_holidays = obj_holidays
        self._workdays = workdays
        self._excludes = excludes
+        self._days_offset = days_offset
        self._state = None

    @property
@@ -135,6 +139,16 @@ class IsWorkdaySensor(BinarySensorDevice):

        return False

+    @property
+    def state_attributes(self):
+        """Return the attributes of the entity."""
+        # return self._attributes
+        return {
+            CONF_WORKDAYS: self._workdays,
+            CONF_EXCLUDES: self._excludes,
+            CONF_OFFSET: self._days_offset
+        }
+
    @asyncio.coroutine
    def async_update(self):
        """Get date and look whether it is a holiday."""
@@ -142,11 +156,12 @@ class IsWorkdaySensor(BinarySensorDevice):
        self._state = False

        # Get iso day of the week (1 = Monday, 7 = Sunday)
-        day = datetime.datetime.today().isoweekday() - 1
+        date = datetime.today() + timedelta(days=self._days_offset)
+        day = date.isoweekday() - 1
        day_of_week = day_to_string(day)

-        if self.is_include(day_of_week, dt_util.now()):
+        if self.is_include(day_of_week, date):
            self._state = True

-        if self.is_exclude(day_of_week, dt_util.now()):
+        if self.is_exclude(day_of_week, date):
            self._state = False
@@ -0,0 +1,347 @@
+"""Support for Xiaomi binary sensors."""
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.xiaomi import (PY_XIAOMI_GATEWAY, XiaomiDevice)
+
+_LOGGER = logging.getLogger(__name__)
+
+NO_CLOSE = 'no_close'
+ATTR_OPEN_SINCE = 'Open since'
+
+MOTION = 'motion'
+NO_MOTION = 'no_motion'
+ATTR_NO_MOTION_SINCE = 'No motion since'
+
+DENSITY = 'density'
+ATTR_DENSITY = 'Density'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Perform the setup for Xiaomi devices."""
+    devices = []
+    for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
+        for device in gateway.devices['binary_sensor']:
+            model = device['model']
+            if model == 'motion':
+                devices.append(XiaomiMotionSensor(device, hass, gateway))
+            elif model == 'sensor_motion.aq2':
+                devices.append(XiaomiMotionSensor(device, hass, gateway))
+            elif model == 'magnet':
+                devices.append(XiaomiDoorSensor(device, gateway))
+            elif model == 'sensor_magnet.aq2':
+                devices.append(XiaomiDoorSensor(device, gateway))
+            elif model == 'sensor_wleak.aq1':
+                devices.append(XiaomiWaterLeakSensor(device, gateway))
+            elif model == 'smoke':
+                devices.append(XiaomiSmokeSensor(device, gateway))
+            elif model == 'natgas':
+                devices.append(XiaomiNatgasSensor(device, gateway))
+            elif model == 'switch':
+                devices.append(XiaomiButton(device, 'Switch', 'status',
+                                            hass, gateway))
+            elif model == 'sensor_switch.aq2':
+                devices.append(XiaomiButton(device, 'Switch', 'status',
+                                            hass, gateway))
+            elif model == '86sw1':
+                devices.append(XiaomiButton(device, 'Wall Switch', 'channel_0',
+                                            hass, gateway))
+            elif model == '86sw2':
+                devices.append(XiaomiButton(device, 'Wall Switch (Left)',
+                                            'channel_0', hass, gateway))
+                devices.append(XiaomiButton(device, 'Wall Switch (Right)',
+                                            'channel_1', hass, gateway))
+                devices.append(XiaomiButton(device, 'Wall Switch (Both)',
+                                            'dual_channel', hass, gateway))
+            elif model == 'cube':
+                devices.append(XiaomiCube(device, hass, gateway))
+    add_devices(devices)
+
+
+class XiaomiBinarySensor(XiaomiDevice, BinarySensorDevice):
+    """Representation of a base XiaomiBinarySensor."""
+
+    def __init__(self, device, name, xiaomi_hub, data_key, device_class):
+        """Initialize the XiaomiSmokeSensor."""
+        self._data_key = data_key
+        self._device_class = device_class
+        self._should_poll = False
+        self._density = 0
+        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+
+    @property
+    def should_poll(self):
+        """Return True if entity has to be polled for state."""
+        return self._should_poll
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._state
+
+    @property
+    def device_class(self):
+        """Return the class of binary sensor."""
+        return self._device_class
+
+    def update(self):
+        """Update the sensor state."""
+        _LOGGER.debug('Updating xiaomi sensor by polling')
+        self._get_from_hub(self._sid)
+
+
+class XiaomiNatgasSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiNatgasSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiSmokeSensor."""
+        self._density = None
+        XiaomiBinarySensor.__init__(self, device, 'Natgas Sensor', xiaomi_hub,
+                                    'alarm', 'gas')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_DENSITY: self._density}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if DENSITY in data:
+            self._density = int(data.get(DENSITY))
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == '1':
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == '0':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiMotionSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiMotionSensor."""
+
+    def __init__(self, device, hass, xiaomi_hub):
+        """Initialize the XiaomiMotionSensor."""
+        self._hass = hass
+        self._no_motion_since = 0
+        XiaomiBinarySensor.__init__(self, device, 'Motion Sensor', xiaomi_hub,
+                                    'status', 'motion')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_NO_MOTION_SINCE: self._no_motion_since}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+        if NO_MOTION in data:  # handle push from the hub
+            self._no_motion_since = data[NO_MOTION]
+            self._state = False
+            return True
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == MOTION:
+            self._should_poll = True
+            if self.entity_id is not None:
+                self._hass.bus.fire('motion', {
+                    'entity_id': self.entity_id
+                })
+
+            self._no_motion_since = 0
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == NO_MOTION:
+            if not self._state:
+                return False
+            self._state = False
+            return True
+
+
+class XiaomiDoorSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiDoorSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiDoorSensor."""
+        self._open_since = 0
+        XiaomiBinarySensor.__init__(self, device, 'Door Window Sensor',
+                                    xiaomi_hub, 'status', 'opening')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_OPEN_SINCE: self._open_since}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+        if NO_CLOSE in data:  # handle push from the hub
+            self._open_since = data[NO_CLOSE]
+            return True
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'open':
+            self._should_poll = True
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == 'close':
+            self._open_since = 0
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiWaterLeakSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiWaterLeakSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiWaterLeakSensor."""
+        XiaomiBinarySensor.__init__(self, device, 'Water Leak Sensor',
+                                    xiaomi_hub, 'status', 'moisture')
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'leak':
+            self._should_poll = True
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == 'no_leak':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiSmokeSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiSmokeSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiSmokeSensor."""
+        self._density = 0
+        XiaomiBinarySensor.__init__(self, device, 'Smoke Sensor', xiaomi_hub,
+                                    'alarm', 'smoke')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_DENSITY: self._density}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if DENSITY in data:
+            self._density = int(data.get(DENSITY))
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == '1':
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == '0':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiButton(XiaomiBinarySensor):
+    """Representation of a Xiaomi Button."""
+
+    def __init__(self, device, name, data_key, hass, xiaomi_hub):
+        """Initialize the XiaomiButton."""
+        self._hass = hass
+        XiaomiBinarySensor.__init__(self, device, name, xiaomi_hub,
+                                    data_key, None)
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'long_click_press':
+            self._state = True
+            click_type = 'long_click_press'
+        elif value == 'long_click_release':
+            self._state = False
+            click_type = 'hold'
+        elif value == 'click':
+            click_type = 'single'
+        elif value == 'double_click':
+            click_type = 'double'
+        elif value == 'both_click':
+            click_type = 'both'
+        else:
+            return False
+
+        self._hass.bus.fire('click', {
+            'entity_id': self.entity_id,
+            'click_type': click_type
+        })
+        if value in ['long_click_press', 'long_click_release']:
+            return True
+        return False
+
+
+class XiaomiCube(XiaomiBinarySensor):
+    """Representation of a Xiaomi Cube."""
+
+    def __init__(self, device, hass, xiaomi_hub):
+        """Initialize the Xiaomi Cube."""
+        self._hass = hass
+        self._state = False
+        XiaomiBinarySensor.__init__(self, device, 'Cube', xiaomi_hub,
+                                    None, None)
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if 'status' in data:
+            self._hass.bus.fire('cube_action', {
+                'entity_id': self.entity_id,
+                'action_type': data['status']
+            })
+
+        if 'rotate' in data:
+            self._hass.bus.fire('cube_action', {
+                'entity_id': self.entity_id,
+                'action_type': 'rotate',
+                'action_value': float(data['rotate'].replace(",", "."))
+            })
+        return False
@@ -23,9 +23,7 @@ def get_device(values, **kwargs):
    """Create Z-Wave entity device."""
    device_mapping = workaround.get_device_mapping(values.primary)
    if device_mapping == workaround.WORKAROUND_NO_OFF_EVENT:
-        # Default the multiplier to 4
-        re_arm_multiplier = zwave.get_config_value(values.primary.node, 9) or 4
-        return ZWaveTriggerSensor(values, "motion", re_arm_multiplier * 8)
+        return ZWaveTriggerSensor(values, "motion")

    if workaround.get_device_component_mapping(values.primary) == DOMAIN:
        return ZWaveBinarySensor(values, None)
@@ -62,15 +60,21 @@ class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity):
 class ZWaveTriggerSensor(ZWaveBinarySensor):
    """Representation of a stateless sensor within Z-Wave."""

-    def __init__(self, values, device_class, re_arm_sec=60):
+    def __init__(self, values, device_class):
        """Initialize the sensor."""
        super(ZWaveTriggerSensor, self).__init__(values, device_class)
-        self.re_arm_sec = re_arm_sec
+        # Set default off delay to 60 sec
+        self.re_arm_sec = 60
        self.invalidate_after = None

    def update_properties(self):
        """Handle value changes for this entity's node."""
        self._state = self.values.primary.data
+        _LOGGER.debug('off_delay=%s', self.values.off_delay)
+        # Set re_arm_sec if off_delay is provided from the sensor
+        if self.values.off_delay:
+            _LOGGER.debug('off_delay.data=%s', self.values.off_delay.data)
+            self.re_arm_sec = self.values.off_delay.data * 8
        # only allow this value to be true for re_arm secs
        if not self.hass:
            return
@@ -23,6 +23,7 @@ from homeassistant.core import callback
 from homeassistant.const import (ATTR_ENTITY_ID, ATTR_ENTITY_PICTURE)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
@@ -55,6 +56,7 @@ CAMERA_SERVICE_SCHEMA = vol.Schema({
 })


+@bind_hass
 def enable_motion_detection(hass, entity_id=None):
    """Enable Motion Detection."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
@@ -62,6 +64,7 @@ def enable_motion_detection(hass, entity_id=None):
        DOMAIN, SERVICE_EN_MOTION, data))


+@bind_hass
 def disable_motion_detection(hass, entity_id=None):
    """Disable Motion Detection."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
@@ -6,7 +6,6 @@ https://home-assistant.io/components/camera.foscam/
 """
 import logging

-import requests
 import voluptuous as vol

 from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
@@ -16,11 +15,15 @@ from homeassistant.helpers import config_validation as cv

 _LOGGER = logging.getLogger(__name__)

+REQUIREMENTS = ['libpyfoscam==1.0']
+
 CONF_IP = 'ip'

 DEFAULT_NAME = 'Foscam Camera'
 DEFAULT_PORT = 88

+FOSCAM_COMM_ERROR = -8
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_IP): cv.string,
    vol.Required(CONF_PASSWORD): cv.string,
@@ -33,46 +36,60 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up a Foscam IP Camera."""
-    add_devices([FoscamCamera(config)])
+    add_devices([FoscamCam(config)])


-class FoscamCamera(Camera):
+class FoscamCam(Camera):
    """An implementation of a Foscam IP camera."""

    def __init__(self, device_info):
        """Initialize a Foscam camera."""
-        super(FoscamCamera, self).__init__()
+        super(FoscamCam, self).__init__()

        ip_address = device_info.get(CONF_IP)
        port = device_info.get(CONF_PORT)
-
-        self._base_url = 'http://{}:{}/'.format(ip_address, port)
-
-        uri_template = self._base_url \
-            + 'cgi-bin/CGIProxy.fcgi?' \
-            + 'cmd=snapPicture2&usr={}&pwd={}'
-
        self._username = device_info.get(CONF_USERNAME)
        self._password = device_info.get(CONF_PASSWORD)
-        self._snap_picture_url = uri_template.format(
-            self._username,
-            self._password
-        )
        self._name = device_info.get(CONF_NAME)
+        self._motion_status = False

-        _LOGGER.info("Using the following URL for %s: %s",
-                     self._name, uri_template.format('***', '***'))
+        from libpyfoscam import FoscamCamera
+
+        self._foscam_session = FoscamCamera(ip_address, port, self._username,
+                                            self._password, verbose=False)

    def camera_image(self):
        """Return a still image reponse from the camera."""
        # Send the request to snap a picture and return raw jpg data
        # Handle exception if host is not reachable or url failed
-        try:
-            response = requests.get(self._snap_picture_url, timeout=10)
-        except requests.exceptions.ConnectionError:
+        result, response = self._foscam_session.snap_picture_2()
+        if result == FOSCAM_COMM_ERROR:
            return None
+
+        return response
+
+    @property
+    def motion_detection_enabled(self):
+        """Camera Motion Detection Status."""
+        return self._motion_status
+
+    def enable_motion_detection(self):
+        """Enable motion detection in camera."""
+        ret, err = self._foscam_session.enable_motion_detection()
+        if ret == FOSCAM_COMM_ERROR:
+            _LOGGER.debug("Unable to communicate with Foscam Camera: %s", err)
+            self._motion_status = True
        else:
-            return response.content
+            self._motion_status = False
+
+    def disable_motion_detection(self):
+        """Disable motion detection."""
+        ret, err = self._foscam_session.disable_motion_detection()
+        if ret == FOSCAM_COMM_ERROR:
+            _LOGGER.debug("Unable to communicate with Foscam Camera: %s", err)
+            self._motion_status = True
+        else:
+            self._motion_status = False

    @property
    def name(self):
@@ -6,6 +6,7 @@ https://home-assistant.io/components/camera.onvif/
 """
 import asyncio
 import logging
+import os

 import voluptuous as vol

@@ -54,6 +55,7 @@ class ONVIFCamera(Camera):
    def __init__(self, hass, config):
        """Initialize a ONVIF camera."""
        from onvif import ONVIFService
+        import onvif
        super().__init__()

        self._name = config.get(CONF_NAME)
@@ -63,7 +65,7 @@ class ONVIFCamera(Camera):
                config.get(CONF_HOST), config.get(CONF_PORT)),
            config.get(CONF_USERNAME),
            config.get(CONF_PASSWORD),
-            '{}/deps/onvif/wsdl/media.wsdl'.format(hass.config.config_dir)
+            '{}/wsdl/media.wsdl'.format(os.path.dirname(onvif.__file__))
        )
        self._input = media.GetStreamUri().Uri
        _LOGGER.debug("ONVIF Camera Using the following URL for %s: %s",
@@ -0,0 +1,94 @@
+"""
+Support for a camera made up of usps mail images.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/camera.usps/
+"""
+from datetime import timedelta
+import logging
+
+from homeassistant.components.camera import Camera
+from homeassistant.components.usps import DATA_USPS
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['usps']
+
+SCAN_INTERVAL = timedelta(seconds=10)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up USPS mail camera."""
+    if discovery_info is None:
+        return
+
+    usps = hass.data[DATA_USPS]
+    add_devices([USPSCamera(usps)])
+
+
+class USPSCamera(Camera):
+    """Representation of the images available from USPS."""
+
+    def __init__(self, usps):
+        """Initialize the USPS camera images."""
+        super().__init__()
+
+        self._usps = usps
+        self._name = self._usps.name
+        self._session = self._usps.session
+
+        self._mail_img = []
+        self._last_mail = None
+        self._mail_index = 0
+        self._mail_count = 0
+
+        self._timer = None
+
+    def camera_image(self):
+        """Update the camera's image if it has changed."""
+        self._usps.update()
+        try:
+            self._mail_count = len(self._usps.mail)
+        except TypeError:
+            # No mail
+            return None
+
+        if self._usps.mail != self._last_mail:
+            # Mail items must have changed
+            self._mail_img = []
+            if len(self._usps.mail) >= 1:
+                self._last_mail = self._usps.mail
+                for article in self._usps.mail:
+                    _LOGGER.debug("Fetching article image: %s", article)
+                    img = self._session.get(article['image']).content
+                    self._mail_img.append(img)
+
+        try:
+            return self._mail_img[self._mail_index]
+        except IndexError:
+            return None
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return '{} mail'.format(self._name)
+
+    @property
+    def model(self):
+        """Return date of mail as model."""
+        try:
+            return 'Date: {}'.format(self._usps.mail[0]['date'])
+        except IndexError:
+            return None
+
+    @property
+    def should_poll(self):
+        """Update the mail image index periodically."""
+        return True
+
+    def update(self):
+        """Update mail image index."""
+        if self._mail_index < (self._mail_count - 1):
+            self._mail_index += 1
+        else:
+            self._mail_index = 0
@@ -14,6 +14,7 @@ from numbers import Number
 import voluptuous as vol

 from homeassistant.config import load_yaml_config_file
+from homeassistant.loader import bind_hass
 from homeassistant.util.temperature import convert as convert_temperature
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
@@ -85,13 +86,17 @@ SET_AUX_HEAT_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Required(ATTR_AUX_HEAT): cv.boolean,
 })
-SET_TEMPERATURE_SCHEMA = vol.Schema({
-    vol.Exclusive(ATTR_TEMPERATURE, 'temperature'): vol.Coerce(float),
-    vol.Inclusive(ATTR_TARGET_TEMP_HIGH, 'temperature'): vol.Coerce(float),
-    vol.Inclusive(ATTR_TARGET_TEMP_LOW, 'temperature'): vol.Coerce(float),
-    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-    vol.Optional(ATTR_OPERATION_MODE): cv.string,
-})
+SET_TEMPERATURE_SCHEMA = vol.Schema(vol.All(
+    cv.has_at_least_one_key(
+        ATTR_TEMPERATURE, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW),
+    {
+        vol.Exclusive(ATTR_TEMPERATURE, 'temperature'): vol.Coerce(float),
+        vol.Inclusive(ATTR_TARGET_TEMP_HIGH, 'temperature'): vol.Coerce(float),
+        vol.Inclusive(ATTR_TARGET_TEMP_LOW, 'temperature'): vol.Coerce(float),
+        vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+        vol.Optional(ATTR_OPERATION_MODE): cv.string,
+    }
+))
 SET_FAN_MODE_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Required(ATTR_FAN_MODE): cv.string,
@@ -114,6 +119,7 @@ SET_SWING_MODE_SCHEMA = vol.Schema({
 })


+@bind_hass
 def set_away_mode(hass, away_mode, entity_id=None):
    """Turn all or specified climate devices away mode on."""
    data = {
@@ -126,6 +132,7 @@ def set_away_mode(hass, away_mode, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_AWAY_MODE, data)


+@bind_hass
 def set_hold_mode(hass, hold_mode, entity_id=None):
    """Set new hold mode."""
    data = {
@@ -138,6 +145,7 @@ def set_hold_mode(hass, hold_mode, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_HOLD_MODE, data)


+@bind_hass
 def set_aux_heat(hass, aux_heat, entity_id=None):
    """Turn all or specified climate devices auxillary heater on."""
    data = {
@@ -150,6 +158,7 @@ def set_aux_heat(hass, aux_heat, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_AUX_HEAT, data)


+@bind_hass
 def set_temperature(hass, temperature=None, entity_id=None,
                    target_temp_high=None, target_temp_low=None,
                    operation_mode=None):
@@ -167,6 +176,7 @@ def set_temperature(hass, temperature=None, entity_id=None,
    hass.services.call(DOMAIN, SERVICE_SET_TEMPERATURE, kwargs)


+@bind_hass
 def set_humidity(hass, humidity, entity_id=None):
    """Set new target humidity."""
    data = {ATTR_HUMIDITY: humidity}
@@ -177,6 +187,7 @@ def set_humidity(hass, humidity, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_HUMIDITY, data)


+@bind_hass
 def set_fan_mode(hass, fan, entity_id=None):
    """Set all or specified climate devices fan mode on."""
    data = {ATTR_FAN_MODE: fan}
@@ -187,6 +198,7 @@ def set_fan_mode(hass, fan, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_FAN_MODE, data)


+@bind_hass
 def set_operation_mode(hass, operation_mode, entity_id=None):
    """Set new target operation mode."""
    data = {ATTR_OPERATION_MODE: operation_mode}
@@ -197,6 +209,7 @@ def set_operation_mode(hass, operation_mode, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_OPERATION_MODE, data)


+@bind_hass
 def set_swing_mode(hass, swing_mode, entity_id=None):
    """Set new target swing mode."""
    data = {ATTR_SWING_MODE: swing_mode}
@@ -47,8 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    devices = []
    for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMThermostat(hass, conf)
-        new_device.link_homematic()
+        new_device = HMThermostat(conf)
        devices.append(new_device)

    add_devices(devices)
@@ -75,7 +75,8 @@ def _setup_round(username, password, config, add_devices):
        zones = evo_api.temperatures(force_refresh=True)
        for i, zone in enumerate(zones):
            add_devices(
-                [RoundThermostat(evo_api, zone['id'], i == 0, away_temp)]
+                [RoundThermostat(evo_api, zone['id'], i == 0, away_temp)],
+                True
            )
    except socket.error:
        _LOGGER.error(
@@ -115,9 +116,9 @@ def _setup_us(username, password, config, add_devices):
 class RoundThermostat(ClimateDevice):
    """Representation of a Honeywell Round Connected thermostat."""

-    def __init__(self, device, zone_id, master, away_temp):
+    def __init__(self, client, zone_id, master, away_temp):
        """Initialize the thermostat."""
-        self.device = device
+        self.client = client
        self._current_temperature = None
        self._target_temperature = None
        self._name = 'round connected'
@@ -126,7 +127,6 @@ class RoundThermostat(ClimateDevice):
        self._is_dhw = False
        self._away_temp = away_temp
        self._away = False
-        self.update()

    @property
    def name(self):
@@ -155,12 +155,12 @@ class RoundThermostat(ClimateDevice):
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return
-        self.device.set_temperature(self._name, temperature)
+        self.client.set_temperature(self._name, temperature)

    @property
    def current_operation(self: ClimateDevice) -> str:
        """Get the current operation of the system."""
-        return getattr(self.device, ATTR_SYSTEM_MODE, None)
+        return getattr(self.client, ATTR_SYSTEM_MODE, None)

    @property
    def is_away_mode_on(self):
@@ -169,8 +169,8 @@ class RoundThermostat(ClimateDevice):

    def set_operation_mode(self: ClimateDevice, operation_mode: str) -> None:
        """Set the HVAC mode for the thermostat."""
-        if hasattr(self.device, ATTR_SYSTEM_MODE):
-            self.device.system_mode = operation_mode
+        if hasattr(self.client, ATTR_SYSTEM_MODE):
+            self.client.system_mode = operation_mode

    def turn_away_mode_on(self):
        """Turn away on.
@@ -180,22 +180,27 @@ class RoundThermostat(ClimateDevice):
        it doesn't get overwritten when away mode is switched on.
        """
        self._away = True
-        self.device.set_temperature(self._name, self._away_temp)
+        self.client.set_temperature(self._name, self._away_temp)

    def turn_away_mode_off(self):
        """Turn away off."""
        self._away = False
-        self.device.cancel_temp_override(self._name)
+        self.client.cancel_temp_override(self._name)

    def update(self):
        """Get the latest date."""
        try:
            # Only refresh if this is the "master" device,
            # others will pick up the cache
-            for val in self.device.temperatures(force_refresh=self._master):
+            for val in self.client.temperatures(force_refresh=self._master):
                if val['id'] == self._id:
                    data = val

+        except KeyError:
+            _LOGGER.error("Update failed from Honeywell server")
+            self.client.user_data = None
+            return
+
        except StopIteration:
            _LOGGER.error("Did not receive any temperature data from the "
                          "evohomeclient API")
@@ -210,6 +215,12 @@ class RoundThermostat(ClimateDevice):
            self._name = data['name']
            self._is_dhw = False

+            # The underlying library doesn't expose the thermostat's mode
+            # but we can pull it out of the big dictionary of information.
+            device = self.client.devices[self._id]
+            self.client.system_mode = device[
+                'thermostat']['changeableValues']['mode']
+

 class HoneywellUSThermostat(ClimateDevice):
    """Representation of a Honeywell US Thermostat."""
@@ -1,68 +1,136 @@
 """
-Support for KNX thermostats.
+Support for KNX/IP climate devices.

-For more details about this platform, please refer to the documentation
+For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.knx/
 """
-import logging
-
+import asyncio
 import voluptuous as vol

-from homeassistant.components.climate import (ClimateDevice, PLATFORM_SCHEMA)
-from homeassistant.components.knx import (KNXConfig, KNXMultiAddressDevice)
-from homeassistant.const import (CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE)
+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
+from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateDevice
+from homeassistant.const import CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv

-_LOGGER = logging.getLogger(__name__)
-
-CONF_ADDRESS = 'address'
 CONF_SETPOINT_ADDRESS = 'setpoint_address'
 CONF_TEMPERATURE_ADDRESS = 'temperature_address'
+CONF_TARGET_TEMPERATURE_ADDRESS = 'target_temperature_address'
+CONF_OPERATION_MODE_ADDRESS = 'operation_mode_address'
+CONF_OPERATION_MODE_STATE_ADDRESS = 'operation_mode_state_address'
+CONF_CONTROLLER_STATUS_ADDRESS = 'controller_status_address'
+CONF_CONTROLLER_STATUS_STATE_ADDRESS = 'controller_status_state_address'
+CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS = \
+    'operation_mode_frost_protection_address'
+CONF_OPERATION_MODE_NIGHT_ADDRESS = 'operation_mode_night_address'
+CONF_OPERATION_MODE_COMFORT_ADDRESS = 'operation_mode_comfort_address'

-DEFAULT_NAME = 'KNX Thermostat'
+DEFAULT_NAME = 'KNX Climate'
 DEPENDENCIES = ['knx']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ADDRESS): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Required(CONF_SETPOINT_ADDRESS): cv.string,
    vol.Required(CONF_TEMPERATURE_ADDRESS): cv.string,
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Required(CONF_TARGET_TEMPERATURE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_CONTROLLER_STATUS_ADDRESS): cv.string,
+    vol.Optional(CONF_CONTROLLER_STATUS_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_NIGHT_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_COMFORT_ADDRESS): cv.string,
 })


-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Create and add an entity based on the configuration."""
-    add_devices([KNXThermostat(hass, KNXConfig(config))])
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up climate(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
+
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True


-class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
-    """Representation of a KNX thermostat.
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up climates for KNX platform configured within plattform."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXClimate(hass, device))
+    add_devices(entities)

-    A KNX thermostat will has the following parameters:
-    - temperature (current temperature)
-    - setpoint (target temperature in HASS terms)
-    - operation mode selection (comfort/night/frost protection)

-    This version supports only polling. Messages from the KNX bus do not
-    automatically update the state of the thermostat (to be implemented
-    in future releases)
-    """
+@callback
+def async_add_devices_config(hass, config, add_devices):
+    """Set up climate for KNX platform configured within plattform."""
+    import xknx
+    climate = xknx.devices.Climate(
+        hass.data[DATA_KNX].xknx,
+        name=config.get(CONF_NAME),
+        group_address_temperature=config.get(
+            CONF_TEMPERATURE_ADDRESS),
+        group_address_target_temperature=config.get(
+            CONF_TARGET_TEMPERATURE_ADDRESS),
+        group_address_setpoint=config.get(
+            CONF_SETPOINT_ADDRESS),
+        group_address_operation_mode=config.get(
+            CONF_OPERATION_MODE_ADDRESS),
+        group_address_operation_mode_state=config.get(
+            CONF_OPERATION_MODE_STATE_ADDRESS),
+        group_address_controller_status=config.get(
+            CONF_CONTROLLER_STATUS_ADDRESS),
+        group_address_controller_status_state=config.get(
+            CONF_CONTROLLER_STATUS_STATE_ADDRESS),
+        group_address_operation_mode_protection=config.get(
+            CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS),
+        group_address_operation_mode_night=config.get(
+            CONF_OPERATION_MODE_NIGHT_ADDRESS),
+        group_address_operation_mode_comfort=config.get(
+            CONF_OPERATION_MODE_COMFORT_ADDRESS))
+    hass.data[DATA_KNX].xknx.devices.add(climate)
+    add_devices([KNXClimate(hass, climate)])

-    def __init__(self, hass, config):
-        """Initialize the thermostat based on the given configuration."""
-        KNXMultiAddressDevice.__init__(
-            self, hass, config, ['temperature', 'setpoint'], ['mode'])

-        self._unit_of_measurement = TEMP_CELSIUS  # KNX always used celsius
+class KNXClimate(ClimateDevice):
+    """Representation of a KNX climate."""
+
+    def __init__(self, hass, device):
+        """Initialization of KNXClimate."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
+
+        self._unit_of_measurement = TEMP_CELSIUS
        self._away = False  # not yet supported
        self._is_fan_on = False  # not yet supported
-        self._current_temp = None
-        self._target_temp = None
+
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name

    @property
    def should_poll(self):
-        """Return the polling state, is needed for the KNX thermostat."""
-        return True
+        """No polling needed within KNX."""
+        return False

    @property
    def temperature_unit(self):
@@ -72,32 +140,42 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
    @property
    def current_temperature(self):
        """Return the current temperature."""
-        return self._current_temp
+        return self.device.temperature

    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
-        return self._target_temp
+        if self.device.supports_target_temperature:
+            return self.device.target_temperature
+        return None

-    def set_temperature(self, **kwargs):
+    @asyncio.coroutine
+    def async_set_temperature(self, **kwargs):
        """Set new target temperature."""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return
-        from knxip.conversion import float_to_knx2
+        if self.device.supports_target_temperature:
+            yield from self.device.set_target_temperature(temperature)

-        self.set_value('setpoint', float_to_knx2(temperature))
-        _LOGGER.debug("Set target temperature to %s", temperature)
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if self.device.supports_operation_mode:
+            return self.device.operation_mode.value
+        return None

-    def set_operation_mode(self, operation_mode):
+    @property
+    def operation_list(self):
+        """Return the list of available operation modes."""
+        return [operation_mode.value for
+                operation_mode in
+                self.device.get_supported_operation_modes()]
+
+    @asyncio.coroutine
+    def async_set_operation_mode(self, operation_mode):
        """Set operation mode."""
-        raise NotImplementedError()
-
-    def update(self):
-        """Update KNX climate."""
-        from knxip.conversion import knx2_to_float
-
-        super().update()
-
-        self._current_temp = knx2_to_float(self.value('temperature'))
-        self._target_temp = knx2_to_float(self.value('setpoint'))
+        if self.device.supports_operation_mode:
+            from xknx.knx import HVACOperationMode
+            knx_operation_mode = HVACOperationMode(operation_mode)
+            yield from self.device.set_operation_mode(knx_operation_mode)
@@ -10,7 +10,6 @@ import logging
 from homeassistant.components.climate import ClimateDevice, STATE_AUTO
 from homeassistant.components.maxcube import MAXCUBE_HANDLE
 from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
-from homeassistant.const import STATE_UNKNOWN

 _LOGGER = logging.getLogger(__name__)

@@ -140,7 +139,7 @@ class MaxCubeClimate(ClimateDevice):
    def map_temperature_max_hass(temperature):
        """Map Temperature from MAX! to HASS."""
        if temperature is None:
-            return STATE_UNKNOWN
+            return 0.0

        return temperature

@@ -4,15 +4,11 @@ MySensors platform that offers a Climate (MySensors-HVAC) component.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/climate.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
 from homeassistant.components.climate import (
-    STATE_COOL, STATE_HEAT, STATE_OFF, STATE_AUTO, ClimateDevice,
-    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW)
-from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
-
-_LOGGER = logging.getLogger(__name__)
+    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW, DOMAIN, STATE_AUTO,
+    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice)
+from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT

 DICT_HA_TO_MYS = {
    STATE_AUTO: 'AutoChangeOver',
@@ -29,28 +25,12 @@ DICT_MYS_TO_HA = {


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the mysensors climate."""
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        if float(gateway.protocol_version) < 1.5:
-            continue
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_HVAC: [set_req.V_HVAC_FLOW_STATE],
-        }
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsHVAC, add_devices))
+    """Setup the mysensors climate."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsHVAC, add_devices=add_devices)


-class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
+class MySensorsHVAC(mysensors.MySensorsEntity, ClimateDevice):
    """Representation of a MySensors HVAC."""

    @property
@@ -84,26 +64,28 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        temp = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
        if temp is None:
            temp = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
-        return float(temp)
+        return float(temp) if temp is not None else None

    @property
    def target_temperature_high(self):
        """Return the highbound target temperature we try to reach."""
        set_req = self.gateway.const.SetReq
        if set_req.V_HVAC_SETPOINT_HEAT in self._values:
-            return float(self._values.get(set_req.V_HVAC_SETPOINT_COOL))
+            temp = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
+            return float(temp) if temp is not None else None

    @property
    def target_temperature_low(self):
        """Return the lowbound target temperature we try to reach."""
        set_req = self.gateway.const.SetReq
        if set_req.V_HVAC_SETPOINT_COOL in self._values:
-            return float(self._values.get(set_req.V_HVAC_SETPOINT_HEAT))
+            temp = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
+            return float(temp) if temp is not None else None

    @property
    def current_operation(self):
        """Return current operation ie. heat, cool, idle."""
-        return self._values.get(self.gateway.const.SetReq.V_HVAC_FLOW_STATE)
+        return self._values.get(self.value_type)

    @property
    def operation_list(self):
@@ -128,7 +110,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
        heat = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
        cool = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
-        updates = ()
+        updates = []
        if temp is not None:
            if heat is not None:
                # Set HEAT Target temperature
@@ -146,7 +128,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
            self.gateway.set_child_value(
                self.node_id, self.child_id, value_type, value)
            if self.gateway.optimistic:
-                # optimistically assume that switch has changed state
+                # optimistically assume that device has changed state
                self._values[value_type] = value
                self.schedule_update_ha_state()

@@ -156,54 +138,22 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        self.gateway.set_child_value(
            self.node_id, self.child_id, set_req.V_HVAC_SPEED, fan)
        if self.gateway.optimistic:
-            # optimistically assume that switch has changed state
+            # optimistically assume that device has changed state
            self._values[set_req.V_HVAC_SPEED] = fan
            self.schedule_update_ha_state()

    def set_operation_mode(self, operation_mode):
        """Set new target temperature."""
-        set_req = self.gateway.const.SetReq
        self.gateway.set_child_value(
-            self.node_id, self.child_id, set_req.V_HVAC_FLOW_STATE,
+            self.node_id, self.child_id, self.value_type,
            DICT_HA_TO_MYS[operation_mode])
        if self.gateway.optimistic:
-            # optimistically assume that switch has changed state
-            self._values[set_req.V_HVAC_FLOW_STATE] = operation_mode
+            # optimistically assume that device has changed state
+            self._values[self.value_type] = operation_mode
            self.schedule_update_ha_state()

    def update(self):
        """Update the controller with the latest value from a sensor."""
-        set_req = self.gateway.const.SetReq
-        node = self.gateway.sensors[self.node_id]
-        child = node.children[self.child_id]
-        for value_type, value in child.values.items():
-            _LOGGER.debug(
-                "%s: value_type %s, value = %s", self._name, value_type, value)
-            if value_type == set_req.V_HVAC_FLOW_STATE:
-                self._values[value_type] = DICT_MYS_TO_HA[value]
-            else:
-                self._values[value_type] = value
-
-    def set_humidity(self, humidity):
-        """Set new target humidity."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def set_swing_mode(self, swing_mode):
-        """Set new target swing operation."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_away_mode_on(self):
-        """Turn away mode on."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_away_mode_off(self):
-        """Turn away mode off."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_aux_heat_on(self):
-        """Turn auxillary heater on."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_aux_heat_off(self):
-        """Turn auxillary heater off."""
-        _LOGGER.error("Service Not Implemented yet")
+        super().update()
+        self._values[self.value_type] = DICT_MYS_TO_HA[
+            self._values[self.value_type]]
@@ -36,7 +36,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-def setup_platform(hass, config, add_callback_devices, discovery_info=None):
+def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the NetAtmo Thermostat."""
    netatmo = get_component('netatmo')
    device = config.get(CONF_RELAY)
@@ -49,7 +49,7 @@ def setup_platform(hass, config, add_callback_devices, discovery_info=None):
                if config[CONF_THERMOSTAT] != [] and \
                   module_name not in config[CONF_THERMOSTAT]:
                    continue
-            add_callback_devices([NetatmoThermostat(data, module_name)])
+            add_devices([NetatmoThermostat(data, module_name)], True)
    except lnetatmo.NoDevice:
        return None

@@ -64,7 +64,6 @@ class NetatmoThermostat(ClimateDevice):
        self._name = module_name
        self._target_temperature = None
        self._away = None
-        self.update()

    @property
    def name(self):
@@ -68,7 +68,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            _LOGGER.exception("Unable to connect to Radio Thermostat: %s",
                              host)

-    add_devices(tstats)
+    add_devices(tstats, True)


 class RadioThermostat(ClimateDevice):
@@ -89,7 +89,6 @@ class RadioThermostat(ClimateDevice):
        self._away = False
        self._away_temps = away_temps
        self._prev_temp = None
-        self.update()
        self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]

    @property
@@ -273,31 +273,38 @@ class TadoClimate(ClimateDevice):
            else:
                self._device_is_active = True

+        overlay = False
+        overlay_data = None
+        termination = self._current_operation
+        cooling = False
+        fan_speed = CONST_MODE_OFF
+
+        if 'overlay' in data:
+            overlay_data = data['overlay']
+            overlay = overlay_data is not None
+
+        if overlay:
+            termination = overlay_data['termination']['type']
+
+            if 'setting' in overlay_data:
+                setting_data = overlay_data['setting']
+                setting = setting_data is not None
+
+            if setting:
+                if 'mode' in setting_data:
+                    cooling = setting_data['mode'] == 'COOL'
+
+                if 'fanSpeed' in setting_data:
+                    fan_speed = setting_data['fanSpeed']
+
        if self._device_is_active:
-            overlay = False
-            overlay_data = None
-            termination = self._current_operation
-            cooling = False
-            fan_speed = CONST_MODE_OFF
-
-            if 'overlay' in data:
-                overlay_data = data['overlay']
-                overlay = overlay_data is not None
-
-            if overlay:
-                termination = overlay_data['termination']['type']
-
-                if 'setting' in overlay_data:
-                    cooling = overlay_data['setting']['mode'] == 'COOL'
-                    fan_speed = overlay_data['setting']['fanSpeed']
-
            # If you set mode manualy to off, there will be an overlay
            # and a termination, but we want to see the mode "OFF"
-
            self._overlay_mode = termination
            self._current_operation = termination
-            self._cooling = cooling
-            self._current_fan = fan_speed
+
+        self._cooling = cooling
+        self._current_fan = fan_speed

    def _control_heating(self):
        """Send new target temperature to mytado."""
@@ -0,0 +1,93 @@
+"""
+Support for Tesla HVAC system.
+
+For more details about this platform, please refer to the documentation
+https://home-assistant.io/components/climate.tesla/
+"""
+import logging
+
+from homeassistant.const import STATE_ON, STATE_OFF
+from homeassistant.components.climate import ClimateDevice, ENTITY_ID_FORMAT
+from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
+from homeassistant.const import (
+    TEMP_FAHRENHEIT, TEMP_CELSIUS, ATTR_TEMPERATURE)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+OPERATION_LIST = [STATE_ON, STATE_OFF]
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Tesla climate platform."""
+    devices = [TeslaThermostat(device, hass.data[TESLA_DOMAIN]['controller'])
+               for device in hass.data[TESLA_DOMAIN]['devices']['climate']]
+    add_devices(devices, True)
+
+
+class TeslaThermostat(TeslaDevice, ClimateDevice):
+    """Representation of a Tesla climate."""
+
+    def __init__(self, tesla_device, controller):
+        """Initialize the Tesla device."""
+        super().__init__(tesla_device, controller)
+        self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
+        self._target_temperature = None
+        self._temperature = None
+        self._name = self.tesla_device.name
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. On or Off."""
+        mode = self.tesla_device.is_hvac_enabled()
+        if mode:
+            return OPERATION_LIST[0]  # On
+        else:
+            return OPERATION_LIST[1]  # Off
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return OPERATION_LIST
+
+    def update(self):
+        """Called by the Tesla device callback to update state."""
+        _LOGGER.debug("Updating: %s", self._name)
+        self.tesla_device.update()
+        self._target_temperature = self.tesla_device.get_goal_temp()
+        self._temperature = self.tesla_device.get_current_temp()
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        tesla_temp_units = self.tesla_device.measurement
+
+        if tesla_temp_units == 'F':
+            return TEMP_FAHRENHEIT
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._temperature
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temperature
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperatures."""
+        _LOGGER.debug("Setting temperature for: %s", self._name)
+        temperature = kwargs.get(ATTR_TEMPERATURE)
+        if temperature:
+            self.tesla_device.set_temperature(temperature)
+
+    def set_operation_mode(self, operation_mode):
+        """Set HVAC mode (auto, cool, heat, off)."""
+        _LOGGER.debug("Setting mode for: %s", self._name)
+        if operation_mode == OPERATION_LIST[1]:  # off
+            self.tesla_device.set_status(False)
+        elif operation_mode == OPERATION_LIST[0]:  # heat
+            self.tesla_device.set_status(True)
@@ -0,0 +1,49 @@
+"""Component to integrate the Home Assistant cloud."""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from . import http_api, cloud_api
+from .const import DOMAIN
+
+
+DEPENDENCIES = ['http']
+CONF_MODE = 'mode'
+MODE_DEV = 'development'
+MODE_STAGING = 'staging'
+MODE_PRODUCTION = 'production'
+DEFAULT_MODE = MODE_DEV
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Optional(CONF_MODE, default=DEFAULT_MODE):
+        vol.In([MODE_DEV, MODE_STAGING, MODE_PRODUCTION]),
+    }),
+}, extra=vol.ALLOW_EXTRA)
+_LOGGER = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Initialize the Home Assistant cloud."""
+    mode = MODE_PRODUCTION
+
+    if DOMAIN in config:
+        mode = config[DOMAIN].get(CONF_MODE)
+
+    if mode != 'development':
+        _LOGGER.error('Only development mode is currently allowed.')
+        return False
+
+    data = hass.data[DOMAIN] = {
+        'mode': mode
+    }
+
+    cloud = yield from cloud_api.async_load_auth(hass)
+
+    if cloud is not None:
+        data['cloud'] = cloud
+
+    yield from http_api.async_setup(hass)
+    return True
@@ -0,0 +1,297 @@
+"""Package to offer tools to communicate with the cloud."""
+import asyncio
+from datetime import timedelta
+import json
+import logging
+import os
+from urllib.parse import urljoin
+
+import aiohttp
+import async_timeout
+
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.util.dt import utcnow
+
+from .const import AUTH_FILE, REQUEST_TIMEOUT, SERVERS
+from .util import get_mode
+
+_LOGGER = logging.getLogger(__name__)
+
+
+URL_CREATE_TOKEN = 'o/token/'
+URL_REVOKE_TOKEN = 'o/revoke_token/'
+URL_ACCOUNT = 'account.json'
+
+
+class CloudError(Exception):
+    """Base class for cloud related errors."""
+
+    def __init__(self, reason=None, status=None):
+        """Initialize a cloud error."""
+        super().__init__(reason)
+        self.status = status
+
+
+class Unauthenticated(CloudError):
+    """Raised when authentication failed."""
+
+
+class UnknownError(CloudError):
+    """Raised when an unknown error occurred."""
+
+
+@asyncio.coroutine
+def async_load_auth(hass):
+    """Load authentication from disk and verify it."""
+    auth = yield from hass.async_add_job(_read_auth, hass)
+
+    if not auth:
+        return None
+
+    cloud = Cloud(hass, auth)
+
+    try:
+        with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+            auth_check = yield from cloud.async_refresh_account_info()
+
+            if not auth_check:
+                _LOGGER.error('Unable to validate credentials.')
+                return None
+
+            return cloud
+
+    except asyncio.TimeoutError:
+        _LOGGER.error('Unable to reach server to validate credentials.')
+        return None
+
+
+@asyncio.coroutine
+def async_login(hass, username, password, scope=None):
+    """Get a token using a username and password.
+
+    Returns a coroutine.
+    """
+    data = {
+        'grant_type': 'password',
+        'username': username,
+        'password': password
+    }
+    if scope is not None:
+        data['scope'] = scope
+
+    auth = yield from _async_get_token(hass, data)
+
+    yield from hass.async_add_job(_write_auth, hass, auth)
+
+    return Cloud(hass, auth)
+
+
+@asyncio.coroutine
+def _async_get_token(hass, data):
+    """Get a new token and return it as a dictionary.
+
+    Raises exceptions when errors occur:
+     - Unauthenticated
+     - UnknownError
+    """
+    session = async_get_clientsession(hass)
+    auth = aiohttp.BasicAuth(*_client_credentials(hass))
+
+    try:
+        req = yield from session.post(
+            _url(hass, URL_CREATE_TOKEN),
+            data=data,
+            auth=auth
+        )
+
+        if req.status == 401:
+            _LOGGER.error('Cloud login failed: %d', req.status)
+            raise Unauthenticated(status=req.status)
+        elif req.status != 200:
+            _LOGGER.error('Cloud login failed: %d', req.status)
+            raise UnknownError(status=req.status)
+
+        response = yield from req.json()
+        response['expires_at'] = \
+            (utcnow() + timedelta(seconds=response['expires_in'])).isoformat()
+
+        return response
+
+    except aiohttp.ClientError:
+        raise UnknownError()
+
+
+class Cloud:
+    """Store Hass Cloud info."""
+
+    def __init__(self, hass, auth):
+        """Initialize Hass cloud info object."""
+        self.hass = hass
+        self.auth = auth
+        self.account = None
+
+    @property
+    def access_token(self):
+        """Return access token."""
+        return self.auth['access_token']
+
+    @property
+    def refresh_token(self):
+        """Get refresh token."""
+        return self.auth['refresh_token']
+
+    @asyncio.coroutine
+    def async_refresh_account_info(self):
+        """Refresh the account info."""
+        req = yield from self.async_request('get', URL_ACCOUNT)
+
+        if req.status != 200:
+            return False
+
+        self.account = yield from req.json()
+        return True
+
+    @asyncio.coroutine
+    def async_refresh_access_token(self):
+        """Get a token using a refresh token."""
+        try:
+            self.auth = yield from _async_get_token(self.hass, {
+                'grant_type': 'refresh_token',
+                'refresh_token': self.refresh_token,
+            })
+
+            yield from self.hass.async_add_job(
+                _write_auth, self.hass, self.auth)
+
+            return True
+        except CloudError:
+            return False
+
+    @asyncio.coroutine
+    def async_revoke_access_token(self):
+        """Revoke active access token."""
+        session = async_get_clientsession(self.hass)
+        client_id, client_secret = _client_credentials(self.hass)
+        data = {
+            'token': self.access_token,
+            'client_id': client_id,
+            'client_secret': client_secret
+        }
+        try:
+            req = yield from session.post(
+                _url(self.hass, URL_REVOKE_TOKEN),
+                data=data,
+            )
+
+            if req.status != 200:
+                _LOGGER.error('Cloud logout failed: %d', req.status)
+                raise UnknownError(status=req.status)
+
+            self.auth = None
+            yield from self.hass.async_add_job(
+                _write_auth, self.hass, None)
+
+        except aiohttp.ClientError:
+            raise UnknownError()
+
+    @asyncio.coroutine
+    def async_request(self, method, path, **kwargs):
+        """Make a request to Home Assistant cloud.
+
+        Will refresh the token if necessary.
+        """
+        session = async_get_clientsession(self.hass)
+        url = _url(self.hass, path)
+
+        if 'headers' not in kwargs:
+            kwargs['headers'] = {}
+
+        kwargs['headers']['authorization'] = \
+            'Bearer {}'.format(self.access_token)
+
+        request = yield from session.request(method, url, **kwargs)
+
+        if request.status != 403:
+            return request
+
+        # Maybe token expired. Try refreshing it.
+        reauth = yield from self.async_refresh_access_token()
+
+        if not reauth:
+            return request
+
+        # Release old connection back to the pool.
+        yield from request.release()
+
+        kwargs['headers']['authorization'] = \
+            'Bearer {}'.format(self.access_token)
+
+        # If we are not already fetching the account info,
+        # refresh the account info.
+
+        if path != URL_ACCOUNT:
+            yield from self.async_refresh_account_info()
+
+        request = yield from session.request(method, url, **kwargs)
+
+        return request
+
+
+def _read_auth(hass):
+    """Read auth file."""
+    path = hass.config.path(AUTH_FILE)
+
+    if not os.path.isfile(path):
+        return None
+
+    with open(path) as file:
+        return json.load(file).get(get_mode(hass))
+
+
+def _write_auth(hass, data):
+    """Write auth info for specified mode.
+
+    Pass in None for data to remove authentication for that mode.
+    """
+    path = hass.config.path(AUTH_FILE)
+    mode = get_mode(hass)
+
+    if os.path.isfile(path):
+        with open(path) as file:
+            content = json.load(file)
+    else:
+        content = {}
+
+    if data is None:
+        content.pop(mode, None)
+    else:
+        content[mode] = data
+
+    with open(path, 'wt') as file:
+        file.write(json.dumps(content, indent=4, sort_keys=True))
+
+
+def _client_credentials(hass):
+    """Get the client credentials.
+
+    Async friendly.
+    """
+    mode = get_mode(hass)
+
+    if mode not in SERVERS:
+        raise ValueError('Mode {} is not supported.'.format(mode))
+
+    return SERVERS[mode]['client_id'], SERVERS[mode]['client_secret']
+
+
+def _url(hass, path):
+    """Generate a url for the cloud.
+
+    Async friendly.
+    """
+    mode = get_mode(hass)
+
+    if mode not in SERVERS:
+        raise ValueError('Mode {} is not supported.'.format(mode))
+
+    return urljoin(SERVERS[mode]['host'], path)
@@ -0,0 +1,14 @@
+"""Constants for the cloud component."""
+DOMAIN = 'cloud'
+REQUEST_TIMEOUT = 10
+AUTH_FILE = '.cloud'
+
+SERVERS = {
+    'development': {
+        'host': 'http://localhost:8000',
+        'client_id': 'HBhQxeV8H4aFBcs7jrZUeeDud0FjGEJJSZ9G6gNu',
+        'client_secret': ('V1qw2NhB32cSAlP7DOezjgWNgn7ZKgq0jvVZoYSI0KCmg9rg7q4'
+                          'BSzoebnQnX6tuHCJiZjm2479mZmmtf2LOUdnSqOqkSpjc3js7Wu'
+                          'VBJrRyfgTVd43kbrEQtuOiaUpK')
+    }
+}
@@ -0,0 +1,119 @@
+"""The HTTP api to control the cloud integration."""
+import asyncio
+import logging
+
+import voluptuous as vol
+import async_timeout
+
+from homeassistant.components.http import HomeAssistantView
+
+from . import cloud_api
+from .const import DOMAIN, REQUEST_TIMEOUT
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def async_setup(hass):
+    """Initialize the HTTP api."""
+    hass.http.register_view(CloudLoginView)
+    hass.http.register_view(CloudLogoutView)
+    hass.http.register_view(CloudAccountView)
+
+
+class CloudLoginView(HomeAssistantView):
+    """Login to Home Assistant cloud."""
+
+    url = '/api/cloud/login'
+    name = 'api:cloud:login'
+    schema = vol.Schema({
+        vol.Required('username'): str,
+        vol.Required('password'): str,
+    })
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Validate config and return results."""
+        try:
+            data = yield from request.json()
+        except ValueError:
+            _LOGGER.error('Login with invalid JSON')
+            return self.json_message('Invalid JSON.', 400)
+
+        try:
+            self.schema(data)
+        except vol.Invalid as err:
+            _LOGGER.error('Login with invalid formatted data')
+            return self.json_message(
+                'Message format incorrect: {}'.format(err), 400)
+
+        hass = request.app['hass']
+        phase = 1
+        try:
+            with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+                cloud = yield from cloud_api.async_login(
+                    hass, data['username'], data['password'])
+
+            phase += 1
+
+            with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+                yield from cloud.async_refresh_account_info()
+
+        except cloud_api.Unauthenticated:
+            return self.json_message(
+                'Authentication failed (phase {}).'.format(phase), 401)
+        except cloud_api.UnknownError:
+            return self.json_message(
+                'Unknown error occurred (phase {}).'.format(phase), 500)
+        except asyncio.TimeoutError:
+            return self.json_message(
+                'Unable to reach Home Assistant cloud '
+                '(phase {}).'.format(phase), 502)
+
+        hass.data[DOMAIN]['cloud'] = cloud
+        return self.json(cloud.account)
+
+
+class CloudLogoutView(HomeAssistantView):
+    """Log out of the Home Assistant cloud."""
+
+    url = '/api/cloud/logout'
+    name = 'api:cloud:logout'
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Validate config and return results."""
+        hass = request.app['hass']
+        try:
+            with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+                yield from \
+                    hass.data[DOMAIN]['cloud'].async_revoke_access_token()
+
+            hass.data[DOMAIN].pop('cloud')
+
+            return self.json({
+                'result': 'ok',
+            })
+        except asyncio.TimeoutError:
+            return self.json_message("Could not reach the server.", 502)
+        except cloud_api.UnknownError as err:
+            return self.json_message(
+                "Error communicating with the server ({}).".format(err.status),
+                502)
+
+
+class CloudAccountView(HomeAssistantView):
+    """Log out of the Home Assistant cloud."""
+
+    url = '/api/cloud/account'
+    name = 'api:cloud:account'
+
+    @asyncio.coroutine
+    def get(self, request):
+        """Validate config and return results."""
+        hass = request.app['hass']
+
+        if 'cloud' not in hass.data[DOMAIN]:
+            return self.json_message('Not logged in', 400)
+
+        return self.json(hass.data[DOMAIN]['cloud'].account)
@@ -0,0 +1,10 @@
+"""Utilities for the cloud integration."""
+from .const import DOMAIN
+
+
+def get_mode(hass):
+    """Return the current mode of the cloud component.
+
+    Async friendly.
+    """
+    return hass.data[DOMAIN]['mode']
@@ -14,7 +14,7 @@ from homeassistant.util.yaml import load_yaml, dump

 DOMAIN = 'config'
 DEPENDENCIES = ['http']
-SECTIONS = ('core', 'group', 'hassbian', 'automation')
+SECTIONS = ('core', 'customize', 'group', 'hassbian', 'automation', 'script')
 ON_DEMAND = ('zwave')


@@ -77,11 +77,11 @@ class BaseEditConfigView(HomeAssistantView):
        """Empty config if file not found."""
        raise NotImplementedError

-    def _get_value(self, data, config_key):
+    def _get_value(self, hass, data, config_key):
        """Get value."""
        raise NotImplementedError

-    def _write_value(self, data, config_key, new_value):
+    def _write_value(self, hass, data, config_key, new_value):
        """Set value."""
        raise NotImplementedError

@@ -90,7 +90,7 @@ class BaseEditConfigView(HomeAssistantView):
        """Fetch device specific config."""
        hass = request.app['hass']
        current = yield from self.read_config(hass)
-        value = self._get_value(current, config_key)
+        value = self._get_value(hass, current, config_key)

        if value is None:
            return self.json_message('Resource not found', 404)
@@ -121,7 +121,7 @@ class BaseEditConfigView(HomeAssistantView):
        path = hass.config.path(self.path)

        current = yield from self.read_config(hass)
-        self._write_value(current, config_key, data)
+        self._write_value(hass, current, config_key, data)

        yield from hass.async_add_job(_write, path, current)

@@ -149,11 +149,11 @@ class EditKeyBasedConfigView(BaseEditConfigView):
        """Return an empty config."""
        return {}

-    def _get_value(self, data, config_key):
+    def _get_value(self, hass, data, config_key):
        """Get value."""
        return data.get(config_key, {})

-    def _write_value(self, data, config_key, new_value):
+    def _write_value(self, hass, data, config_key, new_value):
        """Set value."""
        data.setdefault(config_key, {}).update(new_value)

@@ -165,14 +165,14 @@ class EditIdBasedConfigView(BaseEditConfigView):
        """Return an empty config."""
        return []

-    def _get_value(self, data, config_key):
+    def _get_value(self, hass, data, config_key):
        """Get value."""
        return next(
            (val for val in data if val.get(CONF_ID) == config_key), None)

-    def _write_value(self, data, config_key, new_value):
+    def _write_value(self, hass, data, config_key, new_value):
        """Set value."""
-        value = self._get_value(data, config_key)
+        value = self._get_value(hass, data, config_key)

        if value is None:
            value = {CONF_ID: config_key}
@@ -0,0 +1,39 @@
+"""Provide configuration end points for Customize."""
+import asyncio
+
+from homeassistant.components.config import EditKeyBasedConfigView
+from homeassistant.components import async_reload_core_config
+from homeassistant.config import DATA_CUSTOMIZE
+
+import homeassistant.helpers.config_validation as cv
+
+CONFIG_PATH = 'customize.yaml'
+
+
+@asyncio.coroutine
+def async_setup(hass):
+    """Set up the Customize config API."""
+    hass.http.register_view(CustomizeConfigView(
+        'customize', 'config', CONFIG_PATH, cv.entity_id, dict,
+        post_write_hook=async_reload_core_config
+    ))
+
+    return True
+
+
+class CustomizeConfigView(EditKeyBasedConfigView):
+    """Configure a list of entries."""
+
+    def _get_value(self, hass, data, config_key):
+        """Get value."""
+        customize = hass.data.get(DATA_CUSTOMIZE, {}).get(config_key) or {}
+        return {'global': customize, 'local': data.get(config_key, {})}
+
+    def _write_value(self, hass, data, config_key, new_value):
+        """Set value."""
+        data[config_key] = new_value
+
+        state = hass.states.get(config_key)
+        state_attributes = dict(state.attributes)
+        state_attributes.update(new_value)
+        hass.states.async_set(config_key, state.state, state_attributes)
@@ -0,0 +1,19 @@
+"""Provide configuration end points for scripts."""
+import asyncio
+
+from homeassistant.components.config import EditKeyBasedConfigView
+from homeassistant.components.script import SCRIPT_ENTRY_SCHEMA, async_reload
+import homeassistant.helpers.config_validation as cv
+
+
+CONFIG_PATH = 'scripts.yaml'
+
+
+@asyncio.coroutine
+def async_setup(hass):
+    """Set up the script config API."""
+    hass.http.register_view(EditKeyBasedConfigView(
+        'script', 'config', CONFIG_PATH, cv.slug, SCRIPT_ENTRY_SCHEMA,
+        post_write_hook=async_reload
+    ))
+    return True
@@ -1,12 +1,17 @@
 """Provide configuration end points for Z-Wave."""
 import asyncio

+import homeassistant.core as ha
+from homeassistant.const import HTTP_NOT_FOUND
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.config import EditKeyBasedConfigView
-from homeassistant.components.zwave import DEVICE_CONFIG_SCHEMA_ENTRY
+from homeassistant.components.zwave import const, DEVICE_CONFIG_SCHEMA_ENTRY
 import homeassistant.helpers.config_validation as cv


 CONFIG_PATH = 'zwave_device_config.yaml'
+OZW_LOG_FILENAME = 'OZW_Log.txt'
+URL_API_OZW_LOG = '/api/zwave/ozwlog'


@asyncio.coroutine
@@ -16,4 +21,123 @@ def async_setup(hass):
        'zwave', 'device_config', CONFIG_PATH, cv.entity_id,
        DEVICE_CONFIG_SCHEMA_ENTRY
    ))
+    hass.http.register_view(ZWaveNodeValueView)
+    hass.http.register_view(ZWaveNodeGroupView)
+    hass.http.register_view(ZWaveNodeConfigView)
+    hass.http.register_view(ZWaveUserCodeView)
+    hass.http.register_static_path(
+        URL_API_OZW_LOG, hass.config.path(OZW_LOG_FILENAME), False)
+
    return True
+
+
+class ZWaveNodeValueView(HomeAssistantView):
+    """View to return the node values."""
+
+    url = r"/api/zwave/values/{node_id:\d+}"
+    name = "api:zwave:values"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve groups of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        values_list = hass.data[const.DATA_ENTITY_VALUES]
+
+        values_data = {}
+        # Return a list of values for this node that are used as a
+        # primary value for an entity
+        for entity_values in values_list:
+            if entity_values.primary.node.node_id != nodeid:
+                continue
+
+            values_data[entity_values.primary.value_id] = {
+                'label': entity_values.primary.label,
+                'index': entity_values.primary.index,
+                'instance': entity_values.primary.instance,
+            }
+        return self.json(values_data)
+
+
+class ZWaveNodeGroupView(HomeAssistantView):
+    """View to return the nodes group configuration."""
+
+    url = r"/api/zwave/groups/{node_id:\d+}"
+    name = "api:zwave:groups"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve groups of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        node = network.nodes.get(nodeid)
+        if node is None:
+            return self.json_message('Node not found', HTTP_NOT_FOUND)
+        groupdata = node.groups
+        groups = {}
+        for key, value in groupdata.items():
+            groups[key] = {'associations': value.associations,
+                           'association_instances':
+                           value.associations_instances,
+                           'label': value.label,
+                           'max_associations': value.max_associations}
+        return self.json(groups)
+
+
+class ZWaveNodeConfigView(HomeAssistantView):
+    """View to return the nodes configuration options."""
+
+    url = r"/api/zwave/config/{node_id:\d+}"
+    name = "api:zwave:config"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve configurations of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        node = network.nodes.get(nodeid)
+        if node is None:
+            return self.json_message('Node not found', HTTP_NOT_FOUND)
+        config = {}
+        for value in (
+                node.get_values(class_id=const.COMMAND_CLASS_CONFIGURATION)
+                .values()):
+            config[value.index] = {'label': value.label,
+                                   'type': value.type,
+                                   'help': value.help,
+                                   'data_items': value.data_items,
+                                   'data': value.data,
+                                   'max': value.max,
+                                   'min': value.min}
+        return self.json(config)
+
+
+class ZWaveUserCodeView(HomeAssistantView):
+    """View to return the nodes usercode configuration."""
+
+    url = r"/api/zwave/usercodes/{node_id:\d+}"
+    name = "api:zwave:usercodes"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve usercodes of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        node = network.nodes.get(nodeid)
+        if node is None:
+            return self.json_message('Node not found', HTTP_NOT_FOUND)
+        usercodes = {}
+        if not node.has_command_class(const.COMMAND_CLASS_USER_CODE):
+            return self.json(usercodes)
+        for value in (
+                node.get_values(class_id=const.COMMAND_CLASS_USER_CODE)
+                .values()):
+            if value.genre != const.GENRE_USER:
+                continue
+            usercodes[value.index] = {'code': value.data,
+                                      'label': value.label,
+                                      'length': len(value.data)}
+        return self.json(usercodes)
@@ -7,18 +7,21 @@ A callback has to be provided to `request_config` which will be called when
 the user has submitted configuration information.
 """
 import asyncio
+import functools as ft
 import logging

 from homeassistant.core import callback as async_callback
 from homeassistant.const import EVENT_TIME_CHANGED, ATTR_FRIENDLY_NAME, \
    ATTR_ENTITY_PICTURE
-from homeassistant.helpers.entity import generate_entity_id
+from homeassistant.loader import bind_hass
+from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.util.async import run_callback_threadsafe

 _LOGGER = logging.getLogger(__name__)
-_REQUESTS = {}
 _KEY_INSTANCE = 'configurator'

+DATA_REQUESTS = 'configurator_requests'
+
 ATTR_CONFIGURE_ID = 'configure_id'
 ATTR_DESCRIPTION = 'description'
 ATTR_DESCRIPTION_IMAGE = 'description_image'
@@ -37,63 +40,90 @@ STATE_CONFIGURE = 'configure'
 STATE_CONFIGURED = 'configured'


-def request_config(
-        hass, name, callback, description=None, description_image=None,
+@bind_hass
+@async_callback
+def async_request_config(
+        hass, name, callback=None, description=None, description_image=None,
        submit_caption=None, fields=None, link_name=None, link_url=None,
        entity_picture=None):
    """Create a new request for configuration.

    Will return an ID to be used for sequent calls.
    """
-    instance = run_callback_threadsafe(hass.loop,
-                                       _async_get_instance,
-                                       hass).result()
+    instance = hass.data.get(_KEY_INSTANCE)

-    request_id = instance.request_config(
+    if instance is None:
+        instance = hass.data[_KEY_INSTANCE] = Configurator(hass)
+
+    request_id = instance.async_request_config(
        name, callback,
        description, description_image, submit_caption,
        fields, link_name, link_url, entity_picture)

-    _REQUESTS[request_id] = instance
+    if DATA_REQUESTS not in hass.data:
+        hass.data[DATA_REQUESTS] = {}
+
+    hass.data[DATA_REQUESTS][request_id] = instance

    return request_id


-def notify_errors(request_id, error):
+@bind_hass
+def request_config(hass, *args, **kwargs):
+    """Create a new request for configuration.
+
+    Will return an ID to be used for sequent calls.
+    """
+    return run_callback_threadsafe(
+        hass.loop, ft.partial(async_request_config, hass, *args, **kwargs)
+    ).result()
+
+
+@bind_hass
+@async_callback
+def async_notify_errors(hass, request_id, error):
    """Add errors to a config request."""
    try:
-        _REQUESTS[request_id].notify_errors(request_id, error)
+        hass.data[DATA_REQUESTS][request_id].async_notify_errors(
+            request_id, error)
    except KeyError:
        # If request_id does not exist
        pass


-def request_done(request_id):
+@bind_hass
+def notify_errors(hass, request_id, error):
+    """Add errors to a config request."""
+    return run_callback_threadsafe(
+        hass.loop, async_notify_errors, hass, request_id, error
+    ).result()
+
+
+@bind_hass
+@async_callback
+def async_request_done(hass, request_id):
    """Mark a configuration request as done."""
    try:
-        _REQUESTS.pop(request_id).request_done(request_id)
+        hass.data[DATA_REQUESTS].pop(request_id).async_request_done(request_id)
    except KeyError:
        # If request_id does not exist
        pass


+@bind_hass
+def request_done(hass, request_id):
+    """Mark a configuration request as done."""
+    return run_callback_threadsafe(
+        hass.loop, async_request_done, hass, request_id
+    ).result()
+
+
@asyncio.coroutine
 def async_setup(hass, config):
    """Set up the configurator component."""
    return True


-@async_callback
-def _async_get_instance(hass):
-    """Get an instance per hass object."""
-    instance = hass.data.get(_KEY_INSTANCE)
-
-    if instance is None:
-        instance = hass.data[_KEY_INSTANCE] = Configurator(hass)
-
-    return instance
-
-
 class Configurator(object):
    """The class to keep track of current configuration requests."""

@@ -103,14 +133,16 @@ class Configurator(object):
        self._cur_id = 0
        self._requests = {}
        hass.services.async_register(
-            DOMAIN, SERVICE_CONFIGURE, self.handle_service_call)
+            DOMAIN, SERVICE_CONFIGURE, self.async_handle_service_call)

-    def request_config(
+    @async_callback
+    def async_request_config(
            self, name, callback,
            description, description_image, submit_caption,
            fields, link_name, link_url, entity_picture):
        """Set up a request for configuration."""
-        entity_id = generate_entity_id(ENTITY_ID_FORMAT, name, hass=self.hass)
+        entity_id = async_generate_entity_id(
+            ENTITY_ID_FORMAT, name, hass=self.hass)

        if fields is None:
            fields = []
@@ -136,11 +168,12 @@ class Configurator(object):
            ] if value is not None
        })

-        self.hass.states.set(entity_id, STATE_CONFIGURE, data)
+        self.hass.states.async_set(entity_id, STATE_CONFIGURE, data)

        return request_id

-    def notify_errors(self, request_id, error):
+    @async_callback
+    def async_notify_errors(self, request_id, error):
        """Update the state with errors."""
        if not self._validate_request_id(request_id):
            return
@@ -152,9 +185,10 @@ class Configurator(object):
        new_data = dict(state.attributes)
        new_data[ATTR_ERRORS] = error

-        self.hass.states.set(entity_id, STATE_CONFIGURE, new_data)
+        self.hass.states.async_set(entity_id, STATE_CONFIGURE, new_data)

-    def request_done(self, request_id):
+    @async_callback
+    def async_request_done(self, request_id):
        """Remove the configuration request."""
        if not self._validate_request_id(request_id):
            return
@@ -165,15 +199,16 @@ class Configurator(object):
        # the result fo the service call (current design limitation).
        # Instead, we will set it to configured to give as feedback but delete
        # it shortly after so that it is deleted when the client updates.
-        self.hass.states.set(entity_id, STATE_CONFIGURED)
+        self.hass.states.async_set(entity_id, STATE_CONFIGURED)

        def deferred_remove(event):
            """Remove the request state."""
-            self.hass.states.remove(entity_id)
+            self.hass.states.async_remove(entity_id)

-        self.hass.bus.listen_once(EVENT_TIME_CHANGED, deferred_remove)
+        self.hass.bus.async_listen_once(EVENT_TIME_CHANGED, deferred_remove)

-    def handle_service_call(self, call):
+    @async_callback
+    def async_handle_service_call(self, call):
        """Handle a configure service call."""
        request_id = call.data.get(ATTR_CONFIGURE_ID)

@@ -184,8 +219,8 @@ class Configurator(object):
        entity_id, fields, callback = self._requests[request_id]

        # field validation goes here?
-
-        self.hass.async_add_job(callback, call.data.get(ATTR_FIELDS, {}))
+        if callback:
+            self.hass.async_add_job(callback, call.data.get(ATTR_FIELDS, {}))

    def _generate_unique_id(self):
        """Generate a unique configurator ID."""
@@ -4,6 +4,7 @@ Support for functionality to have conversations with Home Assistant.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/conversation/
 """
+import asyncio
 import logging
 import re
 import warnings
@@ -11,16 +12,17 @@ import warnings
 import voluptuous as vol

 from homeassistant import core
+from homeassistant.loader import bind_hass
 from homeassistant.const import (
-    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
-import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers import script
+    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, HTTP_BAD_REQUEST)
+from homeassistant.helpers import intent, config_validation as cv
+from homeassistant.components import http


-REQUIREMENTS = ['fuzzywuzzy==0.15.0']
+REQUIREMENTS = ['fuzzywuzzy==0.15.1']
+DEPENDENCIES = ['http']

 ATTR_TEXT = 'text'
-ATTR_SENTENCE = 'sentence'
 DOMAIN = 'conversation'

 REGEX_TURN_COMMAND = re.compile(r'turn (?P<name>(?: |\w)+) (?P<command>\w+)')
@@ -28,79 +30,174 @@ REGEX_TURN_COMMAND = re.compile(r'turn (?P<name>(?: |\w)+) (?P<command>\w+)')
 SERVICE_PROCESS = 'process'

 SERVICE_PROCESS_SCHEMA = vol.Schema({
-    vol.Required(ATTR_TEXT): vol.All(cv.string, vol.Lower),
+    vol.Required(ATTR_TEXT): cv.string,
 })

 CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({
-    cv.string: vol.Schema({
-        vol.Required(ATTR_SENTENCE): cv.string,
-        vol.Required('action'): cv.SCRIPT_SCHEMA,
+    vol.Optional('intents'): vol.Schema({
+        cv.string: vol.All(cv.ensure_list, [cv.string])
    })
 })}, extra=vol.ALLOW_EXTRA)

+_LOGGER = logging.getLogger(__name__)

-def setup(hass, config):
+
+@core.callback
+@bind_hass
+def async_register(hass, intent_type, utterances):
+    """Register an intent.
+
+    Registrations don't require conversations to be loaded. They will become
+    active once the conversation component is loaded.
+    """
+    intents = hass.data.get(DOMAIN)
+
+    if intents is None:
+        intents = hass.data[DOMAIN] = {}
+
+    conf = intents.get(intent_type)
+
+    if conf is None:
+        conf = intents[intent_type] = []
+
+    conf.extend(_create_matcher(utterance) for utterance in utterances)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
    """Register the process service."""
    warnings.filterwarnings('ignore', module='fuzzywuzzy')
-    from fuzzywuzzy import process as fuzzyExtract

-    logger = logging.getLogger(__name__)
    config = config.get(DOMAIN, {})
+    intents = hass.data.get(DOMAIN)

-    choices = {attrs[ATTR_SENTENCE]: script.Script(
-        hass,
-        attrs['action'],
-        name)
-               for name, attrs in config.items()}
+    if intents is None:
+        intents = hass.data[DOMAIN] = {}

+    for intent_type, utterances in config.get('intents', {}).items():
+        conf = intents.get(intent_type)
+
+        if conf is None:
+            conf = intents[intent_type] = []
+
+        conf.extend(_create_matcher(utterance) for utterance in utterances)
+
+    @asyncio.coroutine
    def process(service):
        """Parse text into commands."""
-        # if actually configured
-        if choices:
-            text = service.data[ATTR_TEXT]
-            match = fuzzyExtract.extractOne(text, choices.keys())
-            scorelimit = 60  # arbitrary value
-            logging.info(
-                'matched up text %s and found %s',
-                text,
-                [match[0] if match[1] > scorelimit else 'nothing']
-                )
-            if match[1] > scorelimit:
-                choices[match[0]].run()  # run respective script
-                return
-
        text = service.data[ATTR_TEXT]
-        match = REGEX_TURN_COMMAND.match(text)
+        yield from _process(hass, text)

-        if not match:
-            logger.error("Unable to process: %s", text)
-            return
-
-        name, command = match.groups()
-        entities = {state.entity_id: state.name for state in hass.states.all()}
-        entity_ids = fuzzyExtract.extractOne(
-            name, entities, score_cutoff=65)[2]
-
-        if not entity_ids:
-            logger.error(
-                "Could not find entity id %s from text %s", name, text)
-            return
-
-        if command == 'on':
-            hass.services.call(core.DOMAIN, SERVICE_TURN_ON, {
-                ATTR_ENTITY_ID: entity_ids,
-            }, blocking=True)
-
-        elif command == 'off':
-            hass.services.call(core.DOMAIN, SERVICE_TURN_OFF, {
-                ATTR_ENTITY_ID: entity_ids,
-            }, blocking=True)
-
-        else:
-            logger.error('Got unsupported command %s from text %s',
-                         command, text)
-
-    hass.services.register(
+    hass.services.async_register(
        DOMAIN, SERVICE_PROCESS, process, schema=SERVICE_PROCESS_SCHEMA)

+    hass.http.register_view(ConversationProcessView)
+
    return True
+
+
+def _create_matcher(utterance):
+    """Create a regex that matches the utterance."""
+    parts = re.split(r'({\w+})', utterance)
+    group_matcher = re.compile(r'{(\w+)}')
+
+    pattern = ['^']
+
+    for part in parts:
+        match = group_matcher.match(part)
+
+        if match is None:
+            pattern.append(part)
+            continue
+
+        pattern.append('(?P<{}>{})'.format(match.groups()[0], r'[\w ]+'))
+
+    pattern.append('$')
+    return re.compile(''.join(pattern), re.I)
+
+
+@asyncio.coroutine
+def _process(hass, text):
+    """Process a line of text."""
+    intents = hass.data.get(DOMAIN, {})
+
+    for intent_type, matchers in intents.items():
+        for matcher in matchers:
+            match = matcher.match(text)
+
+            if not match:
+                continue
+
+            response = yield from intent.async_handle(
+                hass, DOMAIN, intent_type,
+                {key: {'value': value} for key, value
+                 in match.groupdict().items()}, text)
+            return response
+
+    from fuzzywuzzy import process as fuzzyExtract
+    text = text.lower()
+    match = REGEX_TURN_COMMAND.match(text)
+
+    if not match:
+        _LOGGER.error("Unable to process: %s", text)
+        return None
+
+    name, command = match.groups()
+    entities = {state.entity_id: state.name for state
+                in hass.states.async_all()}
+    entity_ids = fuzzyExtract.extractOne(
+        name, entities, score_cutoff=65)[2]
+
+    if not entity_ids:
+        _LOGGER.error(
+            "Could not find entity id %s from text %s", name, text)
+        return None
+
+    if command == 'on':
+        yield from hass.services.async_call(
+            core.DOMAIN, SERVICE_TURN_ON, {
+                ATTR_ENTITY_ID: entity_ids,
+            }, blocking=True)
+
+    elif command == 'off':
+        yield from hass.services.async_call(
+            core.DOMAIN, SERVICE_TURN_OFF, {
+                ATTR_ENTITY_ID: entity_ids,
+            }, blocking=True)
+
+    else:
+        _LOGGER.error('Got unsupported command %s from text %s',
+                      command, text)
+
+    return None
+
+
+class ConversationProcessView(http.HomeAssistantView):
+    """View to retrieve shopping list content."""
+
+    url = '/api/conversation/process'
+    name = "api:conversation:process"
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Send a request for processing."""
+        hass = request.app['hass']
+        try:
+            data = yield from request.json()
+        except ValueError:
+            return self.json_message('Invalid JSON specified',
+                                     HTTP_BAD_REQUEST)
+
+        text = data.get('text')
+
+        if text is None:
+            return self.json_message('Missing "text" key in JSON.',
+                                     HTTP_BAD_REQUEST)
+
+        intent_result = yield from _process(hass, text)
+
+        if intent_result is None:
+            intent_result = intent.IntentResponse()
+            intent_result.async_set_speech("Sorry, I didn't understand that")
+
+        return self.json(intent_result)
@@ -0,0 +1,220 @@
+"""
+Component to count within automations.
+
+For more details about this component, please refer to the documentation
+at https://home-assistant.io/components/counter/
+"""
+import asyncio
+import logging
+import os
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (ATTR_ENTITY_ID, CONF_ICON, CONF_NAME)
+from homeassistant.core import callback
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.restore_state import async_get_last_state
+from homeassistant.loader import bind_hass
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_INITIAL = 'initial'
+ATTR_STEP = 'step'
+
+CONF_INITIAL = 'initial'
+CONF_STEP = 'step'
+
+DEFAULT_INITIAL = 0
+DEFAULT_STEP = 1
+DOMAIN = 'counter'
+
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+SERVICE_DECREMENT = 'decrement'
+SERVICE_INCREMENT = 'increment'
+SERVICE_RESET = 'reset'
+
+SERVICE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+})
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        cv.slug: vol.Any({
+            vol.Optional(CONF_ICON): cv.icon,
+            vol.Optional(CONF_INITIAL, default=DEFAULT_INITIAL):
+                cv.positive_int,
+            vol.Optional(CONF_NAME): cv.string,
+            vol.Optional(CONF_STEP, default=DEFAULT_STEP): cv.positive_int,
+        }, None)
+    })
+}, extra=vol.ALLOW_EXTRA)
+
+
+@bind_hass
+def increment(hass, entity_id):
+    """Increment a counter."""
+    hass.add_job(async_increment, hass, entity_id)
+
+
+@callback
+@bind_hass
+def async_increment(hass, entity_id):
+    """Increment a counter."""
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_INCREMENT, {ATTR_ENTITY_ID: entity_id}))
+
+
+@bind_hass
+def decrement(hass, entity_id):
+    """Decrement a counter."""
+    hass.add_job(async_decrement, hass, entity_id)
+
+
+@callback
+@bind_hass
+def async_decrement(hass, entity_id):
+    """Decrement a counter."""
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_DECREMENT, {ATTR_ENTITY_ID: entity_id}))
+
+
+@bind_hass
+def reset(hass, entity_id):
+    """Reset a counter."""
+    hass.add_job(async_reset, hass, entity_id)
+
+
+@callback
+@bind_hass
+def async_reset(hass, entity_id):
+    """Reset a counter."""
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_RESET, {ATTR_ENTITY_ID: entity_id}))
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Set up a counter."""
+    component = EntityComponent(_LOGGER, DOMAIN, hass)
+
+    entities = []
+
+    for object_id, cfg in config[DOMAIN].items():
+        if not cfg:
+            cfg = {}
+
+        name = cfg.get(CONF_NAME)
+        initial = cfg.get(CONF_INITIAL)
+        step = cfg.get(CONF_STEP)
+        icon = cfg.get(CONF_ICON)
+
+        entities.append(Counter(object_id, name, initial, step, icon))
+
+    if not entities:
+        return False
+
+    @asyncio.coroutine
+    def async_handler_service(service):
+        """Handle a call to the counter services."""
+        target_counters = component.async_extract_from_service(service)
+
+        if service.service == SERVICE_INCREMENT:
+            attr = 'async_increment'
+        elif service.service == SERVICE_DECREMENT:
+            attr = 'async_decrement'
+        elif service.service == SERVICE_RESET:
+            attr = 'async_reset'
+
+        tasks = [getattr(counter, attr)() for counter in target_counters]
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
+
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml')
+    )
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_INCREMENT, async_handler_service,
+        descriptions[DOMAIN][SERVICE_INCREMENT], SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_DECREMENT, async_handler_service,
+        descriptions[DOMAIN][SERVICE_DECREMENT], SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_RESET, async_handler_service,
+        descriptions[DOMAIN][SERVICE_RESET], SERVICE_SCHEMA)
+
+    yield from component.async_add_entities(entities)
+    return True
+
+
+class Counter(Entity):
+    """Representation of a counter."""
+
+    def __init__(self, object_id, name, initial, step, icon):
+        """Initialize a counter."""
+        self.entity_id = ENTITY_ID_FORMAT.format(object_id)
+        self._name = name
+        self._step = step
+        self._state = self._initial = initial
+        self._icon = icon
+
+    @property
+    def should_poll(self):
+        """If entity should be polled."""
+        return False
+
+    @property
+    def name(self):
+        """Return name of the counter."""
+        return self._name
+
+    @property
+    def icon(self):
+        """Return the icon to be used for this entity."""
+        return self._icon
+
+    @property
+    def state(self):
+        """Return the current value of the counter."""
+        return self._state
+
+    @property
+    def state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_INITIAL: self._initial,
+            ATTR_STEP: self._step,
+        }
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Call when entity about to be added to Home Assistant."""
+        # If not None, we got an initial value.
+        if self._state is not None:
+            return
+
+        state = yield from async_get_last_state(self.hass, self.entity_id)
+        self._state = state and state.state == state
+
+    @asyncio.coroutine
+    def async_decrement(self):
+        """Decrement the counter."""
+        self._state -= self._step
+        yield from self.async_update_ha_state()
+
+    @asyncio.coroutine
+    def async_increment(self):
+        """Increment a counter."""
+        self._state += self._step
+        yield from self.async_update_ha_state()
+
+    @asyncio.coroutine
+    def async_reset(self):
+        """Reset a counter."""
+        self._state = self._initial
+        yield from self.async_update_ha_state()
@@ -13,6 +13,7 @@ import os
 import voluptuous as vol

 from homeassistant.config import load_yaml_config_file
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -22,7 +23,7 @@ from homeassistant.const import (
    SERVICE_OPEN_COVER, SERVICE_CLOSE_COVER, SERVICE_SET_COVER_POSITION,
    SERVICE_STOP_COVER, SERVICE_OPEN_COVER_TILT, SERVICE_CLOSE_COVER_TILT,
    SERVICE_STOP_COVER_TILT, SERVICE_SET_COVER_TILT_POSITION, STATE_OPEN,
-    STATE_CLOSED, STATE_UNKNOWN, ATTR_ENTITY_ID)
+    STATE_CLOSED, STATE_UNKNOWN, STATE_OPENING, STATE_CLOSING, ATTR_ENTITY_ID)

 _LOGGER = logging.getLogger(__name__)

@@ -86,24 +87,28 @@ SERVICE_TO_METHOD = {
 }


+@bind_hass
 def is_closed(hass, entity_id=None):
    """Return if the cover is closed based on the statemachine."""
    entity_id = entity_id or ENTITY_ID_ALL_COVERS
    return hass.states.is_state(entity_id, STATE_CLOSED)


+@bind_hass
 def open_cover(hass, entity_id=None):
    """Open all or specified cover."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.services.call(DOMAIN, SERVICE_OPEN_COVER, data)


+@bind_hass
 def close_cover(hass, entity_id=None):
    """Close all or specified cover."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.services.call(DOMAIN, SERVICE_CLOSE_COVER, data)


+@bind_hass
 def set_cover_position(hass, position, entity_id=None):
    """Move to specific position all or specified cover."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
@@ -111,24 +116,28 @@ def set_cover_position(hass, position, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_COVER_POSITION, data)


+@bind_hass
 def stop_cover(hass, entity_id=None):
    """Stop all or specified cover."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.services.call(DOMAIN, SERVICE_STOP_COVER, data)


+@bind_hass
 def open_cover_tilt(hass, entity_id=None):
    """Open all or specified cover tilt."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.services.call(DOMAIN, SERVICE_OPEN_COVER_TILT, data)


+@bind_hass
 def close_cover_tilt(hass, entity_id=None):
    """Close all or specified cover tilt."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.services.call(DOMAIN, SERVICE_CLOSE_COVER_TILT, data)


+@bind_hass
 def set_cover_tilt_position(hass, tilt_position, entity_id=None):
    """Move to specific tilt position all or specified cover."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
@@ -136,6 +145,7 @@ def set_cover_tilt_position(hass, tilt_position, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_COVER_TILT_POSITION, data)


+@bind_hass
 def stop_cover_tilt(hass, entity_id=None):
    """Stop all or specified cover tilt."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
@@ -215,6 +225,11 @@ class CoverDevice(Entity):
    @property
    def state(self):
        """Return the state of the cover."""
+        if self.is_opening:
+            return STATE_OPENING
+        if self.is_closing:
+            return STATE_CLOSING
+
        closed = self.is_closed

        if closed is None:
@@ -252,6 +267,16 @@ class CoverDevice(Entity):

        return supported_features

+    @property
+    def is_opening(self):
+        """Return if the cover is opening or not."""
+        pass
+
+    @property
+    def is_closing(self):
+        """Return if the cover is closing or not."""
+        pass
+
    @property
    def is_closed(self):
        """Return if the cover is closed or not."""
@@ -0,0 +1,49 @@
+"""
+This component provides HA cover support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.abode/
+"""
+import logging
+
+from homeassistant.components.abode import AbodeDevice, DATA_ABODE
+from homeassistant.components.cover import CoverDevice
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Abode cover devices."""
+    import abodepy.helpers.constants as CONST
+
+    abode = hass.data[DATA_ABODE]
+
+    sensors = []
+    for sensor in abode.get_devices(type_filter=(CONST.DEVICE_SECURE_BARRIER)):
+        sensors.append(AbodeCover(abode, sensor))
+
+    add_devices(sensors)
+
+
+class AbodeCover(AbodeDevice, CoverDevice):
+    """Representation of an Abode cover."""
+
+    def __init__(self, controller, device):
+        """Initialize the Abode device."""
+        AbodeDevice.__init__(self, controller, device)
+
+    @property
+    def is_closed(self):
+        """Return true if cover is closed, else False."""
+        return self._device.is_open is False
+
+    def close_cover(self):
+        """Issue close command to cover."""
+        self._device.close_cover()
+
+    def open_cover(self):
+        """Issue open command to cover."""
+        self._device.open_cover()
@@ -35,10 +35,12 @@ class DemoCover(CoverDevice):
        self._set_position = None
        self._set_tilt_position = None
        self._tilt_position = tilt_position
-        self._closing = True
-        self._closing_tilt = True
+        self._requested_closing = True
+        self._requested_closing_tilt = True
        self._unsub_listener_cover = None
        self._unsub_listener_cover_tilt = None
+        self._is_opening = False
+        self._is_closing = False
        if position is None:
            self._closed = True
        else:
@@ -69,6 +71,16 @@ class DemoCover(CoverDevice):
        """Return if the cover is closed."""
        return self._closed

+    @property
+    def is_closing(self):
+        """Return if the cover is closing."""
+        return self._is_closing
+
+    @property
+    def is_opening(self):
+        """Return if the cover is opening."""
+        return self._is_opening
+
    @property
    def device_class(self):
        """Return the class of this device, from component DEVICE_CLASSES."""
@@ -90,8 +102,10 @@ class DemoCover(CoverDevice):
            self.schedule_update_ha_state()
            return

+        self._is_closing = True
        self._listen_cover()
-        self._closing = True
+        self._requested_closing = True
+        self.schedule_update_ha_state()

    def close_cover_tilt(self, **kwargs):
        """Close the cover tilt."""
@@ -99,7 +113,7 @@ class DemoCover(CoverDevice):
            return

        self._listen_cover_tilt()
-        self._closing_tilt = True
+        self._requested_closing_tilt = True

    def open_cover(self, **kwargs):
        """Open the cover."""
@@ -110,8 +124,10 @@ class DemoCover(CoverDevice):
            self.schedule_update_ha_state()
            return

+        self._is_opening = True
        self._listen_cover()
-        self._closing = False
+        self._requested_closing = False
+        self.schedule_update_ha_state()

    def open_cover_tilt(self, **kwargs):
        """Open the cover tilt."""
@@ -119,7 +135,7 @@ class DemoCover(CoverDevice):
            return

        self._listen_cover_tilt()
-        self._closing_tilt = False
+        self._requested_closing_tilt = False

    def set_cover_position(self, position, **kwargs):
        """Move the cover to a specific position."""
@@ -128,7 +144,7 @@ class DemoCover(CoverDevice):
            return

        self._listen_cover()
-        self._closing = position < self._position
+        self._requested_closing = position < self._position

    def set_cover_tilt_position(self, tilt_position, **kwargs):
        """Move the cover til to a specific position."""
@@ -137,10 +153,12 @@ class DemoCover(CoverDevice):
            return

        self._listen_cover_tilt()
-        self._closing_tilt = tilt_position < self._tilt_position
+        self._requested_closing_tilt = tilt_position < self._tilt_position

    def stop_cover(self, **kwargs):
        """Stop the cover."""
+        self._is_closing = False
+        self._is_opening = False
        if self._position is None:
            return
        if self._unsub_listener_cover is not None:
@@ -166,7 +184,7 @@ class DemoCover(CoverDevice):

    def _time_changed_cover(self, now):
        """Track time changes."""
-        if self._closing:
+        if self._requested_closing:
            self._position -= 10
        else:
            self._position += 10
@@ -186,7 +204,7 @@ class DemoCover(CoverDevice):

    def _time_changed_cover_tilt(self, now):
        """Track time changes."""
-        if self._closing_tilt:
+        if self._requested_closing_tilt:
            self._tilt_position -= 10
        else:
            self._tilt_position += 10
@@ -18,10 +18,10 @@ from homeassistant.const import (

 _LOGGER = logging.getLogger(__name__)

-ATTR_AVAILABLE = "available"
-ATTR_SENSOR_STRENGTH = "sensor reflection rate"
-ATTR_SIGNAL_STRENGTH = "wifi signal strength (dB)"
-ATTR_TIME_IN_STATE = "time in state"
+ATTR_AVAILABLE = 'available'
+ATTR_SENSOR_STRENGTH = 'sensor_reflection_rate'
+ATTR_SIGNAL_STRENGTH = 'wifi_signal_strength'
+ATTR_TIME_IN_STATE = 'time_in_state'

 DEFAULT_NAME = 'Garadget'

@@ -21,8 +21,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    devices = []
    for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMCover(hass, conf)
-        new_device.link_homematic()
+        new_device = HMCover(conf)
        devices.append(new_device)

    add_devices(devices)
@@ -1,185 +1,239 @@
 """
-Support for KNX covers.
+Support for KNX/IP covers.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover.knx/
 """
-import logging
-
+import asyncio
 import voluptuous as vol

+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
+from homeassistant.helpers.event import async_track_utc_time_change
 from homeassistant.components.cover import (
-    CoverDevice, PLATFORM_SCHEMA, ATTR_POSITION, DEVICE_CLASSES_SCHEMA,
-    SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION, SUPPORT_STOP,
-    SUPPORT_SET_TILT_POSITION
-)
-from homeassistant.components.knx import (KNXConfig, KNXMultiAddressDevice)
-from homeassistant.const import (CONF_NAME, CONF_DEVICE_CLASS)
+    CoverDevice, PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE,
+    SUPPORT_SET_POSITION, SUPPORT_STOP, SUPPORT_SET_TILT_POSITION,
+    ATTR_POSITION, ATTR_TILT_POSITION)
+from homeassistant.core import callback
+from homeassistant.const import CONF_NAME
 import homeassistant.helpers.config_validation as cv

-_LOGGER = logging.getLogger(__name__)
-
-CONF_GETPOSITION_ADDRESS = 'getposition_address'
-CONF_SETPOSITION_ADDRESS = 'setposition_address'
-CONF_GETANGLE_ADDRESS = 'getangle_address'
-CONF_SETANGLE_ADDRESS = 'setangle_address'
-CONF_STOP = 'stop_address'
-CONF_UPDOWN = 'updown_address'
+CONF_MOVE_LONG_ADDRESS = 'move_long_address'
+CONF_MOVE_SHORT_ADDRESS = 'move_short_address'
+CONF_POSITION_ADDRESS = 'position_address'
+CONF_POSITION_STATE_ADDRESS = 'position_state_address'
+CONF_ANGLE_ADDRESS = 'angle_address'
+CONF_ANGLE_STATE_ADDRESS = 'angle_state_address'
+CONF_TRAVELLING_TIME_DOWN = 'travelling_time_down'
+CONF_TRAVELLING_TIME_UP = 'travelling_time_up'
 CONF_INVERT_POSITION = 'invert_position'
 CONF_INVERT_ANGLE = 'invert_angle'

+DEFAULT_TRAVEL_TIME = 25
 DEFAULT_NAME = 'KNX Cover'
 DEPENDENCIES = ['knx']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_UPDOWN): cv.string,
-    vol.Required(CONF_STOP): cv.string,
-    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
-    vol.Optional(CONF_GETPOSITION_ADDRESS): cv.string,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_SETPOSITION_ADDRESS): cv.string,
+    vol.Optional(CONF_MOVE_LONG_ADDRESS): cv.string,
+    vol.Optional(CONF_MOVE_SHORT_ADDRESS): cv.string,
+    vol.Optional(CONF_POSITION_ADDRESS): cv.string,
+    vol.Optional(CONF_POSITION_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_ANGLE_ADDRESS): cv.string,
+    vol.Optional(CONF_ANGLE_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME):
+        cv.positive_int,
+    vol.Optional(CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME):
+        cv.positive_int,
    vol.Optional(CONF_INVERT_POSITION, default=False): cv.boolean,
-    vol.Inclusive(CONF_GETANGLE_ADDRESS, 'angle'): cv.string,
-    vol.Inclusive(CONF_SETANGLE_ADDRESS, 'angle'): cv.string,
    vol.Optional(CONF_INVERT_ANGLE, default=False): cv.boolean,
 })


-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Create and add an entity based on the configuration."""
-    add_devices([KNXCover(hass, KNXConfig(config))])
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up cover(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
+
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True


-class KNXCover(KNXMultiAddressDevice, CoverDevice):
-    """Representation of a KNX cover. e.g. a rollershutter."""
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up covers for KNX platform configured via xknx.yaml."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXCover(hass, device))
+    add_devices(entities)

-    def __init__(self, hass, config):
+
+@callback
+def async_add_devices_config(hass, config, add_devices):
+    """Set up cover for KNX platform configured within plattform."""
+    import xknx
+    cover = xknx.devices.Cover(
+        hass.data[DATA_KNX].xknx,
+        name=config.get(CONF_NAME),
+        group_address_long=config.get(CONF_MOVE_LONG_ADDRESS),
+        group_address_short=config.get(CONF_MOVE_SHORT_ADDRESS),
+        group_address_position_state=config.get(
+            CONF_POSITION_STATE_ADDRESS),
+        group_address_angle=config.get(CONF_ANGLE_ADDRESS),
+        group_address_angle_state=config.get(CONF_ANGLE_STATE_ADDRESS),
+        group_address_position=config.get(CONF_POSITION_ADDRESS),
+        travel_time_down=config.get(CONF_TRAVELLING_TIME_DOWN),
+        travel_time_up=config.get(CONF_TRAVELLING_TIME_UP))
+
+    invert_position = config.get(CONF_INVERT_POSITION)
+    invert_angle = config.get(CONF_INVERT_ANGLE)
+    hass.data[DATA_KNX].xknx.devices.add(cover)
+    add_devices([KNXCover(hass, cover, invert_position, invert_angle)])
+
+
+class KNXCover(CoverDevice):
+    """Representation of a KNX cover."""
+
+    def __init__(self, hass, device, invert_position=False,
+                 invert_angle=False):
        """Initialize the cover."""
-        KNXMultiAddressDevice.__init__(
-            self, hass, config,
-            ['updown', 'stop'],  # required
-            optional=['setposition', 'getposition',
-                      'getangle', 'setangle']
-        )
-        self._device_class = config.config.get(CONF_DEVICE_CLASS)
-        self._invert_position = config.config.get(CONF_INVERT_POSITION)
-        self._invert_angle = config.config.get(CONF_INVERT_ANGLE)
-        self._hass = hass
-        self._current_pos = None
-        self._target_pos = None
-        self._current_tilt = None
-        self._target_tilt = None
-        self._supported_features = SUPPORT_OPEN | SUPPORT_CLOSE | \
-            SUPPORT_SET_POSITION | SUPPORT_STOP
+        self.device = device
+        self.invert_position = invert_position
+        self.invert_angle = invert_angle
+        self.hass = hass
+        self.async_register_callbacks()

-        # Tilt is only supported, if there is a angle get and set address
-        if CONF_SETANGLE_ADDRESS in config.config:
-            _LOGGER.debug("%s: Tilt supported at addresses %s, %s",
-                          self.name, config.config.get(CONF_SETANGLE_ADDRESS),
-                          config.config.get(CONF_GETANGLE_ADDRESS))
-            self._supported_features = self._supported_features | \
-                SUPPORT_SET_TILT_POSITION
+        self._unsubscribe_auto_updater = None
+
+    @callback
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name

    @property
    def should_poll(self):
-        """Polling is needed for the KNX cover."""
-        return True
+        """No polling needed within KNX."""
+        return False

    @property
    def supported_features(self):
        """Flag supported features."""
-        return self._supported_features
+        supported_features = SUPPORT_OPEN | SUPPORT_CLOSE | \
+            SUPPORT_SET_POSITION | SUPPORT_STOP
+        if self.device.supports_angle:
+            supported_features |= SUPPORT_SET_TILT_POSITION
+        return supported_features
+
+    @property
+    def current_cover_position(self):
+        """Return the current position of the cover."""
+        return int(self.from_knx_position(
+            self.device.current_position(),
+            self.invert_position))

    @property
    def is_closed(self):
        """Return if the cover is closed."""
-        if self.current_cover_position is not None:
-            if self.current_cover_position > 0:
-                return False
-            else:
-                return True
+        return self.device.is_closed()

-    @property
-    def current_cover_position(self):
-        """Return current position of cover.
+    @asyncio.coroutine
+    def async_close_cover(self, **kwargs):
+        """Close the cover."""
+        if not self.device.is_closed():
+            yield from self.device.set_down()
+            self.start_auto_updater()

-        None is unknown, 0 is closed, 100 is fully open.
-        """
-        return self._current_pos
+    @asyncio.coroutine
+    def async_open_cover(self, **kwargs):
+        """Open the cover."""
+        if not self.device.is_open():
+            yield from self.device.set_up()
+            self.start_auto_updater()

-    @property
-    def target_position(self):
-        """Return the position we are trying to reach: 0 - 100."""
-        return self._target_pos
+    @asyncio.coroutine
+    def async_set_cover_position(self, **kwargs):
+        """Move the cover to a specific position."""
+        if ATTR_POSITION in kwargs:
+            position = kwargs[ATTR_POSITION]
+            knx_position = self.to_knx_position(position, self.invert_position)
+            yield from self.device.set_position(knx_position)
+            self.start_auto_updater()
+
+    @asyncio.coroutine
+    def async_stop_cover(self, **kwargs):
+        """Stop the cover."""
+        yield from self.device.stop()
+        self.stop_auto_updater()

    @property
    def current_cover_tilt_position(self):
-        """Return current position of cover.
+        """Return current tilt position of cover."""
+        if not self.device.supports_angle:
+            return None
+        return int(self.from_knx_position(
+            self.device.angle,
+            self.invert_angle))

-        None is unknown, 0 is closed, 100 is fully open.
-        """
-        return self._current_tilt
+    @asyncio.coroutine
+    def async_set_cover_tilt_position(self, **kwargs):
+        """Move the cover tilt to a specific position."""
+        if ATTR_TILT_POSITION in kwargs:
+            position = kwargs[ATTR_TILT_POSITION]
+            knx_position = self.to_knx_position(position, self.invert_angle)
+            yield from self.device.set_angle(knx_position)

-    @property
-    def target_tilt(self):
-        """Return the tilt angle (in %) we are trying to reach: 0 - 100."""
-        return self._target_tilt
+    def start_auto_updater(self):
+        """Start the autoupdater to update HASS while cover is moving."""
+        if self._unsubscribe_auto_updater is None:
+            self._unsubscribe_auto_updater = async_track_utc_time_change(
+                self.hass, self.auto_updater_hook)

-    def set_cover_position(self, **kwargs):
-        """Set new target position."""
-        position = kwargs.get(ATTR_POSITION)
-        if position is None:
-            return
+    def stop_auto_updater(self):
+        """Stop the autoupdater."""
+        if self._unsubscribe_auto_updater is not None:
+            self._unsubscribe_auto_updater()
+            self._unsubscribe_auto_updater = None

-        if self._invert_position:
-            position = 100-position
+    @callback
+    def auto_updater_hook(self, now):
+        """Callback for autoupdater."""
+        # pylint: disable=unused-argument
+        self.hass.async_add_job(self.async_update_ha_state())
+        if self.device.position_reached():
+            self.stop_auto_updater()

-        self._target_pos = position
-        self.set_percentage('setposition', position)
-        _LOGGER.debug("%s: Set target position to %d", self.name, position)
+        self.hass.add_job(self.device.auto_stop_if_necessary())

-    def update(self):
-        """Update device state."""
-        super().update()
-        value = self.get_percentage('getposition')
-        if value is not None:
-            self._current_pos = value
-            if self._invert_position:
-                self._current_pos = 100-value
-            _LOGGER.debug("%s: position = %d", self.name, value)
+    @staticmethod
+    def from_knx_position(raw, invert):
+        """Convert KNX position [0...255] to hass position [100...0]."""
+        position = round((raw/256)*100)
+        if not invert:
+            position = 100 - position
+        return position

-        if self._supported_features & SUPPORT_SET_TILT_POSITION:
-            value = self.get_percentage('getangle')
-            if value is not None:
-                self._current_tilt = value
-                if self._invert_angle:
-                    self._current_tilt = 100-value
-                _LOGGER.debug("%s: tilt = %d", self.name, value)
-
-    def open_cover(self, **kwargs):
-        """Open the cover."""
-        _LOGGER.debug("%s: open: updown = 0", self.name)
-        self.set_int_value('updown', 0)
-
-    def close_cover(self, **kwargs):
-        """Close the cover."""
-        _LOGGER.debug("%s: open: updown = 1", self.name)
-        self.set_int_value('updown', 1)
-
-    def stop_cover(self, **kwargs):
-        """Stop the cover movement."""
-        _LOGGER.debug("%s: stop: stop = 1", self.name)
-        self.set_int_value('stop', 1)
-
-    def set_cover_tilt_position(self, tilt_position, **kwargs):
-        """Move the cover til to a specific position."""
-        if self._invert_angle:
-            tilt_position = 100-tilt_position
-
-        self._target_tilt = round(tilt_position, -1)
-        self.set_percentage('setangle', tilt_position)
-
-    @property
-    def device_class(self):
-        """Return the class of this device, from component DEVICE_CLASSES."""
-        return self._device_class
+    @staticmethod
+    def to_knx_position(value, invert):
+        """Convert hass position [100...0] to KNX position [0...255]."""
+        knx_position = round(value/100*255.4)
+        if not invert:
+            knx_position = 255-knx_position
+        print(value, " -> ", knx_position)
+        return knx_position
@@ -1,18 +1,17 @@
 """
-Support for Lutron Caseta SerenaRollerShade.
+Support for Lutron Caseta shades.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover.lutron_caseta/
 """
 import logging

-
 from homeassistant.components.cover import (
-    CoverDevice, SUPPORT_OPEN, SUPPORT_CLOSE)
+    CoverDevice, SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION,
+    ATTR_POSITION, DOMAIN)
 from homeassistant.components.lutron_caseta import (
    LUTRON_CASETA_SMARTBRIDGE, LutronCasetaDevice)

-
 _LOGGER = logging.getLogger(__name__)

 DEPENDENCIES = ['lutron_caseta']
@@ -20,10 +19,10 @@ DEPENDENCIES = ['lutron_caseta']

 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the Lutron Caseta Serena shades as a cover device."""
+    """Set up the Lutron Caseta shades as a cover device."""
    devs = []
    bridge = hass.data[LUTRON_CASETA_SMARTBRIDGE]
-    cover_devices = bridge.get_devices_by_types(["SerenaRollerShade"])
+    cover_devices = bridge.get_devices_by_domain(DOMAIN)
    for cover_device in cover_devices:
        dev = LutronCasetaCover(cover_device, bridge)
        devs.append(dev)
@@ -32,29 +31,36 @@ def setup_platform(hass, config, add_devices, discovery_info=None):


 class LutronCasetaCover(LutronCasetaDevice, CoverDevice):
-    """Representation of a Lutron Serena shade."""
+    """Representation of a Lutron shade."""

    @property
    def supported_features(self):
        """Flag supported features."""
-        return SUPPORT_OPEN | SUPPORT_CLOSE
+        return SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_SET_POSITION

    @property
    def is_closed(self):
        """Return if the cover is closed."""
-        return self._state["current_state"] < 1
+        return self._state['current_state'] < 1

-    def close_cover(self):
+    @property
+    def current_cover_position(self):
+        """Return the current position of cover."""
+        return self._state['current_state']
+
+    def close_cover(self, **kwargs):
        """Close the cover."""
        self._smartbridge.set_value(self._device_id, 0)

-    def open_cover(self):
+    def open_cover(self, **kwargs):
        """Open the cover."""
        self._smartbridge.set_value(self._device_id, 100)

-    def set_cover_position(self, position, **kwargs):
-        """Move the roller shutter to a specific position."""
-        self._smartbridge.set_value(self._device_id, position)
+    def set_cover_position(self, **kwargs):
+        """Move the shade to a specific position."""
+        if ATTR_POSITION in kwargs:
+            position = kwargs[ATTR_POSITION]
+            self._smartbridge.set_value(self._device_id, position)

    def update(self):
        """Call when forcing a refresh of the device."""
@@ -12,7 +12,6 @@ from homeassistant.components.cover import CoverDevice
 from homeassistant.const import (
    CONF_USERNAME, CONF_PASSWORD, CONF_TYPE, STATE_CLOSED)
 import homeassistant.helpers.config_validation as cv
-import homeassistant.loader as loader

 REQUIREMENTS = ['pymyq==0.0.8']

@@ -37,7 +36,6 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)
    brand = config.get(CONF_TYPE)
-    persistent_notification = loader.get_component('persistent_notification')
    myq = pymyq(username, password, brand)

    try:
@@ -52,8 +50,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    except (TypeError, KeyError, NameError, ValueError) as ex:
        _LOGGER.error("%s", ex)
-        persistent_notification.create(
-            hass, 'Error: {}<br />'
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
            'You will need to restart hass after fixing.'
            ''.format(ex),
            title=NOTIFICATION_TITLE,
@@ -4,42 +4,18 @@ Support for MySensors covers.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
-from homeassistant.components.cover import CoverDevice, ATTR_POSITION
+from homeassistant.components.cover import CoverDevice, ATTR_POSITION, DOMAIN
 from homeassistant.const import STATE_ON, STATE_OFF

-_LOGGER = logging.getLogger(__name__)
-
-DEPENDENCIES = []
-

 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the MySensors platform for covers."""
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_COVER: [set_req.V_DIMMER, set_req.V_LIGHT],
-        }
-        if float(gateway.protocol_version) >= 1.5:
-            map_sv_types.update({
-                pres.S_COVER: [set_req.V_PERCENTAGE, set_req.V_STATUS],
-            })
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsCover, add_devices))
+    """Setup the mysensors platform for covers."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsCover, add_devices=add_devices)


-class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
+class MySensorsCover(mysensors.MySensorsEntity, CoverDevice):
    """Representation of the value of a MySensors Cover child node."""

    @property
@@ -16,7 +16,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
    """Set up the RFXtrx cover."""
    import RFXtrx as rfxtrxmod

-    covers = rfxtrx.get_devices_from_config(config, RfxtrxCover, hass)
+    covers = rfxtrx.get_devices_from_config(config, RfxtrxCover)
    add_devices_callback(covers)

    def cover_update(event):
@@ -26,7 +26,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                not event.device.known_to_be_rollershutter:
            return

-        new_device = rfxtrx.get_new_device(event, config, RfxtrxCover, hass)
+        new_device = rfxtrx.get_new_device(event, config, RfxtrxCover)
        if new_device:
            add_devices_callback([new_device])

@@ -24,9 +24,13 @@ CONF_RELAY_PIN = 'relay_pin'
 CONF_RELAY_TIME = 'relay_time'
 CONF_STATE_PIN = 'state_pin'
 CONF_STATE_PULL_MODE = 'state_pull_mode'
+CONF_INVERT_STATE = 'invert_state'
+CONF_INVERT_RELAY = 'invert_relay'

 DEFAULT_RELAY_TIME = .2
 DEFAULT_STATE_PULL_MODE = 'UP'
+DEFAULT_INVERT_STATE = False
+DEFAULT_INVERT_RELAY = False
 DEPENDENCIES = ['rpi_gpio']

 _COVERS_SCHEMA = vol.All(
@@ -45,6 +49,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_STATE_PULL_MODE, default=DEFAULT_STATE_PULL_MODE):
        cv.string,
    vol.Optional(CONF_RELAY_TIME, default=DEFAULT_RELAY_TIME): cv.positive_int,
+    vol.Optional(CONF_INVERT_STATE, default=DEFAULT_INVERT_STATE): cv.boolean,
+    vol.Optional(CONF_INVERT_RELAY, default=DEFAULT_INVERT_RELAY): cv.boolean,
 })


@@ -53,13 +59,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the RPi cover platform."""
    relay_time = config.get(CONF_RELAY_TIME)
    state_pull_mode = config.get(CONF_STATE_PULL_MODE)
+    invert_state = config.get(CONF_INVERT_STATE)
+    invert_relay = config.get(CONF_INVERT_RELAY)
    covers = []
    covers_conf = config.get(CONF_COVERS)

    for cover in covers_conf:
        covers.append(RPiGPIOCover(
            cover[CONF_NAME], cover[CONF_RELAY_PIN], cover[CONF_STATE_PIN],
-            state_pull_mode, relay_time))
+            state_pull_mode, relay_time, invert_state, invert_relay))
    add_devices(covers)


@@ -67,7 +75,7 @@ class RPiGPIOCover(CoverDevice):
    """Representation of a Raspberry GPIO cover."""

    def __init__(self, name, relay_pin, state_pin, state_pull_mode,
-                 relay_time):
+                 relay_time, invert_state, invert_relay):
        """Initialize the cover."""
        self._name = name
        self._state = False
@@ -75,9 +83,11 @@ class RPiGPIOCover(CoverDevice):
        self._state_pin = state_pin
        self._state_pull_mode = state_pull_mode
        self._relay_time = relay_time
+        self._invert_state = invert_state
+        self._invert_relay = invert_relay
        rpi_gpio.setup_output(self._relay_pin)
        rpi_gpio.setup_input(self._state_pin, self._state_pull_mode)
-        rpi_gpio.write_output(self._relay_pin, True)
+        rpi_gpio.write_output(self._relay_pin, not self._invert_relay)

    @property
    def unique_id(self):
@@ -96,13 +106,13 @@ class RPiGPIOCover(CoverDevice):
    @property
    def is_closed(self):
        """Return true if cover is closed."""
-        return self._state
+        return self._state != self._invert_state

    def _trigger(self):
        """Trigger the cover."""
-        rpi_gpio.write_output(self._relay_pin, False)
+        rpi_gpio.write_output(self._relay_pin, self._invert_relay)
        sleep(self._relay_time)
-        rpi_gpio.write_output(self._relay_pin, True)
+        rpi_gpio.write_output(self._relay_pin, not self._invert_relay)

    def close_cover(self):
        """Close the cover."""
@@ -19,7 +19,7 @@ from homeassistant.const import (
    CONF_FRIENDLY_NAME, CONF_ENTITY_ID,
    EVENT_HOMEASSISTANT_START, MATCH_ALL,
    CONF_VALUE_TEMPLATE, CONF_ICON_TEMPLATE,
-    STATE_OPEN, STATE_CLOSED)
+    CONF_OPTIMISTIC, STATE_OPEN, STATE_CLOSED)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
@@ -39,6 +39,8 @@ CLOSE_ACTION = 'close_cover'
 STOP_ACTION = 'stop_cover'
 POSITION_ACTION = 'set_cover_position'
 TILT_ACTION = 'set_cover_tilt_position'
+CONF_TILT_OPTIMISTIC = 'tilt_optimistic'
+
 CONF_VALUE_OR_POSITION_TEMPLATE = 'value_or_position'
 CONF_OPEN_OR_CLOSE = 'open_or_close'

@@ -56,6 +58,8 @@ COVER_SCHEMA = vol.Schema({
    vol.Optional(CONF_POSITION_TEMPLATE): cv.template,
    vol.Optional(CONF_TILT_TEMPLATE): cv.template,
    vol.Optional(CONF_ICON_TEMPLATE): cv.template,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_TILT_OPTIMISTIC): cv.boolean,
    vol.Optional(POSITION_ACTION): cv.SCRIPT_SCHEMA,
    vol.Optional(TILT_ACTION): cv.SCRIPT_SCHEMA,
    vol.Optional(CONF_FRIENDLY_NAME, default=None): cv.string,
@@ -83,11 +87,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        stop_action = device_config.get(STOP_ACTION)
        position_action = device_config.get(POSITION_ACTION)
        tilt_action = device_config.get(TILT_ACTION)
-
-        if position_template is None and state_template is None:
-            _LOGGER.error('Must specify either %s' or '%s',
-                          CONF_VALUE_TEMPLATE, CONF_VALUE_TEMPLATE)
-            continue
+        optimistic = device_config.get(CONF_OPTIMISTIC)
+        tilt_optimistic = device_config.get(CONF_TILT_OPTIMISTIC)

        if position_action is None and open_action is None:
            _LOGGER.error('Must specify at least one of %s' or '%s',
@@ -125,7 +126,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                device, friendly_name, state_template,
                position_template, tilt_template, icon_template,
                open_action, close_action, stop_action,
-                position_action, tilt_action, entity_ids
+                position_action, tilt_action,
+                optimistic, tilt_optimistic, entity_ids
            )
        )
    if not covers:
@@ -142,7 +144,8 @@ class CoverTemplate(CoverDevice):
    def __init__(self, hass, device_id, friendly_name, state_template,
                 position_template, tilt_template, icon_template,
                 open_action, close_action, stop_action,
-                 position_action, tilt_action, entity_ids):
+                 position_action, tilt_action,
+                 optimistic, tilt_optimistic, entity_ids):
        """Initialize the Template cover."""
        self.hass = hass
        self.entity_id = async_generate_entity_id(
@@ -167,6 +170,9 @@ class CoverTemplate(CoverDevice):
        self._tilt_script = None
        if tilt_action is not None:
            self._tilt_script = Script(hass, tilt_action)
+        self._optimistic = (optimistic or
+                            (not state_template and not position_template))
+        self._tilt_optimistic = tilt_optimistic or not tilt_template
        self._icon = None
        self._position = None
        self._tilt_value = None
@@ -260,19 +266,23 @@ class CoverTemplate(CoverDevice):
    def async_open_cover(self, **kwargs):
        """Move the cover up."""
        if self._open_script:
-            self.hass.async_add_job(self._open_script.async_run())
+            yield from self._open_script.async_run()
        elif self._position_script:
-            self.hass.async_add_job(self._position_script.async_run(
-                {"position": 100}))
+            yield from self._position_script.async_run({"position": 100})
+        if self._optimistic:
+            self._position = 100
+            self.hass.async_add_job(self.async_update_ha_state())

    @asyncio.coroutine
    def async_close_cover(self, **kwargs):
        """Move the cover down."""
        if self._close_script:
-            self.hass.async_add_job(self._close_script.async_run())
+            yield from self._close_script.async_run()
        elif self._position_script:
-            self.hass.async_add_job(self._position_script.async_run(
-                {"position": 0}))
+            yield from self._position_script.async_run({"position": 0})
+        if self._optimistic:
+            self._position = 0
+            self.hass.async_add_job(self.async_update_ha_state())

    @asyncio.coroutine
    def async_stop_cover(self, **kwargs):
@@ -284,29 +294,35 @@ class CoverTemplate(CoverDevice):
    def async_set_cover_position(self, **kwargs):
        """Set cover position."""
        self._position = kwargs[ATTR_POSITION]
-        self.hass.async_add_job(self._position_script.async_run(
-            {"position": self._position}))
+        yield from self._position_script.async_run(
+            {"position": self._position})
+        if self._optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())

    @asyncio.coroutine
    def async_open_cover_tilt(self, **kwargs):
        """Tilt the cover open."""
        self._tilt_value = 100
-        self.hass.async_add_job(self._tilt_script.async_run(
-            {"tilt": self._tilt_value}))
+        yield from self._tilt_script.async_run({"tilt": self._tilt_value})
+        if self._tilt_optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())

    @asyncio.coroutine
    def async_close_cover_tilt(self, **kwargs):
        """Tilt the cover closed."""
        self._tilt_value = 0
-        self.hass.async_add_job(self._tilt_script.async_run(
-            {"tilt": self._tilt_value}))
+        yield from self._tilt_script.async_run(
+            {"tilt": self._tilt_value})
+        if self._tilt_optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())

    @asyncio.coroutine
    def async_set_cover_tilt_position(self, **kwargs):
        """Move the cover tilt to a specific position."""
        self._tilt_value = kwargs[ATTR_TILT_POSITION]
-        self.hass.async_add_job(self._tilt_script.async_run(
-            {"tilt": self._tilt_value}))
+        yield from self._tilt_script.async_run({"tilt": self._tilt_value})
+        if self._tilt_optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())

    @asyncio.coroutine
    def async_update(self):
@@ -0,0 +1,160 @@
+"""
+Support for Velbus covers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.velbus/
+"""
+import logging
+import asyncio
+import time
+
+import voluptuous as vol
+
+from homeassistant.components.cover import (
+    CoverDevice, PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE,
+    SUPPORT_STOP)
+from homeassistant.components.velbus import DOMAIN
+from homeassistant.const import (CONF_COVERS, CONF_NAME)
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+COVER_SCHEMA = vol.Schema({
+    vol.Required('module'): cv.positive_int,
+    vol.Required('open_channel'): cv.positive_int,
+    vol.Required('close_channel'): cv.positive_int,
+    vol.Required(CONF_NAME): cv.string
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_COVERS): vol.Schema({cv.slug: COVER_SCHEMA}),
+})
+
+DEPENDENCIES = ['velbus']
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up cover controlled by Velbus."""
+    devices = config.get(CONF_COVERS, {})
+    covers = []
+
+    velbus = hass.data[DOMAIN]
+    for device_name, device_config in devices.items():
+        covers.append(
+            VelbusCover(
+                velbus,
+                device_config.get(CONF_NAME, device_name),
+                device_config.get('module'),
+                device_config.get('open_channel'),
+                device_config.get('close_channel')
+            )
+        )
+
+    if not covers:
+        _LOGGER.error("No covers added")
+        return False
+
+    add_devices(covers)
+
+
+class VelbusCover(CoverDevice):
+    """Representation a Velbus cover."""
+
+    def __init__(self, velbus, name, module, open_channel, close_channel):
+        """Initialize the cover."""
+        self._velbus = velbus
+        self._name = name
+        self._close_channel_state = None
+        self._open_channel_state = None
+        self._module = module
+        self._open_channel = open_channel
+        self._close_channel = close_channel
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Add listener for Velbus messages on bus."""
+        def _init_velbus():
+            """Initialize Velbus on startup."""
+            self._velbus.subscribe(self._on_message)
+            self.get_status()
+
+        yield from self.hass.async_add_job(_init_velbus)
+
+    def _on_message(self, message):
+        import velbus
+        if isinstance(message, velbus.RelayStatusMessage):
+            if message.address == self._module:
+                if message.channel == self._close_channel:
+                    self._close_channel_state = message.is_on()
+                    self.schedule_update_ha_state()
+                if message.channel == self._open_channel:
+                    self._open_channel_state = message.is_on()
+                    self.schedule_update_ha_state()
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_STOP
+
+    @property
+    def should_poll(self):
+        """Disable polling."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the cover."""
+        return self._name
+
+    @property
+    def is_closed(self):
+        """Return if the cover is closed."""
+        return self._close_channel_state
+
+    @property
+    def current_cover_position(self):
+        """Return current position of cover.
+
+        None is unknown.
+        """
+        return None
+
+    def _relay_off(self, channel):
+        import velbus
+        message = velbus.SwitchRelayOffMessage()
+        message.set_defaults(self._module)
+        message.relay_channels = [channel]
+        self._velbus.send(message)
+
+    def _relay_on(self, channel):
+        import velbus
+        message = velbus.SwitchRelayOnMessage()
+        message.set_defaults(self._module)
+        message.relay_channels = [channel]
+        self._velbus.send(message)
+
+    def open_cover(self, **kwargs):
+        """Open the cover."""
+        self._relay_off(self._close_channel)
+        time.sleep(0.3)
+        self._relay_on(self._open_channel)
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        self._relay_off(self._open_channel)
+        time.sleep(0.3)
+        self._relay_on(self._close_channel)
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        self._relay_off(self._open_channel)
+        time.sleep(0.3)
+        self._relay_off(self._close_channel)
+
+    def get_status(self):
+        """Retrieve current status."""
+        import velbus
+        message = velbus.ModuleStatusRequestMessage()
+        message.set_defaults(self._module)
+        message.channels = [self._open_channel, self._close_channel]
+        self._velbus.send(message)
@@ -0,0 +1,66 @@
+"""Support for Xiaomi curtain."""
+import logging
+
+from homeassistant.components.cover import CoverDevice
+from homeassistant.components.xiaomi import (PY_XIAOMI_GATEWAY, XiaomiDevice)
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_CURTAIN_LEVEL = 'curtain_level'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Perform the setup for Xiaomi devices."""
+    devices = []
+    for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
+        for device in gateway.devices['cover']:
+            model = device['model']
+            if model == 'curtain':
+                devices.append(XiaomiGenericCover(device, "Curtain",
+                                                  {'status': 'status',
+                                                   'pos': 'curtain_level'},
+                                                  gateway))
+    add_devices(devices)
+
+
+class XiaomiGenericCover(XiaomiDevice, CoverDevice):
+    """Representation of a XiaomiGenericCover."""
+
+    def __init__(self, device, name, data_key, xiaomi_hub):
+        """Initialize the XiaomiGenericCover."""
+        self._data_key = data_key
+        self._pos = 0
+        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+
+    @property
+    def current_cover_position(self):
+        """Return the current position of the cover."""
+        return self._pos
+
+    @property
+    def is_closed(self):
+        """Return if the cover is closed."""
+        return self.current_cover_position < 0
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        self._write_to_hub(self._sid, **{self._data_key['status']: 'close'})
+
+    def open_cover(self, **kwargs):
+        """Open the cover."""
+        self._write_to_hub(self._sid, **{self._data_key['status']: 'open'})
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        self._write_to_hub(self._sid, **{self._data_key['status']: 'stop'})
+
+    def set_cover_position(self, position, **kwargs):
+        """Move the cover to a specific position."""
+        self._write_to_hub(self._sid, **{self._data_key['pos']: str(position)})
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if ATTR_CURTAIN_LEVEL in data:
+            self._pos = int(data[ATTR_CURTAIN_LEVEL])
+            return True
+        return False
--- a/Show More
+++ b/Show More