Bugfix and cleanup for Rfxtrx (#11600)

* rfxtrx clean up

* rfxtrx clean up

* rfxtrx clean up

homeassistant/components/binary_sensor/rfxtrx.py

@@ -7,30 +7,40 @@ tested. Other types may need some work.
 """
 
 import logging
+
 import voluptuous as vol
+
+from homeassistant.const import (
+    CONF_DEVICE_CLASS, CONF_COMMAND_ON, CONF_COMMAND_OFF, CONF_NAME)
 from homeassistant.components import rfxtrx
+from homeassistant.helpers import event as evt
+from homeassistant.helpers import config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.rfxtrx import (
+    ATTR_NAME, ATTR_DATA_BITS, ATTR_OFF_DELAY, ATTR_FIRE_EVENT,
+    CONF_AUTOMATIC_ADD, CONF_FIRE_EVENT,
+    CONF_DATA_BITS, CONF_DEVICES)
 from homeassistant.util import slugify
 from homeassistant.util import dt as dt_util
-from homeassistant.helpers import config_validation as cv
+
-from homeassistant.helpers import event as evt
-from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.rfxtrx import (
-    ATTR_AUTOMATIC_ADD, ATTR_NAME, ATTR_OFF_DELAY, ATTR_FIREEVENT,
-    ATTR_DATA_BITS, CONF_DEVICES
-)
-from homeassistant.const import (
-    CONF_DEVICE_CLASS, CONF_COMMAND_ON, CONF_COMMAND_OFF
-)
 
 DEPENDENCIES = ["rfxtrx"]
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORM_SCHEMA = vol.Schema({
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required("platform"): rfxtrx.DOMAIN,
+    vol.Optional(CONF_DEVICES, default={}): {
-    vol.Optional(CONF_DEVICES, default={}): vol.All(
+        cv.string: vol.Schema({
-        dict, rfxtrx.valid_binary_sensor),
+            vol.Optional(CONF_NAME): cv.string,
-    vol.Optional(ATTR_AUTOMATIC_ADD, default=False):  cv.boolean,
+            vol.Optional(CONF_DEVICE_CLASS): cv.string,
+            vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean,
+            vol.Optional(CONF_DATA_BITS): cv.positive_int,
+            vol.Optional(CONF_COMMAND_ON): cv.byte,
+            vol.Optional(CONF_COMMAND_OFF): cv.byte
+        })
+    },
+    vol.Optional(CONF_AUTOMATIC_ADD, default=False):  cv.boolean,
 }, extra=vol.ALLOW_EXTRA)
 
 
@@ -46,17 +56,17 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
         if device_id in rfxtrx.RFX_DEVICES:
             continue
 
-        if entity[ATTR_DATA_BITS] is not None:
+        if entity[CONF_DATA_BITS] is not None:
-            _LOGGER.info("Masked device id: %s",
+            _LOGGER.debug("Masked device id: %s",
-                         rfxtrx.get_pt2262_deviceid(device_id,
+                          rfxtrx.get_pt2262_deviceid(device_id,
-                                                    entity[ATTR_DATA_BITS]))
+                                                     entity[ATTR_DATA_BITS]))
 
-        _LOGGER.info("Add %s rfxtrx.binary_sensor (class %s)",
+        _LOGGER.debug("Add %s rfxtrx.binary_sensor (class %s)",
-                     entity[ATTR_NAME], entity[CONF_DEVICE_CLASS])
+                      entity[ATTR_NAME], entity[CONF_DEVICE_CLASS])
 
         device = RfxtrxBinarySensor(event, entity[ATTR_NAME],
                                     entity[CONF_DEVICE_CLASS],
-                                    entity[ATTR_FIREEVENT],
+                                    entity[ATTR_FIRE_EVENT],
                                     entity[ATTR_OFF_DELAY],
                                     entity[ATTR_DATA_BITS],
                                     entity[CONF_COMMAND_ON],
@@ -82,15 +92,15 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
 
         if sensor is None:
             # Add the entity if not exists and automatic_add is True
-            if not config[ATTR_AUTOMATIC_ADD]:
+            if not config[CONF_AUTOMATIC_ADD]:
                 return
 
             if event.device.packettype == 0x13:
                 poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
                 if poss_dev is not None:
                     poss_id = slugify(poss_dev.event.device.id_string.lower())
-                    _LOGGER.info("Found possible matching deviceid %s.",
+                    _LOGGER.debug("Found possible matching deviceid %s.",
-                                 poss_id)
+                                  poss_id)
 
             pkt_id = "".join("{0:02x}".format(x) for x in event.data)
             sensor = RfxtrxBinarySensor(event, pkt_id)
@@ -107,11 +117,11 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
         elif not isinstance(sensor, RfxtrxBinarySensor):
             return
         else:
-            _LOGGER.info("Binary sensor update "
+            _LOGGER.debug("Binary sensor update "
-                         "(Device_id: %s Class: %s Sub: %s)",
+                          "(Device_id: %s Class: %s Sub: %s)",
-                         slugify(event.device.id_string.lower()),
+                          slugify(event.device.id_string.lower()),
-                         event.device.__class__.__name__,
+                          event.device.__class__.__name__,
-                         event.device.subtype)
+                          event.device.subtype)
 
         if sensor.is_lighting4:
             if sensor.data_bits is not None:
@@ -163,10 +173,8 @@ class RfxtrxBinarySensor(BinarySensorDevice):
             self._masked_id = rfxtrx.get_pt2262_deviceid(
                 event.device.id_string.lower(),
                 data_bits)
-
+        else:
-    def __str__(self):
+            self._masked_id = None
-        """Return the name of the sensor."""
-        return self._name
 
     @property
     def name(self):

homeassistant/components/cover/rfxtrx.py

@@ -4,12 +4,29 @@ Support for RFXtrx cover components.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/cover.rfxtrx/
 """
+import voluptuous as vol
+
 import homeassistant.components.rfxtrx as rfxtrx
-from homeassistant.components.cover import CoverDevice
+from homeassistant.components.cover import CoverDevice, PLATFORM_SCHEMA
+from homeassistant.const import CONF_NAME
+from homeassistant.components.rfxtrx import (
+    CONF_AUTOMATIC_ADD, CONF_FIRE_EVENT, DEFAULT_SIGNAL_REPETITIONS,
+    CONF_SIGNAL_REPETITIONS, CONF_DEVICES)
+from homeassistant.helpers import config_validation as cv
 
 DEPENDENCIES = ['rfxtrx']
 
-PLATFORM_SCHEMA = rfxtrx.DEFAULT_SCHEMA
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_DEVICES, default={}): {
+        cv.string: vol.Schema({
+            vol.Required(CONF_NAME): cv.string,
+            vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean
+        })
+    },
+    vol.Optional(CONF_AUTOMATIC_ADD, default=False):  cv.boolean,
+    vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS):
+        vol.Coerce(int),
+})
 
 
 def setup_platform(hass, config, add_devices_callback, discovery_info=None):

