remove polling

homeassistant/components/ads.py

@@ -34,17 +34,13 @@
 # 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)
 
@@ -58,8 +54,6 @@ def setup(hass, 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)
@@ -80,8 +74,7 @@ def setup(hass, config):
 
     # connect to ads client and try to connect
     try:
-        ads = AdsHub(client, poll_interval=poll_interval,
-                     use_notify=use_notify)
+        ads = AdsHub(client)
     except pyads.pyads.ADSError:
         _LOGGER.error(
             'Could not connect to ADS host (netid=%s, port=%s)', net_id, port
@@ -120,11 +113,8 @@ def handle_write_data_by_name(call):
 class AdsHub:
     """Representation of a PyADS connection."""
 
-    def __init__(self, ads_client, poll_interval, use_notify):
+    def __init__(self, ads_client):
         """Initialize the ADS Hub."""
-        self.poll_interval = poll_interval
-        self.use_notify = use_notify
-
         self._client = ads_client
         self._client.open()
 

homeassistant/components/binary_sensor/ads.py

@@ -1,16 +1,13 @@
 """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.components.ads import DATA_ADS, CONF_ADSVAR
 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
 
 
@@ -24,8 +21,6 @@
     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,
 })
 
 
@@ -38,38 +33,24 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     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)
+    ads_sensor = AdsBinarySensor(ads_hub, name, adsvar, device_class)
     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)
+    ads_hub.add_device_notification(adsvar, ads_hub.PLCTYPE_BOOL,
+                                    ads_sensor.callback)
 
 
 class AdsBinarySensor(BinarySensorDevice):
     """Representation of ADS binary sensors."""
 
-    def __init__(self, ads_hub, name, adsvar, device_class, use_notify,
-                 poll_interval):
+    def __init__(self, ads_hub, name, adsvar, device_class):
         """Initialize AdsBinarySensor entity."""
         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):
@@ -95,19 +76,3 @@ def callback(self, name, value):
             self.schedule_update_ha_state()
         except AttributeError:
             pass
-
-    def poll(self, now):
-        """Handle polling."""
-        try:
-            self._state = self._ads_hub.read_by_name(
-                self.adsvar, self._ads_hub.PLCTYPE_BOOL
-            )
-            _LOGGER.debug('Polled value for bool variable %s: %d',
-                          self.adsvar, self._state)
-        except self._ads_hub.ADSError as err:
-            _LOGGER.error(err)
-
-        try:
-            self.schedule_update_ha_state()
-        except AttributeError:
-            pass

homeassistant/components/light/ads.py

@@ -91,8 +91,6 @@ def turn_on(self, **kwargs):
             self._ads_hub.write_by_name(self.varname_brightness, bval,
                                         self._ads_hub.PLCTYPE_UINT)
 
-        self._on_state = True
-
     def turn_off(self, **kwargs):
         """Turn the light off."""
         brightness = kwargs.get(ATTR_BRIGHTNESS)
@@ -104,7 +102,6 @@ def turn_off(self, **kwargs):
         if self.varname_brightness is not None:
             self._ads_hub.write_by_name(self.varname_brightness, bval,
                                         self._ads_hub.PLCTYPE_UINT)
-        self._on_state = False
 
     def value_changed(self, val):
         """Handle value change."""

homeassistant/components/sensor/ads.py

@@ -1,16 +1,14 @@
 """Support for ADS sensors."""
 
 import logging
-from datetime import timedelta
 import voluptuous as vol
 from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.const import CONF_NAME, CONF_UNIT_OF_MEASUREMENT
 from homeassistant.helpers.entity import Entity
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.components import ads
 from homeassistant.components.ads import CONF_ADSVAR, CONF_ADSTYPE, \
-    CONF_ADS_USE_NOTIFY, CONF_ADS_POLL_INTERVAL, CONF_ADS_FACTOR
+    CONF_ADS_FACTOR
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,8 +22,6 @@
     vol.Optional(CONF_ADSTYPE, default=ads.ADSTYPE_INT): vol.In(
         [ads.ADSTYPE_INT, ads.ADSTYPE_UINT, ads.ADSTYPE_BYTE]
     ),
-    vol.Optional(CONF_ADS_USE_NOTIFY): cv.boolean,
-    vol.Optional(CONF_ADS_POLL_INTERVAL): cv.positive_int,
     vol.Optional(CONF_ADS_FACTOR): cv.positive_int,
 })
 
@@ -40,43 +36,31 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     adstype = config.get(CONF_ADSTYPE)
     name = config.get(CONF_NAME)
     unit_of_measurement = config.get(CONF_UNIT_OF_MEASUREMENT)
-    use_notify = config.get(CONF_ADS_USE_NOTIFY, ads_hub.use_notify)
-    poll_interval = config.get(CONF_ADS_POLL_INTERVAL, ads_hub.poll_interval)
     factor = config.get(CONF_ADS_FACTOR)
 
     entity = AdsSensor(ads_hub, adsvar, adstype, name,
-                       unit_of_measurement, use_notify, poll_interval, factor)
+                       unit_of_measurement, factor)
 
     add_devices([entity])
 
-    if use_notify:
-        ads_hub.add_device_notification(adsvar, ads_hub.ADS_TYPEMAP[adstype],
-                                        entity.callback)
-    else:
-        dtime = timedelta(0, 0, poll_interval * 1000)
-        async_track_time_interval(hass, entity.poll, dtime)
+    ads_hub.add_device_notification(adsvar, ads_hub.ADS_TYPEMAP[adstype],
+                                    entity.callback)
 
 
 class AdsSensor(Entity):
     """Representation of an ADS sensor entity."""
 
     def __init__(self, ads_hub, adsvar, adstype, devname, unit_of_measurement,
-                 use_notify, poll_interval, factor):
+                 factor):
         """Initialize AdsSensor entity."""
         self._ads_hub = ads_hub
         self._name = devname
         self._value = 0
         self._unit_of_measurement = unit_of_measurement
         self.adsvar = adsvar
         self.adstype = adstype
-        self.use_notify = use_notify
-        self.poll_interval = poll_interval
         self.factor = factor
 
-        # make first poll if notifications disabled
-        if not self.use_notify:
-            self.poll(None)
-
     @property
     def name(self):
         """Return the name of the entity."""
@@ -106,26 +90,3 @@ def callback(self, name, value):
             self.schedule_update_ha_state()
         except AttributeError:
             pass
-
-    def poll(self, now):
-        """Poll value from ADS device."""
-        try:
-            val = self._ads_hub.read_by_name(
-                self.adsvar, self._ads_hub.ADS_TYPEMAP[self.adstype]
-            )
-
-            if self.factor is None:
-                self._value = val
-            else:
-                self._value = val / self.factor
-
-            _LOGGER.debug('Polled value for variable %s: %d',
-                          self.adsvar, self._value)
-
-        except self._ads_hub.ADSError as err:
-            _LOGGER.error(err)
-
-        try:
-            self.schedule_update_ha_state()
-        except AttributeError:
-            pass