Add Plugwise USB-stick integration

.coveragerc

@@ -661,6 +661,8 @@ omit =
     homeassistant/components/plugwise/climate.py
     homeassistant/components/plugwise/sensor.py
     homeassistant/components/plugwise/switch.py
+    homeassistant/components/plugwise_stick/__init__.py
+    homeassistant/components/plugwise_stick/switch.py
     homeassistant/components/plum_lightpad/light.py
     homeassistant/components/pocketcasts/sensor.py
     homeassistant/components/point/*

CODEOWNERS

@@ -320,6 +320,7 @@ homeassistant/components/plaato/* @JohNan
 homeassistant/components/plant/* @ChristianKuehnel
 homeassistant/components/plex/* @jjlawren
 homeassistant/components/plugwise/* @CoMPaTech @bouwew
+homeassistant/components/plugwise_stick/* @brefra
 homeassistant/components/plum_lightpad/* @ColinHarrington @prystupa
 homeassistant/components/point/* @fredrike
 homeassistant/components/poolsense/* @haemishkyd

homeassistant/components/plugwise_stick/__init__.py

@@ -0,0 +1,180 @@
+"""Support for Plugwise devices connected to a Plugwise USB-stick."""
+import asyncio
+import logging
+
+import plugwise
+from plugwise.exceptions import (
+    CirclePlusError,
+    NetworkDown,
+    PortError,
+    StickInitError,
+    TimeoutException,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.entity import Entity
+
+from .const import (
+    AVAILABLE_SENSOR_ID,
+    CONF_USB_PATH,
+    DOMAIN,
+    SENSORS,
+    UNDO_UPDATE_LISTENER,
+)
+
+_LOGGER = logging.getLogger(__name__)
+CB_TYPE_NEW_NODE = "NEW_NODE"
+PLUGWISE_STICK_PLATFORMS = ["switch"]
+
+
+async def async_setup(hass, config):
+    """Set up the Plugwise stick platform."""
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Establish connection with plugwise USB-stick."""
+    hass.data.setdefault(DOMAIN, {})
+
+    def discover_finished():
+        """Create entities for all discovered nodes."""
+        nodes = stick.nodes()
+        _LOGGER.debug(
+            "Successfully discovered %s out of %s registered nodes",
+            str(len(nodes)),
+            str(stick.registered_nodes()),
+        )
+        for component in PLUGWISE_STICK_PLATFORMS:
+            hass.data[DOMAIN][config_entry.entry_id][component] = []
+            for mac in nodes:
+                if component in stick.node(mac).get_categories():
+                    hass.data[DOMAIN][config_entry.entry_id][component].append(mac)
+            hass.async_create_task(
+                hass.config_entries.async_forward_entry_setup(config_entry, component)
+            )
+        stick.auto_update()
+
+    def shutdown(event):
+        hass.async_add_executor_job(stick.disconnect)
+
+    stick = plugwise.stick(config_entry.data[CONF_USB_PATH])
+    hass.data[DOMAIN][config_entry.entry_id] = {"stick": stick}
+    try:
+        _LOGGER.debug("Connect to USB-Stick")
+        await hass.async_add_executor_job(stick.connect)
+        _LOGGER.debug("Initialize USB-stick")
+        await hass.async_add_executor_job(stick.initialize_stick)
+        _LOGGER.debug("Discover Circle+ node")
+        await hass.async_add_executor_job(stick.initialize_circle_plus)
+    except PortError:
+        _LOGGER.error("Connecting to Plugwise USBstick communication failed")
+        raise ConfigEntryNotReady
+    except StickInitError:
+        _LOGGER.error("Initializing of Plugwise USBstick communication failed")
+        await hass.async_add_executor_job(stick.disconnect)
+        raise ConfigEntryNotReady
+    except NetworkDown:
+        _LOGGER.warning("Plugwise zigbee network down")
+        await hass.async_add_executor_job(stick.disconnect)
+        raise ConfigEntryNotReady
+    except CirclePlusError:
+        _LOGGER.warning("Failed to connect to Circle+ node")
+        await hass.async_add_executor_job(stick.disconnect)
+        raise ConfigEntryNotReady
+    except TimeoutException:
+        _LOGGER.warning("Timeout")
+        await hass.async_add_executor_job(stick.disconnect)
+        raise ConfigEntryNotReady
+    _LOGGER.debug("Start discovery of registered nodes")
+    stick.scan(discover_finished)
+
+    # Listen when EVENT_HOMEASSISTANT_STOP is fired
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, shutdown)
+
+    # Listen for entry updates
+    hass.data[DOMAIN][config_entry.entry_id][
+        UNDO_UPDATE_LISTENER
+    ] = config_entry.add_update_listener(_async_update_listener)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Unload the Plugwise stick connection."""
+    unload_ok = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(config_entry, component)
+                for component in PLUGWISE_STICK_PLATFORMS
+            ]
+        )
+    )
+    hass.data[DOMAIN][config_entry.entry_id][UNDO_UPDATE_LISTENER]()
+    if unload_ok:
+        stick = hass.data[DOMAIN][config_entry.entry_id]["stick"]
+        await hass.async_add_executor_job(stick.disconnect)
+        hass.data[DOMAIN].pop(config_entry.entry_id)
+    return unload_ok
+
+
+async def _async_update_listener(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Handle options update."""
+    await hass.config_entries.async_reload(config_entry.entry_id)
+
+
+class PlugwiseNodeEntity(Entity):
+    """Base class for a Plugwise entities."""
+
+    def __init__(self, node, mac):
+        """Initialize a Node entity."""
+        self._node = node
+        self._mac = mac
+        self.node_callbacks = (AVAILABLE_SENSOR_ID,)
+
+    async def async_added_to_hass(self):
+        """Subscribe to updates."""
+        for node_callback in self.node_callbacks:
+            self._node.subscribe_callback(self.sensor_update, node_callback)
+
+    async def async_will_remove_from_hass(self):
+        """Unsubscribe to updates."""
+        for node_callback in self.node_callbacks:
+            self._node.unsubscribe_callback(self.sensor_update, node_callback)
+
+    @property
+    def available(self):
+        """Return the availability of this entity."""
+        return getattr(self._node, SENSORS[AVAILABLE_SENSOR_ID]["state"])()
+
+    @property
+    def device_info(self):
+        """Return the device info."""
+        return {
+            "identifiers": {(DOMAIN, self._mac)},
+            "name": f"{self._node.get_node_type()} ({self._mac})",
+            "manufacturer": "Plugwise",
+            "model": self._node.get_node_type(),
+            "sw_version": f"{self._node.get_firmware_version()}",
+        }
+
+    @property
+    def name(self):
+        """Return the display name of this entity."""
+        return f"{self._node.get_node_type()} {self._mac[-5:]}"
+
+    def sensor_update(self, state):
+        """Handle status update of Entity."""
+        self.schedule_update_ha_state()
+
+    @property
+    def should_poll(self):
+        """Disable polling."""
+        return False
+
+    @property
+    def unique_id(self):
+        """Get unique ID."""
+        return f"{self._mac}-{self._node.get_node_type()}"

homeassistant/components/plugwise_stick/config_flow.py

@@ -0,0 +1,131 @@
+"""Config flow for the Plugwise_stick platform."""
+import os
+from typing import Dict
+
+import plugwise
+from plugwise.exceptions import NetworkDown, PortError, StickInitError, TimeoutException
+import serial.tools.list_ports
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.core import HomeAssistant, callback
+
+from .const import CONF_USB_PATH, DOMAIN
+
+CONF_MANUAL_PATH = "Enter Manually"
+
+
+@callback
+def plugwise_stick_entries(hass: HomeAssistant):
+    """Return existing connections for Plugwise USB-stick domain."""
+    return {
+        (entry.data[CONF_USB_PATH])
+        for entry in hass.config_entries.async_entries(DOMAIN)
+    }
+
+
+class PlugwiseConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_PUSH
+
+    async def async_step_user(self, user_input=None):
+        """Step when user initializes a integration."""
+        errors = {}
+        ports = await self.hass.async_add_executor_job(serial.tools.list_ports.comports)
+        list_of_ports = [
+            f"{p}, s/n: {p.serial_number or 'n/a'}"
+            + (f" - {p.manufacturer}" if p.manufacturer else "")
+            for p in ports
+        ]
+        list_of_ports.append(CONF_MANUAL_PATH)
+
+        if user_input is not None:
+            user_selection = user_input[CONF_USB_PATH]
+            if user_selection == CONF_MANUAL_PATH:
+                return await self.async_step_manual_path()
+            if user_selection in list_of_ports:
+                port = ports[list_of_ports.index(user_selection)]
+                device_path = await self.hass.async_add_executor_job(
+                    get_serial_by_id, port.device
+                )
+            else:
+                device_path = await self.hass.async_add_executor_job(
+                    get_serial_by_id, user_selection
+                )
+            errors = await validate_connection(self.hass, device_path)
+            if not errors:
+                return self.async_create_entry(
+                    title=device_path, data={CONF_USB_PATH: device_path}
+                )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {vol.Required(CONF_USB_PATH): vol.In(list_of_ports)}
+            ),
+            errors=errors,
+        )
+
+    async def async_step_manual_path(self, user_input=None):
+        """Step when manual path to device."""
+        errors = {}
+
+        if user_input is not None:
+            device_path = await self.hass.async_add_executor_job(
+                get_serial_by_id, user_input.get(CONF_USB_PATH)
+            )
+            errors = await validate_connection(self.hass, device_path)
+            if not errors:
+                return self.async_create_entry(
+                    title=device_path, data={CONF_USB_PATH: device_path}
+                )
+        return self.async_show_form(
+            step_id="manual_path",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_USB_PATH, default="/dev/ttyUSB0" or vol.UNDEFINED
+                    ): str
+                }
+            ),
+            errors=errors if errors else {},
+        )
+
+
+async def validate_connection(self, device_path=None) -> Dict[str, str]:
+    """Test if device_path is a real Plugwise USB-Stick."""
+    errors = {}
+    if device_path is None:
+        errors["base"] = "connection_failed"
+        return errors
+
+    if device_path in plugwise_stick_entries(self):
+        errors["base"] = "connection_exists"
+        return errors
+
+    stick = await self.async_add_executor_job(plugwise.stick, device_path)
+    try:
+        await self.async_add_executor_job(stick.connect)
+        await self.async_add_executor_job(stick.initialize_stick)
+        await self.async_add_executor_job(stick.disconnect)
+    except PortError:
+        errors["base"] = "cannot_connect"
+    except StickInitError:
+        errors["base"] = "stick_init"
+    except NetworkDown:
+        errors["base"] = "network_down"
+    except TimeoutException:
+        errors["base"] = "network_timeout"
+    return errors
+
+
+def get_serial_by_id(dev_path: str) -> str:
+    """Return a /dev/serial/by-id match for given device if available."""
+    by_id = "/dev/serial/by-id"
+    if not os.path.isdir(by_id):
+        return dev_path
+    for path in (entry.path for entry in os.scandir(by_id) if entry.is_symlink()):
+        if os.path.realpath(path) == dev_path:
+            return path
+    return dev_path

homeassistant/components/plugwise_stick/const.py

@@ -0,0 +1,62 @@
+"""Const for Plugwise USB-stick."""
+
+from homeassistant.components.switch import DEVICE_CLASS_OUTLET
+from homeassistant.const import (
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    ENERGY_KILO_WATT_HOUR,
+    POWER_WATT,
+)
+
+DOMAIN = "plugwise_stick"
+CONF_USB_PATH = "usb_path"
+UNDO_UPDATE_LISTENER = "undo_update_listener"
+
+# Callback types
+CB_NEW_NODE = "NEW_NODE"
+
+# Sensor IDs
+AVAILABLE_SENSOR_ID = "available"
+CURRENT_POWER_SENSOR_ID = "power_1s"
+TODAY_ENERGY_SENSOR_ID = "power_con_today"
+
+# Sensor types
+SENSORS = {
+    AVAILABLE_SENSOR_ID: {
+        "class": None,
+        "enabled_default": False,
+        "icon": "mdi:signal-off",
+        "name": "Available",
+        "state": "get_available",
+        "unit": None,
+    },
+    CURRENT_POWER_SENSOR_ID: {
+        "class": DEVICE_CLASS_POWER,
+        "enabled_default": True,
+        "icon": None,
+        "name": "Power usage",
+        "state": "get_power_usage",
+        "unit": POWER_WATT,
+    },
+    TODAY_ENERGY_SENSOR_ID: {
+        "class": DEVICE_CLASS_ENERGY,
+        "enabled_default": True,
+        "icon": None,
+        "name": "Power consumption today",
+        "state": "get_power_consumption_today",
+        "unit": ENERGY_KILO_WATT_HOUR,
+    },
+}
+
+# Switch types
+SWITCHES = {
+    "relay": {
+        "class": DEVICE_CLASS_OUTLET,
+        "enabled_default": True,
+        "icon": None,
+        "name": "Relay state",
+        "state": "get_relay_state",
+        "switch": "set_relay_state",
+        "unit": "state",
+    }
+}