homeassistant/components/light/rfxtrx.py

@@ -6,15 +6,32 @@ https://home-assistant.io/components/light.rfxtrx/
 """
 import logging
 
+import voluptuous as vol
+
 import homeassistant.components.rfxtrx as rfxtrx
-from homeassistant.components.light import (ATTR_BRIGHTNESS,
+from homeassistant.components.light import (
-                                            SUPPORT_BRIGHTNESS, Light)
+    ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light, PLATFORM_SCHEMA)
+from homeassistant.const import CONF_NAME
+from homeassistant.components.rfxtrx import (
+    CONF_AUTOMATIC_ADD, CONF_FIRE_EVENT, DEFAULT_SIGNAL_REPETITIONS,
+    CONF_SIGNAL_REPETITIONS, CONF_DEVICES)
+from homeassistant.helpers import config_validation as cv
 
 DEPENDENCIES = ['rfxtrx']
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORM_SCHEMA = rfxtrx.DEFAULT_SCHEMA
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_DEVICES, default={}): {
+        cv.string: vol.Schema({
+            vol.Required(CONF_NAME): cv.string,
+            vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean
+        })
+    },
+    vol.Optional(CONF_AUTOMATIC_ADD, default=False):  cv.boolean,
+    vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS):
+        vol.Coerce(int),
+})
 
 SUPPORT_RFXTRX = SUPPORT_BRIGHTNESS
 

homeassistant/components/rfxtrx.py

@@ -16,11 +16,11 @@ from homeassistant.const import (
     EVENT_HOMEASSISTANT_START,
     EVENT_HOMEASSISTANT_STOP,
     ATTR_ENTITY_ID, TEMP_CELSIUS,
-    CONF_DEVICE_CLASS, CONF_COMMAND_ON, CONF_COMMAND_OFF
+    CONF_DEVICES
 )
 from homeassistant.helpers.entity import Entity
 
-REQUIREMENTS = ['pyRFXtrx==0.20.1']
+REQUIREMENTS = ['pyRFXtrx==0.21.1']
 
 DOMAIN = 'rfxtrx'
 
@@ -31,13 +31,19 @@ ATTR_DEVICE = 'device'
 ATTR_DEBUG = 'debug'
 ATTR_STATE = 'state'
 ATTR_NAME = 'name'
-ATTR_FIREEVENT = 'fire_event'
+ATTR_FIRE_EVENT = 'fire_event'
 ATTR_DATA_TYPE = 'data_type'
 ATTR_DATA_BITS = 'data_bits'
 ATTR_DUMMY = 'dummy'
 ATTR_OFF_DELAY = 'off_delay'
+CONF_AUTOMATIC_ADD = 'automatic_add'
+CONF_DATA_TYPE = 'data_type'
 CONF_SIGNAL_REPETITIONS = 'signal_repetitions'
-CONF_DEVICES = 'devices'
+CONF_FIRE_EVENT = 'fire_event'
+CONF_DATA_BITS = 'data_bits'
+CONF_DUMMY = 'dummy'
+CONF_DEVICE = 'device'
+CONF_DEBUG = 'debug'
 EVENT_BUTTON_PRESSED = 'button_pressed'
 
 DATA_TYPES = OrderedDict([
@@ -57,93 +63,13 @@ DATA_TYPES = OrderedDict([
 RECEIVED_EVT_SUBSCRIBERS = []
 RFX_DEVICES = {}
 _LOGGER = logging.getLogger(__name__)
-RFXOBJECT = 'rfxobject'
+DATA_RFXOBJECT = 'rfxobject'
-
-
-def _valid_device(value, device_type):
-    """Validate a dictionary of devices definitions."""
-    config = OrderedDict()
-    for key, device in value.items():
-
-        # Still accept old configuration
-        if 'packetid' in device.keys():
-            msg = 'You are using an outdated configuration of the rfxtrx ' +\
-                  'device, {}.'.format(key) +\
-                  ' Your new config should be:\n    {}: \n        name: {}'\
-                  .format(device.get('packetid'),
-                          device.get(ATTR_NAME, 'deivce_name'))
-            _LOGGER.warning(msg)
-            key = device.get('packetid')
-            device.pop('packetid')
-
-        key = str(key)
-        if not len(key) % 2 == 0:
-            key = '0' + key
-
-        if device_type == 'sensor':
-            config[key] = DEVICE_SCHEMA_SENSOR(device)
-        elif device_type == 'binary_sensor':
-            config[key] = DEVICE_SCHEMA_BINARYSENSOR(device)
-        elif device_type == 'light_switch':
-            config[key] = DEVICE_SCHEMA(device)
-        else:
-            raise vol.Invalid('Rfxtrx device is invalid')
-
-        if not config[key][ATTR_NAME]:
-            config[key][ATTR_NAME] = key
-    return config
-
-
-def valid_sensor(value):
-    """Validate sensor configuration."""
-    return _valid_device(value, "sensor")
-
-
-def valid_binary_sensor(value):
-    """Validate binary sensor configuration."""
-    return _valid_device(value, "binary_sensor")
-
-
-def _valid_light_switch(value):
-    return _valid_device(value, "light_switch")
-
-
-DEVICE_SCHEMA = vol.Schema({
-    vol.Required(ATTR_NAME): cv.string,
-    vol.Optional(ATTR_FIREEVENT, default=False): cv.boolean,
-})
-
-DEVICE_SCHEMA_SENSOR = vol.Schema({
-    vol.Optional(ATTR_NAME, default=None): cv.string,
-    vol.Optional(ATTR_FIREEVENT, default=False): cv.boolean,
-    vol.Optional(ATTR_DATA_TYPE, default=[]):
-        vol.All(cv.ensure_list, [vol.In(DATA_TYPES.keys())]),
-})
-
-DEVICE_SCHEMA_BINARYSENSOR = vol.Schema({
-    vol.Optional(ATTR_NAME, default=None): cv.string,
-    vol.Optional(CONF_DEVICE_CLASS, default=None): cv.string,
-    vol.Optional(ATTR_FIREEVENT, default=False): cv.boolean,
-    vol.Optional(ATTR_OFF_DELAY, default=None):
-        vol.Any(cv.time_period, cv.positive_timedelta),
-    vol.Optional(ATTR_DATA_BITS, default=None): cv.positive_int,
-    vol.Optional(CONF_COMMAND_ON, default=None): cv.byte,
-    vol.Optional(CONF_COMMAND_OFF, default=None): cv.byte
-})
-
-DEFAULT_SCHEMA = vol.Schema({
-    vol.Required("platform"): DOMAIN,
-    vol.Optional(CONF_DEVICES, default={}): vol.All(dict, _valid_light_switch),
-    vol.Optional(ATTR_AUTOMATIC_ADD, default=False):  cv.boolean,
-    vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS):
-        vol.Coerce(int),
-})
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.Schema({
-        vol.Required(ATTR_DEVICE): cv.string,
+        vol.Required(CONF_DEVICE): cv.string,
-        vol.Optional(ATTR_DEBUG, default=False): cv.boolean,
+        vol.Optional(CONF_DEBUG, default=False): cv.boolean,
-        vol.Optional(ATTR_DUMMY, default=False): cv.boolean,
+        vol.Optional(CONF_DUMMY, default=False): cv.boolean,
     }),
 }, extra=vol.ALLOW_EXTRA)
 
@@ -152,7 +78,7 @@ def setup(hass, config):
     """Set up the RFXtrx component."""
     # Declare the Handle event
     def handle_receive(event):
-        """Handle revieved messgaes from RFXtrx gateway."""
+        """Handle revieved messages from RFXtrx gateway."""
         # Log RFXCOM event
         if not event.device.id_string:
             return
@@ -175,21 +101,22 @@ def setup(hass, config):
     dummy_connection = config[DOMAIN][ATTR_DUMMY]
 
     if dummy_connection:
-        hass.data[RFXOBJECT] =\
+        rfx_object = rfxtrxmod.Connect(
-            rfxtrxmod.Connect(device, None, debug=debug,
+            device, None, debug=debug,
-                              transport_protocol=rfxtrxmod.DummyTransport2)
+            transport_protocol=rfxtrxmod.DummyTransport2)
     else:
-        hass.data[RFXOBJECT] = rfxtrxmod.Connect(device, None, debug=debug)
+        rfx_object = rfxtrxmod.Connect(device, None, debug=debug)
 
     def _start_rfxtrx(event):
-        hass.data[RFXOBJECT].event_callback = handle_receive
+        rfx_object.event_callback = handle_receive
     hass.bus.listen_once(EVENT_HOMEASSISTANT_START, _start_rfxtrx)
 
     def _shutdown_rfxtrx(event):
         """Close connection with RFXtrx."""
-        hass.data[RFXOBJECT].close_connection()
+        rfx_object.close_connection()
     hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown_rfxtrx)
 
+    hass.data[DATA_RFXOBJECT] = rfx_object
     return True
 
 
@@ -248,9 +175,9 @@ def get_pt2262_device(device_id):
         if (hasattr(device, 'is_lighting4') and
                 device.masked_id == get_pt2262_deviceid(device_id,
                                                         device.data_bits)):
-            _LOGGER.info("rfxtrx: found matching device %s for %s",
+            _LOGGER.debug("rfxtrx: found matching device %s for %s",
-                         device_id,
+                          device_id,
-                         device.masked_id)
+                          device.masked_id)
             return device
     return None
 
@@ -295,11 +222,11 @@ def get_devices_from_config(config, device):
         device_id = slugify(event.device.id_string.lower())
         if device_id in RFX_DEVICES:
             continue
-        _LOGGER.info("Add %s rfxtrx", entity_info[ATTR_NAME])
+        _LOGGER.debug("Add %s rfxtrx", entity_info[ATTR_NAME])
 
         # Check if i must fire event
-        fire_event = entity_info[ATTR_FIREEVENT]
+        fire_event = entity_info[ATTR_FIRE_EVENT]
-        datas = {ATTR_STATE: False, ATTR_FIREEVENT: fire_event}
+        datas = {ATTR_STATE: False, ATTR_FIRE_EVENT: fire_event}
 
         new_device = device(entity_info[ATTR_NAME], event, datas,
                             signal_repetitions)
@@ -318,14 +245,14 @@ def get_new_device(event, config, device):
         return
 
     pkt_id = "".join("{0:02x}".format(x) for x in event.data)
-    _LOGGER.info(
+    _LOGGER.debug(
         "Automatic add %s rfxtrx device (Class: %s Sub: %s Packet_id: %s)",
         device_id,
         event.device.__class__.__name__,
         event.device.subtype,
         pkt_id
     )
-    datas = {ATTR_STATE: False, ATTR_FIREEVENT: False}
+    datas = {ATTR_STATE: False, ATTR_FIRE_EVENT: False}
     signal_repetitions = config[CONF_SIGNAL_REPETITIONS]
     new_device = device(pkt_id, event, datas,
                         signal_repetitions)
@@ -370,7 +297,7 @@ def apply_received_command(event):
                 ATTR_STATE: event.values['Command'].lower()
             }
         )
-        _LOGGER.info(
+        _LOGGER.debug(
             "Rfxtrx fired event: (event_type: %s, %s: %s, %s: %s)",
             EVENT_BUTTON_PRESSED,
             ATTR_ENTITY_ID,
@@ -392,7 +319,7 @@ class RfxtrxDevice(Entity):
         self._name = name
         self._event = event
         self._state = datas[ATTR_STATE]
-        self._should_fire_event = datas[ATTR_FIREEVENT]
+        self._should_fire_event = datas[ATTR_FIRE_EVENT]
         self._brightness = 0
         self.added_to_hass = False
 
@@ -440,40 +367,35 @@ class RfxtrxDevice(Entity):
     def _send_command(self, command, brightness=0):
         if not self._event:
             return
+        rfx_object = self.hass.data[DATA_RFXOBJECT]
 
         if command == "turn_on":
             for _ in range(self.signal_repetitions):
-                self._event.device.send_on(self.hass.data[RFXOBJECT]
+                self._event.device.send_on(rfx_object.transport)
-                                           .transport)
             self._state = True
 
         elif command == "dim":
             for _ in range(self.signal_repetitions):
-                self._event.device.send_dim(self.hass.data[RFXOBJECT]
+                self._event.device.send_dim(rfx_object.transport, brightness)
-                                            .transport, brightness)
             self._state = True
 
         elif command == 'turn_off':
             for _ in range(self.signal_repetitions):
-                self._event.device.send_off(self.hass.data[RFXOBJECT]
+                self._event.device.send_off(rfx_object.transport)
-                                            .transport)
             self._state = False
             self._brightness = 0
 
         elif command == "roll_up":
             for _ in range(self.signal_repetitions):
-                self._event.device.send_open(self.hass.data[RFXOBJECT]
+                self._event.device.send_open(rfx_object.transport)
-                                             .transport)
 
         elif command == "roll_down":
             for _ in range(self.signal_repetitions):
-                self._event.device.send_close(self.hass.data[RFXOBJECT]
+                self._event.device.send_close(rfx_object.transport)
-                                              .transport)
 
         elif command == "stop_roll":
             for _ in range(self.signal_repetitions):
-                self._event.device.send_stop(self.hass.data[RFXOBJECT]
+                self._event.device.send_stop(rfx_object.transport)
-                                             .transport)
 
         if self.added_to_hass:
             self.schedule_update_ha_state()

homeassistant/components/sensor/rfxtrx.py

@@ -10,21 +10,28 @@ import voluptuous as vol
 
 import homeassistant.components.rfxtrx as rfxtrx
 import homeassistant.helpers.config_validation as cv
-from homeassistant.const import CONF_PLATFORM
+from homeassistant.const import ATTR_ENTITY_ID, CONF_NAME
 from homeassistant.helpers.entity import Entity
 from homeassistant.util import slugify
+from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.components.rfxtrx import (
-    ATTR_AUTOMATIC_ADD, ATTR_NAME, ATTR_FIREEVENT, CONF_DEVICES, DATA_TYPES,
+    ATTR_NAME, ATTR_FIRE_EVENT, ATTR_DATA_TYPE, CONF_AUTOMATIC_ADD,
-    ATTR_DATA_TYPE, ATTR_ENTITY_ID)
+    CONF_FIRE_EVENT, CONF_DEVICES, DATA_TYPES, CONF_DATA_TYPE)
 
 DEPENDENCIES = ['rfxtrx']
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORM_SCHEMA = vol.Schema({
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PLATFORM): rfxtrx.DOMAIN,
+    vol.Optional(CONF_DEVICES, default={}): {
-    vol.Optional(CONF_DEVICES, default={}): vol.All(dict, rfxtrx.valid_sensor),
+        cv.string: vol.Schema({
-    vol.Optional(ATTR_AUTOMATIC_ADD, default=False):  cv.boolean,
+            vol.Optional(CONF_NAME): cv.string,
+            vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean,
+            vol.Optional(CONF_DATA_TYPE, default=[]):
+            vol.All(cv.ensure_list, [vol.In(DATA_TYPES.keys())]),
+        })
+    },
+    vol.Optional(CONF_AUTOMATIC_ADD, default=False):  cv.boolean,
 }, extra=vol.ALLOW_EXTRA)
 
 
@@ -49,7 +56,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                     break
         for _data_type in data_types:
             new_sensor = RfxtrxSensor(None, entity_info[ATTR_NAME],
-                                      _data_type, entity_info[ATTR_FIREEVENT])
+                                      _data_type, entity_info[ATTR_FIRE_EVENT])
             sensors.append(new_sensor)
             sub_sensors[_data_type] = new_sensor
         rfxtrx.RFX_DEVICES[device_id] = sub_sensors
@@ -78,7 +85,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
             return
 
         # Add entity if not exist and the automatic_add is True
-        if not config[ATTR_AUTOMATIC_ADD]:
+        if not config[CONF_AUTOMATIC_ADD]:
             return
 
         pkt_id = "".join("{0:02x}".format(x) for x in event.data)

homeassistant/components/switch/rfxtrx.py

@@ -6,14 +6,31 @@ https://home-assistant.io/components/switch.rfxtrx/
 """
 import logging
 
