Remote IR Vaccum

[CooleRnax]

Here is IR Remote Vacuum Component. It has power_template docking mode and timeout in minutes cleaning/docking mode. Power_template mode is not fully tested. It also has special brand mode, irobot is implemented.

"""
Support for the Xiaomi vacuum cleaner robot.
For more details about this platform, please refer to the documentation
https://home-assistant.io/components/vacuum.xiaomi_miio/
"""
import asyncio
from functools import partial
import logging
import time
import datetime

import voluptuous as vol

from homeassistant.components.vacuum import (
    ATTR_CLEANED_AREA, DOMAIN, PLATFORM_SCHEMA, SUPPORT_BATTERY,
    SUPPORT_CLEAN_SPOT, SUPPORT_FAN_SPEED, SUPPORT_LOCATE, SUPPORT_PAUSE,
    SUPPORT_RETURN_HOME, SUPPORT_SEND_COMMAND, SUPPORT_STOP,
    SUPPORT_STATE, SUPPORT_START, VACUUM_SERVICE_SCHEMA, StateVacuumDevice,
    STATE_CLEANING, STATE_DOCKED, STATE_PAUSED, STATE_IDLE, STATE_RETURNING,
    STATE_ERROR)
from homeassistant.components.remote import (
    ATTR_COMMAND, DOMAIN, SERVICE_SEND_COMMAND)
from homeassistant.const import (
    ATTR_ENTITY_ID, CONF_HOST, CONF_NAME, CONF_TOKEN, STATE_OFF, STATE_ON)
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.restore_state import RestoreEntity
from homeassistant.util import Throttle
from homeassistant.helpers.event import async_track_state_change
from homeassistant.core import callback
from homeassistant.exceptions import TemplateError

DEPENDENCIES = ['remote']

_LOGGER = logging.getLogger(__name__)

DEFAULT_NAME = 'IR Vacuum cleaner'
DEFAULT_BRAND = None
DEFAULT_CLEANING_TIME = 60
DEFAULT_TIME_DOCKING = 1


CONF_REMOTE = 'remote'
CONF_BRAND = 'brand'
CONF_TIME_CLEANING = 'time_cleaning'
CONF_TIME_DOCKING = 'time_docking'
CONF_POWER_TEMPLATE = 'power_template'
CONF_COMMANDS = 'commands'

COMMAND_START = 'start'

COMMANDS_SCHEMA = vol.Schema({
    vol.Required(COMMAND_START): cv.string
}, extra=vol.ALLOW_EXTRA)

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_BRAND, default=DEFAULT_BRAND): cv.string,
    vol.Optional(CONF_TIME_CLEANING, default=DEFAULT_CLEANING_TIME): cv.positive_int,
    vol.Optional(CONF_TIME_DOCKING, default=DEFAULT_TIME_DOCKING): cv.positive_int,
    vol.Required(CONF_REMOTE): cv.entity_id,
    vol.Optional(CONF_POWER_TEMPLATE): cv.template,
    vol.Required(CONF_COMMANDS): COMMANDS_SCHEMA
})

ATTR_CLEAN_START = 'clean_start'
ATTR_CLEAN_STOP = 'clean_stop'
ATTR_CLEANING_TIME = 'time_cleaning'
ATTR_DO_NOT_DISTURB = 'do_not_disturb'
ATTR_DO_NOT_DISTURB_START = 'do_not_disturb_start'
ATTR_DO_NOT_DISTURB_END = 'do_not_disturb_end'
ATTR_MAIN_BRUSH_LEFT = 'main_brush_left'
ATTR_SIDE_BRUSH_LEFT = 'side_brush_left'
ATTR_FILTER_LEFT = 'filter_left'
ATTR_SENSOR_DIRTY_LEFT = 'sensor_dirty_left'
ATTR_CLEANING_COUNT = 'cleaning_count'
ATTR_CLEANED_TOTAL_AREA = 'total_cleaned_area'
ATTR_CLEANING_TOTAL_TIME = 'total_time_cleaning'
ATTR_ERROR = 'error'
ATTR_RC_DURATION = 'duration'
ATTR_RC_ROTATION = 'rotation'
ATTR_RC_VELOCITY = 'velocity'
ATTR_STATUS = 'status'

MIN_TIME_BETWEEN_UPDATES = datetime.timedelta(seconds=10)


async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
    """Set up the xiaomi remote climate platform."""
    name = config.get(CONF_NAME)
    brand = config.get(CONF_BRAND)
    time_cleaning = config.get(CONF_TIME_CLEANING)
    time_docking = config.get(CONF_TIME_DOCKING)
    remote_entity_id = config.get(CONF_REMOTE)
    commands = config.get(CONF_COMMANDS)
    power_template = config.get(CONF_POWER_TEMPLATE)

    async_add_entities([
        RemoteVacuum(hass, name, brand, time_cleaning, time_docking, remote_entity_id, commands, power_template)
    ])


