Add ADS component

.coveragerc

@@ -11,6 +11,9 @@ omit =
     homeassistant/components/abode.py
     homeassistant/components/*/abode.py
 
+    homeassistant/components/ads.py
+    homeassistant/components/*/ads.py
+
     homeassistant/components/alarmdecoder.py
     homeassistant/components/*/alarmdecoder.py
 

homeassistant/components/ads.py

@@ -0,0 +1,207 @@
+"""
+ADS Component.
+
+For more details about this component, please refer to the documentation.
+https://home-assistant.io/components/ads/
+
+"""
+import threading
+import struct
+import logging
+import ctypes
+from collections import namedtuple
+import voluptuous as vol
+from homeassistant.const import CONF_DEVICE, CONF_PORT, CONF_IP_ADDRESS, \
+    EVENT_HOMEASSISTANT_STOP
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['pyads==2.2.6']
+
+_LOGGER = logging.getLogger(__name__)
+
+DATA_ADS = 'data_ads'
+
+# Supported Types
+ADSTYPE_INT = 'int'
+ADSTYPE_UINT = 'uint'
+ADSTYPE_BYTE = 'byte'
+ADSTYPE_BOOL = 'bool'
+
+
+ADS_PLATFORMS = ['switch', 'binary_sensor', 'light']
+DOMAIN = 'ads'
+
+# config variable names
+CONF_ADSVAR = 'adsvar'
+CONF_ADSTYPE = 'adstype'
+CONF_ADS_USE_NOTIFY = 'use_notify'
+CONF_ADS_POLL_INTERVAL = 'poll_interval'
+CONF_ADS_FACTOR = 'factor'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_DEVICE): cv.string,
+        vol.Required(CONF_PORT): cv.port,
+        vol.Optional(CONF_IP_ADDRESS): cv.string,
+        vol.Optional(CONF_ADS_POLL_INTERVAL, default=1000): cv.positive_int,
+        vol.Optional(CONF_ADS_USE_NOTIFY, default=True): cv.boolean,
+    })
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    import pyads
+    """ Set up the ADS component. """
+    _LOGGER.info('created ADS client')
+    conf = config[DOMAIN]
+
+    # get ads connection parameters from config
+    net_id = conf.get(CONF_DEVICE)
+    ip_address = conf.get(CONF_IP_ADDRESS)
+    port = conf.get(CONF_PORT)
+    poll_interval = conf.get(CONF_ADS_POLL_INTERVAL)
+    use_notify = conf.get(CONF_ADS_USE_NOTIFY)
+
+    # create a new ads connection
+    client = pyads.Connection(net_id, port, ip_address)
+
+    # connect to ads client and try to connect
+    try:
+        ads = AdsHub(client, poll_interval=poll_interval,
+                     use_notify=use_notify)
+    except pyads.pyads.ADSError as e:
+        _LOGGER.error('Could not connect to ADS host (netid={}, port={})'
+                      .format(net_id, port))
+        return False
+
+    # add ads hub to hass data collection, listen to shutdown
+    hass.data[DATA_ADS] = ads
+    hass.bus.listen(EVENT_HOMEASSISTANT_STOP, ads.shutdown)
+
+    def handle_write_data_by_name(call):
+        """ Write a value to the connected ADS device. """
+        adsvar = call.data.get('adsvar')
+        adstype = call.data.get('adstype')
+        value = call.data.get('value')
+
+        assert adstype in ads.ADS_TYPEMAP
+
+        try:
+            ads.write_by_name(adsvar, value, ads.ADS_TYPEMAP[adstype])
+        except pyads.ADSError as e:
+            _LOGGER.error(e)
+
+    hass.services.register(DOMAIN, 'write_data_by_name',
+                           handle_write_data_by_name)
+
+    return True
+
+
+# tuple to hold data needed for notification
+NotificationItem = namedtuple(
+    'NotificationItem', 'hnotify huser name plc_datatype callback'
+)
+
+
+class AdsHub:
+    """ Representation of a PyADS connection. """
+
+    def __init__(self, ads_client, poll_interval, use_notify):
+        from pyads import PLCTYPE_BOOL, PLCTYPE_BYTE, PLCTYPE_INT, \
+            PLCTYPE_UINT, ADSError
+
+        self.ADS_TYPEMAP = {
+            ADSTYPE_BOOL: PLCTYPE_BOOL,
+            ADSTYPE_BYTE: PLCTYPE_BYTE,
+            ADSTYPE_INT: PLCTYPE_INT,
+            ADSTYPE_UINT: PLCTYPE_UINT,
+        }
+
+        self.PLCTYPE_BOOL = PLCTYPE_BOOL
+        self.PLCTYPE_BYTE = PLCTYPE_BYTE
+        self.PLCTYPE_INT = PLCTYPE_INT
+        self.PLCTYPE_UINT = PLCTYPE_UINT
+        self.ADSError = ADSError
+        self.poll_interval = poll_interval
+        self.use_notify = use_notify
+
+        self._client = ads_client
+        self._client.open()
+
+        # all ADS devices are registered here
+        self._devices = []
+        self._notification_items = {}
+        self._lock = threading.Lock()
+
+    def shutdown(self, *args, **kwargs):
+        _LOGGER.debug('Shutting down ADS')
+        for key, notification_item in self._notification_items.items():
+            self._client.del_device_notification(
+                notification_item.hnotify,
+                notification_item.huser
+            )
+            _LOGGER.debug('Deleting device notification {0}, {1}'
+                          .format(notification_item.hnotify,
+                                  notification_item.huser))
+        self._client.close()
+
+    def register_device(self, device):
+        """ Register a new device. """
+        self._devices.append(device)
+
+    def write_by_name(self, name, value, plc_datatype):
+        with self._lock:
+            return self._client.write_by_name(name, value, plc_datatype)
+
+    def read_by_name(self, name, plc_datatype):
+        with self._lock:
+            return self._client.read_by_name(name, plc_datatype)
+
+    def add_device_notification(self, name, plc_datatype, callback):
+        from pyads import NotificationAttrib
+        """ Add a notification to the ADS devices. """
+        attr = NotificationAttrib(ctypes.sizeof(plc_datatype))
+
+        with self._lock:
+            hnotify, huser = self._client.add_device_notification(
+                name, attr, self._device_notification_callback
+            )
+            hnotify = int(hnotify)
+
+        _LOGGER.debug('Added Device Notification {0} for variable {1}'
+                      .format(hnotify, name))
+
+        self._notification_items[hnotify] = NotificationItem(
+            hnotify, huser, name, plc_datatype, callback
+        )
+
+    def _device_notification_callback(self, addr, notification, huser):
+        from pyads import PLCTYPE_BOOL, PLCTYPE_INT, PLCTYPE_BYTE, PLCTYPE_UINT
+        contents = notification.contents
+
+        hnotify = int(contents.hNotification)
+        _LOGGER.debug('Received Notification {0}'.format(hnotify))
+        data = contents.data
+
+        try:
+            notification_item = self._notification_items[hnotify]
+        except KeyError:
+            _LOGGER.debug('Unknown Device Notification handle: {0}'
+                          .format(hnotify))
+            return
+
+        # parse data to desired datatype
+        if notification_item.plc_datatype == PLCTYPE_BOOL:
+            value = bool(struct.unpack('<?', bytearray(data)[:1])[0])
+        elif notification_item.plc_datatype == PLCTYPE_INT:
+            value = struct.unpack('<h', bytearray(data)[:2])[0]
+        elif notification_item.plc_datatype == PLCTYPE_BYTE:
+            value = struct.unpack('<B', bytearray(data)[:1])[0]
+        elif notification_item.plc_datatype == PLCTYPE_UINT:
+            value = struct.unpack('<H', bytearray(data)[:2])[0]
+        else:
+            value = bytearray(data)
+            _LOGGER.warning('No callback available for this datatype.')
+
+        # execute callback
+        notification_item.callback(notification_item.name, value)

homeassistant/components/binary_sensor/ads.py

@@ -0,0 +1,112 @@
+"""
+Support for ADS binary sensors.
+
+"""
+import logging
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import BinarySensorDevice, \
+    PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA
+from homeassistant.components.ads import DATA_ADS, CONF_ADSVAR, \
+    CONF_ADS_USE_NOTIFY, CONF_ADS_POLL_INTERVAL
+from homeassistant.const import CONF_NAME, CONF_DEVICE_CLASS
+from homeassistant.helpers.event import async_track_time_interval
+import homeassistant.helpers.config_validation as cv
+
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['ads']
+DEFAULT_NAME = 'ADS binary sensor'
+
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ADSVAR): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_ADS_USE_NOTIFY): cv.boolean,
+    vol.Optional(CONF_ADS_POLL_INTERVAL): cv.positive_int,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Set up the Binary Sensor platform for ADS. """
+    ads_hub = hass.data.get(DATA_ADS)
+    if not ads_hub:
+        return False
+
+    adsvar = config.get(CONF_ADSVAR)
+    name = config.get(CONF_NAME)
+    device_class = config.get(CONF_DEVICE_CLASS)
+    use_notify = config.get(CONF_ADS_USE_NOTIFY, ads_hub.use_notify)
+    poll_interval = config.get(CONF_ADS_POLL_INTERVAL, ads_hub.poll_interval)
+
+    ads_sensor = AdsBinarySensor(ads_hub, name, adsvar, device_class,
+                                 use_notify, poll_interval)
+    add_devices([ads_sensor], True)
+
+    if use_notify:
+        ads_hub.add_device_notification(adsvar, ads_hub.PLCTYPE_BOOL,
+                                        ads_sensor.callback)
+    else:
+        dtime = timedelta(0, 0, poll_interval * 1000)
+        async_track_time_interval(hass, ads_sensor.poll, dtime)
+
+
+class AdsBinarySensor(BinarySensorDevice):
+    """ Representation of ADS binary sensors. """
+
+    def __init__(self, ads_hub, name, adsvar, device_class, use_notify,
+                 poll_interval):
+        self._name = name
+        self._state = False
+        self._device_class = device_class or 'moving'
+        self._ads_hub = ads_hub
+        self.adsvar = adsvar
+        self.use_notify = use_notify
+        self.poll_interval = poll_interval
+
+        # make first poll if notifications disabled
+        if not self.use_notify:
+            self.poll(None)
+
+    @property
+    def name(self):
+        """ Return the default name of the binary sensor. """
+        return self._name
+
+    @property
+    def device_class(self):
+        """ Return the device class. """
+        return self._device_class
+
+    @property
+    def is_on(self):
+        """ Return if the binary sensor is on. """
+        return self._state
+
+    def callback(self, name, value):
+        _LOGGER.debug('Variable "{0}" changed its value to "{1}"'
+                      .format(name, value))
+        self._state = value
+        try:
+            self.schedule_update_ha_state()
+        except AttributeError:
+            pass
+
+    def poll(self, now):
+        try:
+            self._state = self._ads_hub.read_by_name(
+                self.adsvar, self._ads_hub.PLCTYPE_BOOL
+            )
+            _LOGGER.debug('Polled value for bool variable {0}: {1}'
+                          .format(self.adsvar, self._state))
+        except self._ads_hub.ADSError as e:
+            _LOGGER.error(e)
+
+        try:
+            self.schedule_update_ha_state()
+        except AttributeError:
+            pass