+import voluptuous as vol
+
 import homeassistant.components.rfxtrx as rfxtrx
-from homeassistant.components.switch import SwitchDevice
+from homeassistant.components.switch import SwitchDevice, PLATFORM_SCHEMA
+from homeassistant.const import CONF_NAME
+from homeassistant.components.rfxtrx import (
+    CONF_AUTOMATIC_ADD, CONF_FIRE_EVENT, DEFAULT_SIGNAL_REPETITIONS,
+    CONF_SIGNAL_REPETITIONS, CONF_DEVICES)
+from homeassistant.helpers import config_validation as cv
 
 DEPENDENCIES = ['rfxtrx']
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORM_SCHEMA = rfxtrx.DEFAULT_SCHEMA
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_DEVICES, default={}): {
+        cv.string: vol.Schema({
+            vol.Required(CONF_NAME): cv.string,
+            vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean
+        })
+    },
+    vol.Optional(CONF_AUTOMATIC_ADD, default=False):  cv.boolean,
+    vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS):
+        vol.Coerce(int),
+})
 
 
 def setup_platform(hass, config, add_devices_callback, discovery_info=None):

requirements_all.txt

@@ -622,7 +622,7 @@ pyCEC==0.4.13
 pyHS100==0.3.0
 
 # homeassistant.components.rfxtrx
-pyRFXtrx==0.20.1
+pyRFXtrx==0.21.1
 
 # homeassistant.components.sensor.tibber
 pyTibber==0.2.1