Home Assistant switch description

This is my document about the development of a switch platform for the Home Assistant project.

If you haven't already read the component description, please do so first.

W800rf32 switch platform code

Support for w800rf32 switches.

For more details about this platform, please refer to the documentation at

# Example configuration.yaml entry

  - platform: w800rf32
        name: keypad_1_1
        name: keypad_1_2



There isn't much change here from the components code, we have added the import from homeassistant.components.switch because our w800rf32SwitchDevice class inherits the HA SwitchDevice.

import logging

import voluptuous as vol

from homeassistant.components import w800rf32
from homeassistant.components.switch import (
    PLATFORM_SCHEMA, SwitchDevice)
from homeassistant.components.w800rf32 import (CONF_FIRE_EVENT)
from homeassistant.const import (ATTR_NAME, CONF_DEVICES, CONF_NAME)
from homeassistant.helpers import config_validation as cv

_LOGGER = logging.getLogger(__name__)


This tells the code we depend on the w800rf32 component code.

DEPENDENCIES = ['w800rf32']

    vol.Optional(CONF_DEVICES, default={}): {
        cv.string: vol.Schema({
            vol.Optional(CONF_NAME): cv.string,
            vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean
}, extra=vol.ALLOW_EXTRA)


Called from: homeassistant.setup

This is where we setup our platform for HA.

Here is the HA checklist for creating a platform. So lets list what we are doing in our platform:

    1. Define a setup_platform function and pass in the hass object, the config dictionary and the add_entities function.
    2. Setup an an switch_update function to deal with events.
    3. Import the W800rf32 module
    4. Get the entities from config and add them to the hass object.
    5. Finally add the switch_update function to the event handler so it is run for every event.

We have already talked about the hass and config objects.
The add_entities function simply registers the entities inside HA. Here. is a description of the entity registry.

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the Switch platform to w800rf32."""
    import W800rf32 as w800rf32mod
    switches = []
config[CONF_DEVICES] is an OrderedDict and with a yaml file as described at the top of this page, it looks like this:

      OrderedDict([('name', 'keypad_1_1') )])),
      OrderedDict([('name', 'keypad_1_1')]))])

    # device_id --> "c1 or a3" X10 device. entity (type dictionary) --> name, device_class etc
    for device_id, entity in config[CONF_DEVICES].items():

        if device_id in w800rf32.W800_DEVICES:

        _LOGGER.debug("Add %s w800rf32.switch",

For each entity, make a w800rf32Switch object then add it to the hass object with add_entities().
Also keep track of all our entities in w800rf32.W800_DEVICES

        event = None  # None until an event happens
        device = w800rf32Switch(event, entity.get(CONF_NAME),entity[CONF_FIRE_EVENT],)

        w800rf32.W800_DEVICES[device_id] = device



Called from: handle_receive() in component
Returns: None

switch_update is called for every incoming event. We run some basic checks then apply the w800rf32.apply_received_command() fucntion from the component code.

    def switch_update(event):
        """Call for control updates from the w800rf32 gateway."""
        switch = None

        if not isinstance(event, w800rf32mod.W800rf32Event):

        # make sure it's lowercase
        device_id = event.device.lower()

        # get the name, ex: motion_hall
        if device_id in w800rf32.W800_DEVICES:
            switch = w800rf32.W800_DEVICES[device_id]

        if switch is None:
        elif not isinstance(switch, w800rf32Switch):
                "Binary sensor update (Device ID: %s Class: %s)",


Finally add the switch_update function to the list of event subscribers so it will be called when an event happens.

    # Subscribe to main w800rf32 events
    if switch_update not in w800rf32.RECEIVED_EVT_SUBSCRIBERS:

w800rf32Switch class

Called from:

Describe the w800rf32Switch object. This just overrides some of the HA SwitchDevice properties and functions to customize it for our object.
w800rf32Switch is used to keep state of each switch and is added in setup_platform().

class w800rf32Switch(SwitchDevice):
    """A representation of a w800rf32 switch."""

    def __init__(self, event, name, should_fire=False,):
        """Initialize the w800rf32 switch."""
        self.event = event
        self._name = name
        self._should_fire_event = should_fire
        self._state = False

    def name(self):
        """Return the device name."""
        return self._name

    def should_poll(self):
        """No polling needed."""
        return False

    def is_on(self):
        """Return true if the sensor state is True."""
        return self._state

    def should_fire_event(self):
        """Return is the device must fire event."""
        return self._should_fire_event

    def turn_on(self, **kwargs):
        self._state = True

    def turn_off(self, **kwargs):
        self._state = False

    def update_state(self, state):
        """Update the state of the device."""
        self._state = state