text: """Support for ADS covers."""
  import logging
  
  import voluptuous as vol
  
  from homeassistant.components.cover import (
      PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_STOP,
      SUPPORT_SET_POSITION, ATTR_POSITION, DEVICE_CLASSES_SCHEMA,
      CoverDevice)
  from homeassistant.const import (
      CONF_NAME, CONF_DEVICE_CLASS)
  import homeassistant.helpers.config_validation as cv
  
  from . import CONF_ADS_VAR, CONF_ADS_VAR_POSITION, DATA_ADS, \
      AdsEntity, STATE_KEY_STATE, STATE_KEY_POSITION
  
  _LOGGER = logging.getLogger(__name__)
  
  DEFAULT_NAME = 'ADS Cover'
  
  CONF_ADS_VAR_SET_POS = 'adsvar_set_position'
  CONF_ADS_VAR_OPEN = 'adsvar_open'
  CONF_ADS_VAR_CLOSE = 'adsvar_close'
  CONF_ADS_VAR_STOP = 'adsvar_stop'
  
  PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
      vol.Optional(CONF_ADS_VAR): cv.string,
      vol.Optional(CONF_ADS_VAR_POSITION): cv.string,
      vol.Optional(CONF_ADS_VAR_SET_POS): cv.string,
      vol.Optional(CONF_ADS_VAR_CLOSE): cv.string,
      vol.Optional(CONF_ADS_VAR_OPEN): cv.string,
      vol.Optional(CONF_ADS_VAR_STOP): cv.string,
      vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
      vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA
  })
  
  
  def setup_platform(hass, config, add_entities, discovery_info=None):
      """Set up the cover platform for ADS."""
      ads_hub = hass.data[DATA_ADS]
  
      ads_var_is_closed = config.get(CONF_ADS_VAR)
      ads_var_position = config.get(CONF_ADS_VAR_POSITION)
      ads_var_pos_set = config.get(CONF_ADS_VAR_SET_POS)
      ads_var_open = config.get(CONF_ADS_VAR_OPEN)
      ads_var_close = config.get(CONF_ADS_VAR_CLOSE)
      ads_var_stop = config.get(CONF_ADS_VAR_STOP)
      name = config[CONF_NAME]
      device_class = config.get(CONF_DEVICE_CLASS)
  
      add_entities([AdsCover(ads_hub,
                             ads_var_is_closed,
                             ads_var_position,
                             ads_var_pos_set,
                             ads_var_open,
                             ads_var_close,
                             ads_var_stop,
                             name,
                             device_class)])
  
  
  class AdsCover(AdsEntity, CoverDevice):
      """Representation of ADS cover."""
  
      def __init__(self, ads_hub,
                   ads_var_is_closed, ads_var_position,
                   ads_var_pos_set, ads_var_open,
                   ads_var_close, ads_var_stop, name, device_class):
          """Initialize AdsCover entity."""
          super().__init__(ads_hub, name, ads_var_is_closed)
          if self._ads_var is None:
              if ads_var_position is not None:
                  self._unique_id = ads_var_position
              elif ads_var_pos_set is not None:
                  self._unique_id = ads_var_pos_set
              elif ads_var_open is not None:
                  self._unique_id = ads_var_open
  
          self._state_dict[STATE_KEY_POSITION] = None
          self._ads_var_position = ads_var_position
          self._ads_var_pos_set = ads_var_pos_set
          self._ads_var_open = ads_var_open
          self._ads_var_close = ads_var_close
          self._ads_var_stop = ads_var_stop
          self._device_class = device_class
  
      async def async_added_to_hass(self):
          """Register device notification."""
          if self._ads_var is not None:
              await self.async_initialize_device(self._ads_var,
                                                 self._ads_hub.PLCTYPE_BOOL)
  
          if self._ads_var_position is not None:
              await self.async_initialize_device(self._ads_var_position,
                                                 self._ads_hub.PLCTYPE_BYTE,
                                                 STATE_KEY_POSITION)
  
      @property
      def device_class(self):
          """Return the class of this cover."""
          return self._device_class
  
      @property
      def is_closed(self):
          """Return if the cover is closed."""
          if self._ads_var is not None:
              return self._state_dict[STATE_KEY_STATE]
          if self._ads_var_position is not None:
              return self._state_dict[STATE_KEY_POSITION] == 0
          return None
  
      @property
      def current_cover_position(self):
          """Return current position of cover."""
          return self._state_dict[STATE_KEY_POSITION]
  
      @property
      def supported_features(self):
          """Flag supported features."""
          supported_features = SUPPORT_OPEN | SUPPORT_CLOSE
  
          if self._ads_var_stop is not None:
              supported_features |= SUPPORT_STOP
  
          if self._ads_var_pos_set is not None:
              supported_features |= SUPPORT_SET_POSITION
  
          return supported_features
  
      def stop_cover(self, **kwargs):
          """Fire the stop action."""
          if self._ads_var_stop:
              self._ads_hub.write_by_name(self._ads_var_stop, True,
                                          self._ads_hub.PLCTYPE_BOOL)
  
      def set_cover_position(self, **kwargs):
          """Set cover position."""
          position = kwargs[ATTR_POSITION]
          if self._ads_var_pos_set is not None:
              self._ads_hub.write_by_name(self._ads_var_pos_set, position,
                                          self._ads_hub.PLCTYPE_BYTE)
  
      def open_cover(self, **kwargs):
          """Move the cover up."""
          if self._ads_var_open is not None:
              self._ads_hub.write_by_name(self._ads_var_open, True,
                                          self._ads_hub.PLCTYPE_BOOL)
          elif self._ads_var_pos_set is not None:
              self.set_cover_position(position=100)
  
      def close_cover(self, **kwargs):
          """Move the cover down."""
          if self._ads_var_close is not None:
              self._ads_hub.write_by_name(self._ads_var_close, True,
                                          self._ads_hub.PLCTYPE_BOOL)
          elif self._ads_var_pos_set is not None:
              self.set_cover_position(position=0)
  
      @property
      def available(self):
          """Return False if state has not been updated yet."""
          if self._ads_var is not None or self._ads_var_position is not None:
              return self._state_dict[STATE_KEY_STATE] is not None or \
                     self._state_dict[STATE_KEY_POSITION] is not None
          return True
  