class RemoteVacuum(StateVacuumDevice, RestoreEntity):

    def __init__(self, hass, name, brand, time_cleaning, time_docking, remote_entity_id, commands, power_template):
        self.hass = hass
        self._name = name
        self._brand = brand.lower()

        self._time_cleaning = time_cleaning * 60
        self._time_docking = time_docking * 60

        self._remote_entity_id = remote_entity_id
        self._commands = commands

        s = set()
        s.add(SUPPORT_STATE)

        if 'start' in commands:
            s.add(SUPPORT_START)
        if 'stop' in commands:
            s.add(SUPPORT_STOP)
        if 'pause' in commands:
            s.add(SUPPORT_PAUSE)
        if 'return_to_base' in commands:
            s.add(SUPPORT_RETURN_HOME)
        self._support = s

        self._state = STATE_DOCKED
        self.last_clean = {}
        self._skip_update = False

        self._power_template = power_template
        self.clean_start = time.time()
        self.dock_start = time.time()

    @property
    def name(self):
        """Return the name of the climate device."""
        return self._name

    @property
    def supported_features(self):
        """Flag vacuum cleaner robot features that are supported."""
        return self._support

    @property
    def state(self):
        return self._state

    @property
    def available(self) -> bool:
        """Return True if entity is available."""
        return True

    @property
    def device_state_attributes(self):
        """Return the specific state attributes of this vacuum cleaner."""
        attrs = {}
        if self._state is not None:
            if self.last_clean:
                if 'start' in self.last_clean:
                    attrs[ATTR_CLEAN_START] = self.last_clean['start']
                if 'end' in self.last_clean:
                    attrs[ATTR_CLEAN_STOP] = self.last_clean['end']
        return attrs

    def _send_command(self, command_name):
        if command_name in self._commands:
            command = self._commands[command_name]
            if command is not None:
                self.hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, {
                    ATTR_COMMAND: 'raw:' + command,
                    ATTR_ENTITY_ID: self._remote_entity_id
                })
                if self._brand == 'irobot':
                    self.hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, {
                        ATTR_COMMAND: 'raw:' + command,
                        ATTR_ENTITY_ID: self._remote_entity_id
                    })

    def start(self):
        self._send_command('start')
        self._state = STATE_CLEANING
        if not self._power_template:
            self.clean_start = time.time()
        else:
            self._skip_update = True
        self.last_clean['start'] = self.dt()
        self.schedule_update_ha_state()

    def stop(self):
        self._send_command('stop')
        self._state = STATE_IDLE
        self.last_clean['end'] = self.dt()
        self.schedule_update_ha_state()

    def pause(self):
        self._send_command('pause')
        self._state = STATE_PAUSED
        self.last_clean['end'] = self.dt()
        self.schedule_update_ha_state()

    def return_to_base(self):
        if self._state == STATE_CLEANING:
            self.last_clean['end'] = self.dt()
            if self._brand == 'irobot':
                self._send_command('start')
                time.sleep(2)
        self._send_command('return_to_base')
        self._state = STATE_RETURNING
        if not self._power_template:
            self.dock_start = time.time()
        self.schedule_update_ha_state()

    @callback
    def _async_update_power(self):
        try:
            if self._power_template.async_render().lower() in ('true', 'on', '1'):
                self._state = STATE_DOCKED
        except TemplateError as ex:
            _LOGGER.warning('Unable to update power from template: %s', ex)

    def dt(self):
        return datetime.datetime.now().strftime("%H:%M:%S %d.%m.%Y")

    @Throttle(MIN_TIME_BETWEEN_UPDATES)
    async def async_update(self):
        if self._skip_update:
            self._skip_update = False
            return

        if not self._power_template:
            if self._state == STATE_CLEANING:
                time_diff = time.time() - self.clean_start
                # _LOGGER.error('STATE_CLEANING %s' % time_diff)
                if time_diff > self._time_cleaning:
                    self.last_clean['end'] = self.dt()
                    self._state = STATE_DOCKED
                    self.schedule_update_ha_state()

            elif self._state == STATE_RETURNING:
                time_diff = time.time() - self.dock_start
                # _LOGGER.error('STATE_RETURNING %s' % time_diff)
                if time_diff > self._time_docking:
                    self._state = STATE_DOCKED
                    self.schedule_update_ha_state()
            else:
                self.clean_start = None
                self.dock_start = None
        elif self._power_template:
            self._async_update_power()

IR codes example: https://www.dropbox.com/s/texllwcvx3sxnqe/ir_remote_codes.rar?dl=0&file_subpath=%2Fir_remote_codes%2Fvacuum