eslint compliance

eslint conformance for
add .eslintrc
2021-05-10 20:51:29 +02:00 · 2021-05-10 20:43:56 +02:00 · 2021-05-10 20:43:35 +02:00 · 2021-05-10 10:06:49 +02:00 · 2021-05-10 09:53:47 +02:00 · 2021-05-10 09:30:07 +02:00
31 changed files with 9371 additions and 475 deletions
--- a/.eslintrc
+++ b/.eslintrc
@@ -0,0 +1,39 @@
+{
+    "parser": "@typescript-eslint/parser",
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended" // uses the recommended rules from the @typescript-eslint/eslint-plugin
+    ],
+    "parserOptions": {
+      "ecmaVersion": 2018,
+      "sourceType": "module"
+    },
+    "ignorePatterns": [
+      "dist"
+    ],
+    "rules": {
+      "quotes": ["warn", "single"],
+      "indent": ["warn", 2, { "SwitchCase": 1 }],
+      "semi": ["off"],
+      "comma-dangle": ["warn", "always-multiline"],
+      "dot-notation": "off",
+      "eqeqeq": "warn",
+      "curly": ["warn", "all"],
+      "brace-style": ["warn"],
+      "prefer-arrow-callback": ["warn"],
+      "max-len": ["warn", 140],
+      "no-console": ["warn"], // use the provided Homebridge log method instead
+      "no-non-null-assertion": ["off"],
+      "comma-spacing": ["error"],
+      "no-multi-spaces": ["warn", { "ignoreEOLComments": true }],
+      "no-trailing-spaces": ["warn"],
+      "lines-between-class-members": ["warn", "always", {"exceptAfterSingleLine": true}],
+      "@typescript-eslint/explicit-function-return-type": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/semi": ["warn"],
+      "@typescript-eslint/member-delimiter-style": ["warn"]
+    }
+  }
+  
--- a/.github/workflows/npm.yml
+++ b/.github/workflows/npm.yml
@@ -0,0 +1,19 @@
+name: npm
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    # Setup .npmrc file to publish to npm
+    - uses: actions/setup-node@v2
+      with:
+        node-version: '12.x'
+        registry-url: 'https://registry.npmjs.org'
+    - run: npm install
+    - run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,120 @@
+# Ignore compiled code
+dist
+
+# ------------- Defaults ------------- #
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.pnp.*
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -74,4 +74,80 @@
 * Changed error handling
 * Changed debug messages
 * Updated node-botvac dependency to 0.1.6
-* Removed extra care navigation option parameter (is now a button)
+* Removed extra care navigation option parameter (is now a button)
+
+## 0.5.1
+
+* Updated node-botvac dependency to 0.1.7
+
+## 0.5.2
+
+* Added schema file for use with homebridge-config-ui-x
+
+## 0.6.0
+
+* Added support for zone cleaning
+
+## 0.6.1
+
+* Fixed homebridge startup failed when robot does not support zone cleaning
+
+## 0.6.2
+
+* Fixed homebridge startup failed when robot does not support mapping
+
+## 0.6.3
+
+* Fixed homebridge crash when robot has a map without zones
+* Fixed homebridge crash when homebridge has no internet connection or the neato servers are offline
+* Fixed homebridge crash when 2 zones have the same name
+
+## 0.7.0
+
+* Added find me function
+* Added spot cleaning function with individual spot size and repeat option
+* Added model and firmware information to homekit
+* Added logic to be able to change the currently cleaned room
+* Improved number of requests when having multiple rooms
+* Fixed room switches not taking eco and extraCare mode into account
+* Fixed room switches not supporting pause/resume
+
+## 0.7.1
+* Fixed robot not shown before setting up a floor plan
+
+## 0.7.2
+* Fixed homebridge crash with multiple robots per account
+
+## 0.8.0
+* Add German plugin language (for example, this gives you a "Sauge Küche" Siri command for a zone called "Küche")
+* Added possibility to toggle between languages (English/German) in Homebridge UI Plugin Settings
+
+## 0.8.1
+* Include Robot name in Homekit battery service name
+
+## 0.8.2
+* Eliminate warnings on Homebridge >= 1.3.0 (77945f8 and 877c3d7 on `naofireblade/homebridge-neato`)
+
+## 0.8.3
+* Add French plugin language (for example, this gives you a "Aspirer la cuisine" Siri command for a zone called "La cuisine")
+
+## 0.8.4
+* Link to token getter tool in homebridge UI 
+
+## 1.0.0
+Changes adapted from [homebridge-neato](https://github.com/naofireblade/homebridge-neato) to the Vorwerk API:
+
+* Added bin full sensor
+* Added config-ui support for all options
+* Added config parameter **prefix** to use robot name as prefix for service names
+* Retrying mechanism if a robot is not available on homebridge launch
+* Changed service names to not include robot name as prefix by default
+* Changed background update to use better default intervals (1 minute while cleaning, 30 minutes while idle)
+* Changed config parameter **refresh**. Renamed to **backgroundUpdate**, unit changed to minute and will only be used during idle
+* Changed config parameter **hidden**. Renamed to **services**, now takes list of services that should be _visible_. Default are all available services.
+* Fixed robots no longer disappear or change the room after connection issues with the Vorwerk API
+* Fixed plugin no longer crashes if non smart robot is assigned in Vorwerk account
+* Fixed options for eco, nogo lines, extra care, spot repeat, spot size are now saved in homebridge and will no longer be overridden by Vorwerk API
+
+## TODO until 1.0.0 release
+ * Room cleaning
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2017 Arne Blumentritt
+Copyright (c) 2021 Luis Riegger

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@@ -1,79 +1,129 @@
-# homebridge-neato
-[![npm](https://img.shields.io/npm/v/homebridge-neato.svg?style=flat-square)](https://www.npmjs.com/package/homebridge-neato)
-[![npm](https://img.shields.io/npm/dt/homebridge-neato.svg?style=flat-square)](https://www.npmjs.com/package/homebridge-neato)
-[![GitHub last commit](https://img.shields.io/github/last-commit/naofireblade/homebridge-neato.svg?style=flat-square)](https://github.com/naofireblade/homebridge-neato)
+[![Latest NPM release](https://img.shields.io/npm/v/homebridge-kobold.svg)](https://www.npmjs.com/package/homebridge-kobold)

-This is a plugin for [homebridge](https://github.com/nfarina/homebridge) to control your [Neato](https://www.neatorobotics.com/) vacuum robot. You can download it via [npm](https://www.npmjs.com/package/homebridge-neato).
+# homebridge-kobold

-Feel free to leave any feedback [here](https://github.com/naofireblade/homebridge-neato/issues).
+This is a plugin for [homebridge](https://github.com/nfarina/homebridge) to control your [Vorwerk Kobold](https://kobold.vorwerk.de/saugroboter/) VR300 vacuum robot. You can download it via [npm](https://www.npmjs.com/package/homebridge-kobold).

-If you update from a previous version 0.3.x you have to adapt your config (plugin is now a platform).
+It is based on a fork of naofireblade's [homebridge-neato](https://github.com/naofireblade/homebridge-neato), merged with the oAuth authentication mechanism from nicoh88's [homebridge-vorwerk](https://github.com/nicoh88/homebridge-vorwerk).
+
+The interaction with the Server is handled by the underlying [node-kobold-control](https://github.com/himbeles/node-kobold-control) module.

 ## Features

- Start and pause cleaning
+- House Cleaning
+  - Eco mode
+  - Extra care navigation
+  - Nogo lines
+- Zone cleaning <sup>[1](#change-room)</sup>
+- Spot cleaning
+  - Individual spot size <sup>[2](#eve)</sup>
+  - Clean twice <sup>[2](#eve)</sup>
 - Return to dock
- Toggle schedule
- Toggle eco mode
- Toggle extra care navigation
- toggle nogo lines
- Get battery info
- Get dock info
- Periodic refresh of robot state
- Support for multiple robots
+- Find the robot
+- Schedule (de)activation
+- Robot information
+  - Battery level
+  - Charging state
+  - Dock occupancy
+  - Model and firmware version
+- Automatic or periodic refresh of robot state
+- Multiple robots
+
+- German, English or French Language Setting
+
+> <b name="change-room">2</b> You can send the robot from one room to another as well. He will return to the base, wait there some seconds and then starts cleaning the next room.
+
+> <b name="eve">3</b> You need a third party app like eve to access these features.
+
+

 ## Installation

 1. Install homebridge using: `npm install -g homebridge`
-2. Install this plugin using: `npm install -g homebridge-neato`
-3. If you don't have a Neato account yet create one [here](https://www.neatorobotics.com/create-account/).
-4. Update your configuration file. See the sample below.
+2. Install this plugin using: `npm install -g homebridge-kobold`
+3. Update your configuration file. See the sample below.

 ## Configuration

-Add the following information to your config file. Change the values for email and password.
+Add the following information to your config file. Adapt the value for `token`.

 ### Simple

 ```json
 "platforms": [
-	{
-		"platform": "NeatoVacuumRobot",
-		"email": "YourEmail",
-		"password": "YourPassword"
-	}
+  {
+    "platform": "KoboldVacuumRobot",
+    "token": "YourToken",
+    "language": "de"
+  }
 ]
 ```

+You can get a token using the GUI tool [Kobold Token Getter](https://github.com/himbeles/kobold-token-get) or using the following two curl commands:
+
+```bash
+# This will trigger the email sending
+curl -X "POST" "https://mykobold.eu.auth0.com/passwordless/start" \
+     -H 'Content-Type: application/json' \
+     -d '{
+  "send": "code",
+  "email": "ENTER_YOUR_EMAIL_HERE",
+  "client_id": "KY4YbVAvtgB7lp8vIbWQ7zLk3hssZlhR",
+  "connection": "email"
+}'
+```
+==== wait for the email to be received ====
+
+```bash
+# this will generate a token using the numbers you received via email
+# replace the value of otp 123456 with the value you received from the email
+curl -X "POST" "https://mykobold.eu.auth0.com/oauth/token" \
+     -H 'Content-Type: application/json' \
+     -d '{
+  "prompt": "login",
+  "grant_type": "http://auth0.com/oauth/grant-type/passwordless/otp",
+  "scope": "openid email profile read:current_user",
+  "locale": "en",
+  "otp": "123456",
+  "source": "vorwerk_auth0",
+  "platform": "ios",
+  "audience": "https://mykobold.eu.auth0.com/userinfo",
+  "username": "ENTER_YOUR_EMAIL_HERE",
+  "client_id": "KY4YbVAvtgB7lp8vIbWQ7zLk3hssZlhR",
+  "realm": "email",
+  "country_code": "DE"
+}'
+```
+
+From the output, you want to copy the `id_token` value.
+
+The `language` can be `de` for German, `en` for English, or `fr` for French.
+
 ### Advanced

-The following config contains advanced optional settings.
+Below are explanations for advanced parameters to adjust the plugin to your needs. All parameters are *optional*.

-The parameter **refresh** sets an interval in seconds that is used to update the robot state in the background. This is only required for automations based on the robot state. The default value is `auto` which means that the update is automatically enabled while cleaning and disabled while not cleaning. You can set a value in seconds e.g. `120` to enable background updates even when the robot is not cleaning. You can also disable background updates completely by setting the value `0`. This might be required if you experience timeouts in the app because you have other home automation apps that are connected to your robot.
+**refresh**  
+Timer for periodic refresh of robot state. The default is `auto`. The options are:  
+`auto` Updates the robot state when a cleaning was started via homekit so that you can activate automations based on a successful cleaning.  
+`120` Or any other time in seconds (minimum `60`) is required if you want to receive robot state updates after starting the cleaning from outside of homekit (e.g. neato app or schedule).  
+`0` Disables background updates completely.

-The parameter **disabled** accepts a list of switches/sensors that can be disabled in the neato homekit plugin (e.g. dock, dockstate, eco, schedule).
+**hidden**  
+List of plugin features that you don't want to use in homekit (e.g. `dock`, `dockstate`, `eco`, `nogolines`, `extracare`, `schedule`, `find`, `spot`).

 ```json
 "platforms": [
-	{
-		"platform": "NeatoVacuumRobot",
-		"email": "YourEmail",
-		"password": "YourPassword",
-		"refresh": "120",
-		"disabled": ["dock", "dockstate", "eco", "nogolines", "extracare", "schedule"]
-	}
+  {
+    "platform": "KoboldVacuumRobot",
+    "token": "YourToken",
+    "refresh": "120",
+    "hidden": ["dock", "dockstate", "eco", "nogolines", "extracare", "schedule", "find", "spot"],
+    "language": "de"
+  }
 ]
 ```

 ## Tested robots

- BotVac Connected (Firmware 2.2.0)
- BotVac D3 Connected
- BotVac D5 Connected (Firmware 4.0.0, Firmware 4.3.0)
- BotVac D7 Connected
-
-The plugin should work with D4 and D6 as well. If you have connected neato robot, please [tell me](https://github.com/naofireblade/homebridge-neato/issues) about your experience with this plugin.
-
-## Contributors
-Many thanks go to
- [ghulands](https://github.com/ghulands) for finding and fixing a bug when no robot is associated with the neato account
+- Vorwerk Kobold VR300
--- a/_config.yml
+++ b/_config.yml
@@ -1 +0,0 @@
-theme: jekyll-theme-cayman
--- a/archive/accessories/koboldVacuumRobot.js
+++ b/archive/accessories/koboldVacuumRobot.js
@@ -0,0 +1,725 @@
+const debug = require('debug')('homebridge-kobold');
+const colors = require('colors');
+
+const CustomUUID = {
+	SpotCleanWidth: 'A7889A9A-2F27-4293-BEF8-3FE805B36F4E',
+	SpotCleanHeight: 'CA282DB2-62BF-4325-A1BE-F8BB5478781A',
+	SpotCleanRepeat: '1E79C603-63B8-4E6A-9CE1-D31D67981831'
+};
+
+let Service,
+	Characteristic,
+	SpotWidthCharacteristic,
+	SpotHeightCharacteristic,
+	SpotRepeatCharacteristic;
+
+module.exports = function (_Service, _Characteristic)
+{
+	Service = _Service;
+	Characteristic = _Characteristic;
+	SpotWidthCharacteristic = require('../characteristics/spotWidth')(Characteristic, CustomUUID);
+	SpotHeightCharacteristic = require('../characteristics/spotHeight')(Characteristic, CustomUUID);
+	SpotRepeatCharacteristic = require('../characteristics/spotRepeat')(Characteristic, CustomUUID);
+
+	return KoboldVacuumRobotAccessory;
+};
+
+function KoboldVacuumRobotAccessory(platform, robotObject)
+{
+	this.platform = platform;
+	this.log = platform.log;
+	this.refresh = platform.refresh;
+	this.hiddenServices = platform.hiddenServices;
+	this.nextRoom = platform.nextRoom;
+
+	this.robotObject = robotObject;
+	this.robot = robotObject.device;
+	this.meta = robotObject.meta;
+	this.spotPlusFeatures = ((typeof robotObject.availableServices.spotCleaning !== 'undefined') && robotObject.availableServices.spotCleaning.includes("basic"));
+	this.boundary = (typeof robotObject.boundary === 'undefined') ? null : robotObject.boundary;
+
+	this.dict = {
+		'en': {
+			"clean": "Clean",
+			"clean the": "Clean the",
+			"goToDock": "Go to Dock",
+			"dockState": "Dock",
+			"eco": "Eco Mode",
+			"noGoLines": "NoGo Lines",
+			"extraCare": "Extra Care",
+			"schedule": "Schedule",
+			"findMe": "Find me",
+			"cleanSpot": "Clean Spot",
+			"battery": "Battery"
+		},
+		'de': {
+			"clean": "Sauge",
+			"clean the": "Sauge",
+			"goToDock": "Zur Basis",
+			"dockState": "In der Basis",
+			"eco": "Eco Modus",
+			"noGoLines": "NoGo Linien",
+			"extraCare": "Extra Care",
+			"schedule": "Zeitplan",
+			"findMe": "Finde mich",
+			"cleanSpot": "Spot Reinigung",
+			"battery": "Batterie"
+		},
+		'fr': {
+			"clean": "Aspirer",
+			"clean the": "Aspirer",
+			"goToDock": "Retour à la base",
+			"dockState": "Sur la base",
+			"eco": "Eco mode",
+			"noGoLines": "Lignes NoGo",
+			"extraCare": "Extra Care",
+			"schedule": "Planifier",
+			"findMe": "Me retrouver",
+			"cleanSpot": "Nettoyage local",
+			"battery": "Batterie"
+		}
+	}[this.platform.language]
+
+	if (this.boundary == null)
+	{
+		this.name = this.robot.name;
+	}
+	else
+	{
+		// if boundary name already exists
+		if (platform.boundaryNames.includes(this.boundary.name))
+		{
+			let lastChar = this.boundary.name.slice(-1);
+			// boundary name already contains a count number
+			if (!isNaN(lastChar))
+			{
+				// Increment existing count number
+				this.boundary.name = this.boundary.name.slice(0, -1) + (parseInt(lastChar) + 1);
+			}
+			else
+			{
+				// Add a new count number
+				this.boundary.name = this.boundary.name + " 2";
+			}
+		}
+		platform.boundaryNames.push(this.boundary.name);
+		this.name = this.robot.name + ' - ' + this.boundary.name;
+	}
+
+	this.batteryService = new Service.BatteryService(this.name + " " + this.dict["battery"], "battery");
+
+	if (this.boundary == null)
+	{
+		this.cleanService = new Service.Switch(this.name + " " + this.dict["clean"], "clean");
+		this.goToDockService = new Service.Switch(this.name + " " + this.dict["goToDock"], "goToDock");
+		this.dockStateService = new Service.OccupancySensor(this.name + " " + this.dict["dockState"], "dockState");
+		this.ecoService = new Service.Switch(this.name + " " + this.dict["eco"], "eco");
+		this.noGoLinesService = new Service.Switch(this.name + " " + this.dict["noGoLines"], "noGoLines");
+		this.extraCareService = new Service.Switch(this.name + " " + this.dict["extraCare"], "extraCare");
+		this.scheduleService = new Service.Switch(this.name + " " + this.dict["schedule"], "schedule");
+		this.findMeService = new Service.Switch(this.name + " " + this.dict["findMe"], "findMe");
+
+		this.spotCleanService = new Service.Switch(this.name + " " + this.dict["cleanSpot"], "cleanSpot");
+		this.spotCleanService.addCharacteristic(SpotRepeatCharacteristic);
+		if (this.spotPlusFeatures)
+		{
+			this.spotCleanService.addCharacteristic(SpotWidthCharacteristic);
+			this.spotCleanService.addCharacteristic(SpotHeightCharacteristic);
+		}
+	}
+	else
+	{
+		const splitName = this.boundary.name.split(' ');
+		let serviceName = this.dict["clean the"] + " " + this.boundary.name;
+		if (splitName.length >= 2 && splitName[splitName.length - 2].match(/[']s$/g))
+		{
+			serviceName = this.dict["clean"] + " " + this.boundary.name;
+		}
+		this.cleanService = new Service.Switch(serviceName, "cleanBoundary:" + this.boundary.id);
+	}
+
+	this.log("Added cleaning device named: " + this.name);
+}
+
+KoboldVacuumRobotAccessory.prototype = {
+	identify: function (callback)
+	{
+		this.robot.getState((error, result) =>
+		{
+			if (error)
+			{
+				this.log.error("Error getting robot information: " + error + ": " + result);
+			}
+			else
+			{
+				this.log("### Robot information ###");
+				this.log(result);
+			}
+			callback();
+		});
+	},
+
+	getServices: function ()
+	{
+		this.informationService = new Service.AccessoryInformation();
+		this.informationService
+		.setCharacteristic(Characteristic.Manufacturer, "Vorwerk Deutschland Stiftung & Co. KG")
+		.setCharacteristic(Characteristic.Model, this.meta.modelName)
+		.setCharacteristic(Characteristic.SerialNumber, this.robot._serial)
+		.setCharacteristic(Characteristic.FirmwareRevision, this.meta.firmware)
+		.setCharacteristic(Characteristic.Name, this.robot.name + (this.boundary == null ? '' : ' - ' + this.boundary.name));
+
+		this.cleanService.getCharacteristic(Characteristic.On).on('set', this.setClean.bind(this));
+		this.cleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));
+
+		this.services = [this.informationService, this.cleanService];
+
+		if (this.boundary == null)
+		{
+			this.batteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
+			this.batteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
+			this.services.push(this.batteryService);
+
+			this.goToDockService.getCharacteristic(Characteristic.On).on('set', this.setGoToDock.bind(this));
+			this.goToDockService.getCharacteristic(Characteristic.On).on('get', this.getGoToDock.bind(this));
+
+			this.dockStateService.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getDock.bind(this));
+
+			this.ecoService.getCharacteristic(Characteristic.On).on('set', this.setEco.bind(this));
+			this.ecoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
+
+			this.noGoLinesService.getCharacteristic(Characteristic.On).on('set', this.setNoGoLines.bind(this));
+			this.noGoLinesService.getCharacteristic(Characteristic.On).on('get', this.getNoGoLines.bind(this));
+
+			this.extraCareService.getCharacteristic(Characteristic.On).on('set', this.setExtraCare.bind(this));
+			this.extraCareService.getCharacteristic(Characteristic.On).on('get', this.getExtraCare.bind(this));
+
+			this.scheduleService.getCharacteristic(Characteristic.On).on('set', this.setSchedule.bind(this));
+			this.scheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
+
+			this.findMeService.getCharacteristic(Characteristic.On).on('set', this.setFindMe.bind(this));
+			this.findMeService.getCharacteristic(Characteristic.On).on('get', this.getFindMe.bind(this));
+
+			this.spotCleanService.getCharacteristic(Characteristic.On).on('set', this.setSpotClean.bind(this));
+			this.spotCleanService.getCharacteristic(Characteristic.On).on('get', this.getSpotClean.bind(this));
+			this.spotCleanService.getCharacteristic(SpotRepeatCharacteristic).on('set', this.setSpotRepeat.bind(this));
+			this.spotCleanService.getCharacteristic(SpotRepeatCharacteristic).on('get', this.getSpotRepeat.bind(this));
+
+			if (this.spotPlusFeatures)
+			{
+				this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).on('set', this.setSpotWidth.bind(this));
+				this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).on('get', this.getSpotWidth.bind(this));
+				this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).on('set', this.setSpotHeight.bind(this));
+				this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).on('get', this.getSpotHeight.bind(this));
+			}
+
+			if (this.hiddenServices.indexOf('spot') === -1)
+			{
+				this.services.push(this.spotCleanService);
+			}
+
+			// Add optional services
+			if (this.hiddenServices.indexOf('dock') === -1)
+				this.services.push(this.goToDockService);
+			if (this.hiddenServices.indexOf('dockstate') === -1)
+				this.services.push(this.dockStateService);
+			if (this.hiddenServices.indexOf('eco') === -1)
+				this.services.push(this.ecoService);
+			if (this.hiddenServices.indexOf('nogolines') === -1)
+				this.services.push(this.noGoLinesService);
+			if (this.hiddenServices.indexOf('extracare') === -1)
+				this.services.push(this.extraCareService);
+			if (this.hiddenServices.indexOf('schedule') === -1)
+				this.services.push(this.scheduleService);
+			if (this.hiddenServices.indexOf('find') === -1)
+				this.services.push(this.findMeService);
+		}
+
+		return this.services;
+	},
+
+
+	getClean: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			let cleaning;
+			if (this.boundary == null)
+			{
+				cleaning = this.robot.canPause;
+			}
+			else
+			{
+				cleaning = this.robot.canPause && (this.robot.cleaningBoundaryId === this.boundary.id)
+			}
+
+			debug(this.name + ": Cleaning is " + (cleaning ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, cleaning);
+		});
+	},
+
+	setClean: function (on, callback)
+	{
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " Clean " + (this.boundary ? JSON.stringify(this.boundary) : ''));
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			// Start
+			if (on)
+			{
+				// No room given or same room
+				if (this.boundary == null || this.robot.cleaningBoundaryId === this.boundary.id)
+				{
+					// Resume cleaning
+					if (this.robot.canResume)
+					{
+						debug(this.name + ": ## Resume cleaning");
+						this.robot.resumeCleaning((error) =>
+						{
+							callback(error);
+						});
+					}
+					// Start cleaning
+					else if (this.robot.canStart)
+					{
+						debug(this.name + ": ## Start cleaning");
+						this.clean(callback);
+					}
+					// Cannot start
+					else
+					{
+						debug(this.name + ": Cannot start, maybe already cleaning (expected)");
+						callback();
+					}
+				}
+				// Different room given
+				else
+				{
+					// Return to dock
+					if (this.robot.canPause || this.robot.canResume)
+					{
+						debug(this.name + ": ## Returning to dock to start cleaning of new room");
+						this.setGoToDock(true, (error, result) =>
+						{
+							this.nextRoom = this.boundary.id;
+							callback();
+						});
+					}
+					// Start new cleaning of new room
+					else
+					{
+						debug(this.name + ": ## Start cleaning of new room");
+						this.clean(callback);
+					}
+				}
+			}
+			// Stop
+			else
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": ## Pause cleaning");
+					this.robot.pauseCleaning((error) =>
+					{
+						callback(error);
+					});
+				}
+				else
+				{
+					debug(this.name + ": Already paused");
+					callback();
+				}
+			}
+		});
+	},
+
+	clean: function (callback, spot)
+	{
+		// Start automatic update while cleaning
+		if (this.refresh === 'auto')
+		{
+			setTimeout(() =>
+			{
+				this.platform.updateRobotTimer(this.robot._serial);
+			}, 60 * 1000);
+		}
+
+		let eco = this.robotObject.mainAccessory.ecoService.getCharacteristic(Characteristic.On).value;
+		let extraCare = this.robotObject.mainAccessory.extraCareService.getCharacteristic(Characteristic.On).value;
+		let nogoLines = this.robotObject.mainAccessory.noGoLinesService.getCharacteristic(Characteristic.On).value;
+		let room = (this.boundary == null) ? '' : this.boundary.name;
+		debug(this.name + ": ## Start cleaning (" + (room !== '' ? room + " " : '') + "eco: " + eco + ", extraCare: " + extraCare + ", nogoLines: " + nogoLines + ", spot: " + JSON.stringify(spot) + ")");
+
+		// Normal cleaning
+		if (this.boundary == null && (typeof spot === 'undefined'))
+		{
+			this.robot.startCleaning(eco, extraCare ? 2 : 1, nogoLines, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start cleaning. " + error + ": " + JSON.stringify(result));
+				}
+				callback(error);
+			});
+		}
+		// Room cleaning
+		else if (room !== '')
+		{
+			this.robot.startCleaningBoundary(eco, extraCare, this.boundary.id, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start room cleaning. " + error + ": " + JSON.stringify(result));
+				}
+				callback(error);
+			});
+		}
+		// Spot cleaning
+		else
+		{
+			this.robot.startSpotCleaning(eco, spot.width, spot.height, spot.repeat, extraCare ? 2 : 1, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start spot cleaning. " + error + ": " + JSON.stringify(result));
+				}
+				callback(error);
+			});
+		}
+	},
+
+	getGoToDock: function (callback)
+	{
+		callback(false, false);
+	},
+
+	setGoToDock: function (on, callback)
+	{
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			if (on)
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": ## Pause cleaning to go to dock");
+					this.robot.pauseCleaning((error, result) =>
+					{
+						setTimeout(() =>
+						{
+							debug(this.name + ": ## Go to dock");
+							this.robot.sendToBase(() =>
+							{
+								callback();
+							});
+						}, 1000);
+					});
+				}
+				else if (this.robot.canGoToBase)
+				{
+					debug(this.name + ": ## Go to dock");
+					this.robot.sendToBase(() =>
+					{
+						callback();
+					});
+				}
+				else
+				{
+					this.log.warn(this.name + ": Can't go to dock at the moment");
+					callback();
+				}
+			}
+			else
+			{
+				callback();
+			}
+		});
+	},
+
+	getEco: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Eco Mode is " + (this.robot.eco ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.eco);
+		});
+	},
+
+	setEco: function (on, callback)
+	{
+		this.robot.eco = on;
+		debug(this.name + ": " + (on ? "Enabled ".red : "Disabled".red) + " Eco Mode ");
+		callback();
+	},
+
+	getNoGoLines: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": NoGoLine is " + (this.robot.eco ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.noGoLines ? 1 : 0);
+		});
+	},
+
+	setNoGoLines: function (on, callback)
+	{
+		this.robot.noGoLines = on;
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " NoGoLine ");
+		callback();
+	},
+
+	getExtraCare: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Care Nav is " + (this.robot.navigationMode === 2 ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.navigationMode === 2 ? 1 : 0);
+		});
+	},
+
+	setExtraCare: function (on, callback)
+	{
+		this.robot.navigationMode = on ? 2 : 1;
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " Care Nav ");
+		callback();
+	},
+
+	getSchedule: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Schedule is " + (this.robot.eco ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.isScheduleEnabled);
+		});
+	},
+
+	setSchedule: function (on, callback)
+	{
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			if (on)
+			{
+				debug(this.name + ": " + "Enabled".brightGreen + " Schedule");
+				this.robot.enableSchedule((error) =>
+				{
+					callback(error);
+				});
+			}
+			else
+			{
+				debug(this.name + ": " + "Disabled".red + " Schedule");
+				this.robot.disableSchedule((error) =>
+				{
+					callback(error);
+				});
+			}
+		});
+	},
+
+	getFindMe: function (callback)
+	{
+		callback(false, false);
+	},
+
+	setFindMe: function (on, callback)
+	{
+		if (on)
+		{
+			debug(this.name + ": ## Find me");
+			setTimeout(() =>
+			{
+				this.findMeService.setCharacteristic(Characteristic.On, false);
+			}, 1000);
+
+			this.robot.findMe((error) =>
+			{
+				callback(error);
+			});
+		}
+	},
+
+	getSpotClean: function (callback)
+	{
+		callback(false, this.spotCleanService.getCharacteristic(Characteristic.On).value);
+	},
+
+	setSpotClean: function (on, callback)
+	{
+		let spot = {
+			width: this.spotPlusFeatures ? this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).value : null,
+			height: this.spotPlusFeatures ? this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).value : null,
+			repeat: this.spotCleanService.getCharacteristic(SpotRepeatCharacteristic).value
+		};
+
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			// Start
+			if (on)
+			{
+				// Resume cleaning
+				if (this.robot.canResume)
+				{
+					debug(this.name + ": ## Resume (spot) cleaning");
+					this.robot.resumeCleaning(callback);
+				}
+				// Start cleaning
+				else if (this.robot.canStart)
+				{
+					this.clean(callback, spot);
+				}
+				// Cannot start
+				else
+				{
+					debug(this.name + ": Cannot start spot cleaning, maybe already cleaning");
+					callback();
+				}
+			}
+			// Stop
+			else
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": ## Pause cleaning");
+					this.robot.pauseCleaning((error) =>
+					{
+						callback(error);
+					});
+				}
+				else
+				{
+					debug(this.name + ": Already paused");
+					callback();
+				}
+			}
+		});
+	},
+
+	getSpotWidth: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Spot width  is " + this.robot.spotWidth + "cm");
+			callback(false, this.robot.spotWidth);
+		});
+	},
+
+	setSpotWidth: function (width, callback)
+	{
+		this.robot.spotWidth = width;
+		debug(this.name + ": Set spot width to " + width + "cm");
+		callback();
+	},
+
+	getSpotHeight: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Spot height is " + this.robot.spotHeight + "cm");
+			callback(false, this.robot.spotHeight);
+		});
+	},
+
+	setSpotHeight: function (height, callback)
+	{
+		this.robot.spotHeight = height;
+		debug(this.name + ": Set spot height to " + height + "cm");
+		callback();
+	},
+
+	getSpotRepeat: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Spot repeat is " + (this.robot.spotRepeat ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.spotRepeat);
+		});
+	},
+
+	setSpotRepeat: function (on, callback)
+	{
+		this.robot.spotRepeat = on;
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " Spot repeat");
+		callback();
+	},
+
+	getDock: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": The Dock is " + (this.robot.isDocked ? "OCCUPIED".brightGreen : "NOT OCCUPIED".red));
+			callback(false, this.robot.isDocked ? 1 : 0);
+		});
+	},
+
+	getBatteryLevel: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Battery  is " + this.robot.charge + "%");
+			callback(false, this.robot.charge);
+		});
+	},
+
+	getBatteryChargingState: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Battery  is " + (this.robot.isCharging ? "CHARGING".brightGreen : "NOT CHARGING".red));
+			callback(false, this.robot.isCharging);
+		});
+	},
+
+	updated: function ()
+	{
+		if (this.boundary == null)
+		{
+			// only update these values if the state is different from the current one, otherwise we might accidentally start an action
+			if (this.cleanService.getCharacteristic(Characteristic.On).value !== this.robot.canPause)
+			{
+				this.cleanService.setCharacteristic(Characteristic.On, this.robot.canPause);
+			}
+
+			// dock switch is on (dock not seen before) and dock has just been seen -> turn switch off
+			if (this.goToDockService.getCharacteristic(Characteristic.On).value == true && this.robot.dockHasBeenSeen)
+			{
+				this.goToDockService.setCharacteristic(Characteristic.On, false);
+			}
+
+			if (this.scheduleService.getCharacteristic(Characteristic.On).value !== this.robot.isScheduleEnabled)
+			{
+				this.scheduleService.setCharacteristic(Characteristic.On, this.robot.isScheduleEnabled);
+			}
+
+			// no commands here, values can be updated without problems
+			this.dockStateService.setCharacteristic(Characteristic.OccupancyDetected, this.robot.isDocked ? 1 : 0);
+
+			this.ecoService.setCharacteristic(Characteristic.On, this.robot.eco);
+			this.noGoLinesService.setCharacteristic(Characteristic.On, this.robot.noGoLines);
+			this.extraCareService.setCharacteristic(Characteristic.On, this.robot.navigationMode == 2 ? true : false);
+
+			this.spotCleanService.setCharacteristic(SpotRepeatCharacteristic, this.robot.spotRepeat);
+
+			if (this.spotPlusFeatures)
+			{
+				let widthProps = this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).props;
+				let heightProps = this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).props;
+
+				this.spotCleanService.setCharacteristic(SpotWidthCharacteristic,
+					this.robot.spotWidth >= widthProps.minValue && this.robot.spotWidth <= widthProps.maxValue ? this.robot.spotWidth : widthProps.minValue);
+				this.spotCleanService.setCharacteristic(SpotHeightCharacteristic,
+					this.robot.spotHeight >= heightProps.minValue && this.robot.spotHeight <= heightProps.maxValue ? this.robot.spotHeight : heightProps.minValue);
+			}
+		}
+
+		this.batteryService.setCharacteristic(Characteristic.BatteryLevel, this.robot.charge);
+		this.batteryService.setCharacteristic(Characteristic.ChargingState, this.robot.isCharging);
+
+		// Robot has a next room to clean in queue
+		if (this.nextRoom != null && this.robot.isDocked)
+		{
+			this.clean((error, result) =>
+			{
+				this.nextRoom = null;
+				debug("## Starting cleaning of next room");
+			});
+		}
+	}
+};
--- a/archive/characteristics/spotHeight.js
+++ b/archive/characteristics/spotHeight.js
@@ -0,0 +1,21 @@
+const inherits = require('util').inherits;
+
+module.exports = function (Characteristic, CustomUUID)
+{
+	let SpotHeight = function ()
+	{
+		Characteristic.call(this, 'Spot ↕', CustomUUID.SpotCleanHeight);
+		this.setProps({
+			format: Characteristic.Formats.INT,
+			unit: 'cm',
+			maxValue: 400,
+			minValue: 100,
+			minStep: 50,
+			perms: [Characteristic.Perms.READ, Characteristic.Perms.WRITE]
+		});
+		this.value = this.getDefaultValue();
+	};
+	inherits(SpotHeight, Characteristic);
+
+	return SpotHeight;
+};
--- a/archive/characteristics/spotRepeat.js
+++ b/archive/characteristics/spotRepeat.js
@@ -0,0 +1,17 @@
+const inherits = require('util').inherits;
+
+module.exports = function (Characteristic, CustomUUID)
+{
+	let SpotRepeat = function ()
+	{
+		Characteristic.call(this, 'Spot 2x', CustomUUID.SpotCleanRepeat);
+		this.setProps({
+			format: Characteristic.Formats.BOOL,
+			perms: [Characteristic.Perms.READ, Characteristic.Perms.WRITE]
+		});
+		this.value = this.getDefaultValue();
+	};
+	inherits(SpotRepeat, Characteristic);
+
+	return SpotRepeat;
+};
--- a/archive/characteristics/spotWidth.js
+++ b/archive/characteristics/spotWidth.js
@@ -0,0 +1,21 @@
+const inherits = require('util').inherits;
+
+module.exports = function (Characteristic, CustomUUID)
+{
+	let SpotWidth = function ()
+	{
+		Characteristic.call(this, 'Spot ↔', CustomUUID.SpotCleanWidth);
+		this.setProps({
+			format: Characteristic.Formats.INT,
+			unit: 'cm',
+			maxValue: 400,
+			minValue: 100,
+			minStep: 50,
+			perms: [Characteristic.Perms.READ, Characteristic.Perms.WRITE]
+		});
+		this.value = this.getDefaultValue();
+	};
+	inherits(SpotWidth, Characteristic);
+
+	return SpotWidth;
+};
--- a/archive/index.js
+++ b/archive/index.js
@@ -0,0 +1,305 @@
+"use strict";
+let inherits = require('util').inherits,
+	debug = require('debug')('homebridge-kobold'),
+	control = require('node-kobold-control'),
+
+	Service,
+	Characteristic,
+	KoboldVacuumRobotAccessory;
+
+module.exports = function (homebridge)
+{
+	Service = homebridge.hap.Service;
+	Characteristic = homebridge.hap.Characteristic;
+	KoboldVacuumRobotAccessory = require('./accessories/koboldVacuumRobot')(Service, Characteristic);
+	homebridge.registerPlatform("homebridge-kobold", "KoboldVacuumRobot", KoboldVacuumRobotPlatform);
+};
+
+function KoboldVacuumRobotPlatform(log, config)
+{
+	this.log = log;
+	this.serial = "1-3-3-7";
+	this.token = config['token'];
+	this.language = config['language'];
+	this.hiddenServices = '';
+	this.hiddenServices = ('disabled' in config ? config['disabled'] : this.hiddenServices);
+	this.hiddenServices = ('hidden' in config ? config['hidden'] : this.hiddenServices);
+
+	// Array of real robots and associated robot accessories (incl rooms)
+	this.robots = [];
+	this.nextRoom = null;
+
+	if ('refresh' in config && config['refresh'] !== 'auto')
+	{
+		// parse config parameter
+		this.refresh = parseInt(config['refresh']);
+		// must be integer and positive
+		this.refresh = (typeof this.refresh !== 'number' || (this.refresh % 1) !== 0 || this.refresh < 0) ? 60 : this.refresh;
+		// minimum 60s to save some load on the Vorwerk servers
+		if (this.refresh > 0 && this.refresh < 60)
+		{
+			this.log.warn("Minimum refresh time is 60 seconds to not overload the Vorwerk servers");
+			this.refresh = (this.refresh > 0 && this.refresh < 60) ? 60 : this.refresh;
+		}
+	}
+	// default auto
+	else
+	{
+		this.refresh = 'auto';
+	}
+	this.log("Refresh is set to: " + this.refresh + (this.refresh !== 'auto' ? ' seconds' : ''));
+}
+
+KoboldVacuumRobotPlatform.prototype = {
+	accessories: function (callback)
+	{
+		debug("Get robots");
+		let accessories = [];
+		this.boundaryNames = [];
+
+		this.getRobots(() =>
+		{
+			// // MOCK MULTIPLE ROBOTS START
+			// let client = new control.Client();
+			// client.authorize(this.token, (error) =>
+			// {
+			// 	client.getRobots((error, robs) =>
+			// 	{
+			// 		let testRobot = robs[0];
+			// 		testRobot.getState((error, result) =>
+			// 		{
+			// 			testRobot.name = "Testrobot";
+			// 			this.robots.push({device: testRobot, meta: result.meta, availableServices: result.availableServices});
+			// 			// MOCK MULTIPLE ROBOTS END
+
+						this.robots.forEach((robot, i) =>
+						{
+							this.log("Found robot #" + (i + 1) + " named \"" + robot.device.name + "\" with serial \"" + robot.device._serial.substring(0, 9) + "XXXXXXXXXXXX\"");
+
+							let mainAccessory = new KoboldVacuumRobotAccessory(this, robot);
+							accessories.push(mainAccessory);
+
+							robot.mainAccessory = mainAccessory;
+							robot.roomAccessories = [];
+
+							// Start Update Intervall
+							this.updateRobotTimer(robot.device._serial);
+
+							// // MOCK ZONE CLEANING START
+							// robot.boundary = {name: "Testroom", id: "1"};
+							// let roomAccessory = new KoboldVacuumRobotAccessory(this, robot);
+							// accessories.push(roomAccessory);
+							// robot.roomAccessories.push(roomAccessory);
+							// // MOCK ZONE CLEANING END
+
+							if (robot.device.maps)
+							{
+								robot.device.maps.forEach((map) =>
+								{
+									if (map.boundaries)
+									{
+										map.boundaries.forEach((boundary) =>
+										{
+											if (boundary.type === "polygon")
+											{
+												robot.boundary = boundary;
+												let roomAccessory = new KoboldVacuumRobotAccessory(this, robot);
+												accessories.push(roomAccessory);
+
+												robot.roomAccessories.push(roomAccessory);
+											}
+										})
+									}
+								})
+							}
+						});
+						callback(accessories);
+
+			// 			// MOCK MULTIPLE ROBOTS START
+			// 		});
+			// 	});
+			// });
+			// // MOCK MULTIPLE ROBOTS END
+		});
+	},
+
+	getRobots: function (callback)
+	{
+		debug("Loading your robots");
+		let client = new control.Client();
+
+		// Login
+		client.authorize(this.token, (error) =>
+		{
+			if (error)
+			{
+				this.log.error("Can't log on to Vorwerk cloud. Please check your internet connection and your token. Try again later if the Vorwerk servers have issues: " + error);
+				callback();
+			}
+			else
+			{
+				// Get all robots
+				client.getRobots((error, robots) =>
+				{
+					if (error)
+					{
+						this.log.error("Successful login but can't connect to your Vorwerk robot: " + error);
+						callback();
+					}
+					else if (robots.length === 0)
+					{
+						this.log.error("Successful login but no robots associated with your account.");
+						this.robots = [];
+						callback();
+					}
+					else
+					{
+						debug("Found " + robots.length + " robots");
+						let loadedRobots = 0;
+
+						robots.forEach((robot) =>
+						{
+							// Get additional information for the robot
+							robot.getState((error, state) =>
+							{
+								if (error)
+								{
+									this.log.error("Error getting robot meta information: " + error + ": " + state);
+									callback();
+								}
+								else
+								{
+									// Get all maps for each robot
+									robot.getPersistentMaps((error, maps) =>
+									{
+										if (error)
+										{
+											this.log.error("Error updating persistent maps: " + error + ": " + maps);
+											callback();
+										}
+										// Robot has no maps
+										else if (maps.length === 0)
+										{
+											robot.maps = [];
+											this.robots.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+											loadedRobots++;
+											if (loadedRobots === robots.length)
+											{
+												callback();
+											}
+										}
+										// Robot has maps
+										else
+										{
+											robot.maps = maps;
+											let loadedMaps = 0;
+											robot.maps.forEach((map) =>
+											{
+												// Save zones in each map
+												robot.getMapBoundaries(map.id, (error, result) =>
+												{
+													if (error)
+													{
+														this.log.error("Error getting boundaries: " + error + ": " + result)
+													}
+													else
+													{
+														map.boundaries = result.boundaries;
+													}
+													loadedMaps++;
+
+													// Robot is completely requested if zones for all maps are loaded
+													if (loadedMaps === robot.maps.length)
+													{
+														this.robots.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+														loadedRobots++;
+														if (loadedRobots === robots.length)
+														{
+															callback();
+														}
+													}
+												})
+											});
+										}
+									});
+								}
+							});
+						});
+					}
+				});
+			}
+		});
+	},
+
+	updateRobot: function (serial, callback)
+	{
+		let robot = this.getRobot(serial);
+
+		// Data is up to date
+		if (typeof (robot.lastUpdate) !== 'undefined' && new Date() - robot.lastUpdate < 2000)
+		{
+			callback();
+		}
+		else
+		{
+			debug(robot.device.name + ": ++ Updating robot state");
+			robot.lastUpdate = new Date();
+			robot.device.getState((error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot update robot. Check if robot is online. " + error);
+				}
+				callback();
+			});
+		}
+	},
+
+	getRobot(serial)
+	{
+		let result;
+		this.robots.forEach(function (robot)
+		{
+			if (robot.device._serial === serial)
+			{
+				result = robot;
+			}
+		});
+		return result;
+	},
+
+	updateRobotTimer: function (serial)
+	{
+		this.updateRobot(serial, () =>
+		{
+			let robot = this.getRobot(serial);
+			// Clear any other overlapping timers for this robot
+			clearTimeout(robot.timer);
+
+			// Tell all accessories of this robot (mainAccessory and roomAccessories) that updated robot data is available
+			robot.mainAccessory.updated();
+			robot.roomAccessories.forEach(accessory =>
+			{
+				accessory.updated();
+			});
+
+			// Periodic refresh interval set in config
+			if (this.refresh !== 'auto' && this.refresh !== 0)
+			{
+				debug(robot.device.name + ": ++ Next background update in " + this.refresh + " seconds");
+				robot.timer = setTimeout(this.updateRobotTimer.bind(this), this.refresh * 1000, serial);
+			}
+			// Auto refresh set in config
+			else if (this.refresh === 'auto' && robot.device.canPause)
+			{
+				debug(robot.device.name + ": ++ Next background update in 60 seconds while cleaning (auto mode)");
+				robot.timer = setTimeout(this.updateRobotTimer.bind(this), 60 * 1000, serial);
+			}
+			// No refresh
+			else
+			{
+				debug(robot.device.name + ": ++ Stopped background updates");
+			}
+		});
+	},
+};
--- a/config.schema.json
+++ b/config.schema.json
@@ -0,0 +1,120 @@
+{
+  "pluginAlias": "KoboldVacuumRobot",
+  "pluginType": "platform",
+  "singular": true,
+  "headerDisplay": "homebridge-kobold plugin details [on github](https://github.com/himbeles/homebridge-kobold#readme)",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "token": {
+        "title": "Vorwerk Kobold Token",
+        "type": "string",
+        "required": true,
+        "description": "How to get your Vorwerk Kobold Token (https://git.io/J3g1b)"
+      },
+      "language": {
+        "title": "Services Language",
+        "description": "The displayed language of the registered services (and associated Siri commands)",
+        "type": "string",
+        "default": "en",
+        "oneOf": [
+          {
+            "title": "English",
+            "enum": ["en"]
+          },
+          {
+            "title": "German",
+            "enum": ["de"]
+          },
+          {
+            "title": "French",
+            "enum": ["fr"]
+          }
+        ],
+        "required": true
+      },
+      "prefix": {
+        "title": "Prefix with Robot Name",
+        "description": "Display the name of the robot in front of every service.",
+        "type": "boolean",
+        "default": false
+      },
+      "backgroundUpdate": {
+        "title": "Background Update Interval",
+        "description": "Interval for background updates while the robot is not cleaning (in minutes). During cleaning, the robot will automatically update at a faster rate.",
+        "type": "integer",
+        "minimum": 1,
+        "default": 30
+      },
+      "services": {
+        "type": "array",
+        "title": "Displayed Services",
+        "description": "The services to be made available for Homekit",
+        "uniqueItems": true,
+        "items": {
+          "type": "string",
+          "enum": [
+            "clean",
+            "cleanZone",
+            "cleanSpot",
+            "goToDock",
+            "dockState",
+            "binFull",
+            "eco",
+            "noGoLines",
+            "extraCare",
+            "schedule",
+            "findMe",
+            "battery"
+          ],
+          "enumNames": [
+            "Clean",
+            "Clean Zone",
+            "Clean Spot",
+            "Go to Dock",
+            "Docked State",
+            "Bin Full",
+            "Eco Mode",
+            "NoGo Lines",
+            "Extra Care",
+            "Schedule",
+            "Find me",
+            "Battery"
+          ]
+        },
+        "default": [
+          "clean",
+          "cleanZone",
+          "goToDock",
+          "dockState",
+          "binFull",
+          "eco",
+          "noGoLines",
+          "extraCare",
+          "schedule",
+          "findMe",
+          "cleanSpot",
+          "battery"
+        ]
+      }
+    }
+  },
+  "layout" : [
+    "language",
+    "token",
+    "prefix",
+    "backgroundUpdate",
+    {
+      "type": "fieldset",
+      "title": "Displayed Services",
+      "description": "<i>Services to be displayed in Homekit</i>",
+      "expandable": true,
+      "items": [
+        {
+          "key": "services",
+          "notitle": false
+        }
+      ]
+    }
+  ]
+}
--- a/index.js
+++ b/index.js
@@ -1,416 +0,0 @@
-"use strict";
-var inherits = require('util').inherits,
-	debug = require('debug')('homebridge-neato'),
-	botvac = require('node-botvac'),
-
-	Service,
-	Characteristic
-
-module.exports = function (homebridge) {
-	Service = homebridge.hap.Service;
-	Characteristic = homebridge.hap.Characteristic;
-	homebridge.registerPlatform("homebridge-neato", "NeatoVacuumRobot", NeatoVacuumRobotPlatform);
-}
-
-function NeatoVacuumRobotPlatform(log, config) {
-	this.log = log;
-	this.serial = "1-3-3-7";
-	this.email = config['email'];
-	this.password = config['password'];
-	this.hiddenServices = ('disabled' in config ? config['disabled'] : '');
-
-	if ('refresh' in config && config['refresh'] !== 'auto') {
-		// parse config parameter
-		this.refresh = parseInt(config['refresh']);
-		// must be integer and positive
-		this.refresh = (typeof this.refresh !== 'number' || (this.refresh % 1) !== 0 || this.refresh < 0) ? 60 : this.refresh;
-		// minimum 60s to save some load on the neato servers
-		this.refresh = (this.refresh > 0 && this.refresh < 60) ? 60 : this.refresh;
-	}
-	// default auto
-	else {
-		this.refresh = 'auto';
-	}
-	debug("Refresh is set to: " + this.refresh);
-}
-
-NeatoVacuumRobotPlatform.prototype = {
-	accessories: function (callback) {
-		this.accessories = [];
-
-		let that = this;
-		this.robots = this.getRobots(function () {
-			for (var i = 0; i < that.robots.length; i++) {
-				that.log("Found robot #" + (i + 1) + " named \"" + that.robots[i].name + "\" with serial \"" + that.robots[i]._serial + "\"");
-				var robotAccessory = new NeatoVacuumRobotAccessory(that.robots[i], that);
-				that.accessories.push(robotAccessory);
-			}
-			callback(that.accessories);
-		});
-	},
-
-	getRobots: function (callback) {
-		debug("Loading your robots");
-		let client = new botvac.Client();
-		let that = this;
-		client.authorize(this.email, this.password, false, function (error) {
-			if (error) {
-				that.log(error);
-				that.log.error("Can't log on to neato cloud. Please check your credentials.");
-				callback();
-			}
-			else {
-				client.getRobots(function (error, robots) {
-					if (error) {
-						that.log(error);
-						that.log.error("Successful login but can't connect to your neato robot.");
-						callback();
-					}
-					else {
-						if (robots.length === 0) {
-							that.log.error("Successful login but no robots associated with your account.");
-							that.robots = [];
-							callback();
-						}
-						else {
-							debug("Found " + robots.length + " robots");
-							that.robots = robots;
-							callback();
-						}
-					}
-				});
-			}
-		});
-	}
-}
-
-function NeatoVacuumRobotAccessory(robot, platform) {
-	this.platform = platform;
-	this.log = platform.log;
-	this.refresh = platform.refresh;
-	this.hiddenServices = platform.hiddenServices;
-	this.robot = robot;
-	this.name = robot.name;
-	this.lastUpdate = null;
-
-	this.vacuumRobotCleanService = new Service.Switch(this.name + " Clean", "clean");
-	this.vacuumRobotGoToDockService = new Service.Switch(this.name + " Go to Dock", "goToDock");
-	this.vacuumRobotDockStateService = new Service.OccupancySensor(this.name + " Dock", "dockState");
-	this.vacuumRobotEcoService = new Service.Switch(this.name + " Eco Mode", "eco");
-	this.vacuumRobotNoGoLinesService = new Service.Switch(this.name + " NoGo Lines", "noGoLines");
-	this.vacuumRobotExtraCareService = new Service.Switch(this.name + " Extra Care", "extraCare");
-	this.vacuumRobotScheduleService = new Service.Switch(this.name + " Schedule", "schedule");
-	this.vacuumRobotBatteryService = new Service.BatteryService("Battery", "battery");
-
-	this.updateRobotTimer();
-}
-
-
-NeatoVacuumRobotAccessory.prototype = {
-	identify: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			// hide serial and secret in log
-			let _serial = that.robot._serial;
-			let _secret = that.robot._secret;
-			that.robot._serial = "*****";
-			that.robot._secret = "*****";
-			that.log(that.robot);
-			that.robot._serial = _serial;
-			that.robot._secret = _secret;
-			callback();
-		});
-	},
-
-	getServices: function () {
-		this.informationService = new Service.AccessoryInformation();
-		this.informationService
-			.setCharacteristic(Characteristic.Name, this.robot.name)
-			.setCharacteristic(Characteristic.Manufacturer, "Neato Robotics")
-			.setCharacteristic(Characteristic.Model, "Coming soon")
-			.setCharacteristic(Characteristic.SerialNumber, this.robot._serial);
-
-		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('set', this.setClean.bind(this));
-		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));
-
-		this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('set', this.setGoToDock.bind(this));
-		this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('get', this.getGoToDock.bind(this));
-
-		this.vacuumRobotDockStateService.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getDock.bind(this));
-
-		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('set', this.setEco.bind(this));
-		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
-
-		this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('set', this.setNoGoLines.bind(this));
-		this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('get', this.getNoGoLines.bind(this));
-
-		this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('set', this.setExtraCare.bind(this));
-		this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('get', this.getExtraCare.bind(this));
-
-		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('set', this.setSchedule.bind(this));
-		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
-
-		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
-		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
-
-		this.services = [this.informationService, this.vacuumRobotCleanService, this.vacuumRobotBatteryService];
-		if (this.hiddenServices.indexOf('dock') === -1)
-			this.services.push(this.vacuumRobotGoToDockService);
-		if (this.hiddenServices.indexOf('dockstate') === -1)
-			this.services.push(this.vacuumRobotDockStateService);
-		if (this.hiddenServices.indexOf('eco') === -1)
-			this.services.push(this.vacuumRobotEcoService);
-		if (this.hiddenServices.indexOf('nogolines') === -1)
-			this.services.push(this.vacuumRobotNoGoLinesService);
-		if (this.hiddenServices.indexOf('extracare') === -1)
-			this.services.push(this.vacuumRobotExtraCareService);
-		if (this.hiddenServices.indexOf('schedule') === -1)
-			this.services.push(this.vacuumRobotScheduleService);
-
-		return this.services;
-	},
-
-	setClean: function (on, callback) {
-		let that = this;
-		this.updateRobot(function (error, result) {
-			if (on) {
-				if (that.robot.canResume || that.robot.canStart) {
-
-					// start extra update robot timer if refresh is set to "auto"
-					if (that.refresh === 'auto') {
-						setTimeout(function () {
-							clearTimeout(that.timer);
-							that.updateRobotTimer();
-						}, 60 * 1000);
-					}
-
-					if (that.robot.canResume) {
-						debug(that.name + ": Resume cleaning");
-						that.robot.resumeCleaning(callback);
-					}
-					else {
-						let eco = that.vacuumRobotEcoService.getCharacteristic(Characteristic.On).value;
-						let extraCare = that.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).value;
-						let nogoLines = that.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).value;
-						debug(that.name + ": Start cleaning (eco: " + eco + ", extraCare: " + extraCare + ", nogoLines: " + nogoLines + ")");
-						that.robot.startCleaning(
-							eco,
-							extraCare ? 2 : 1,
-							nogoLines,
-							function (error, result) {
-								if (error) {
-									that.log.error(error + ": " + result);
-									callback(true);
-								}
-								else {
-									callback();
-								}
-							});
-					}
-				}
-				else {
-					debug(that.name + ": Cant start, maybe already cleaning");
-					callback();
-				}
-			}
-			else {
-				if (that.robot.canPause) {
-					debug(that.name + ": Pause cleaning");
-					that.robot.pauseCleaning(callback);
-				}
-				else {
-					debug(that.name + ": Already stopped");
-					callback();
-				}
-			}
-		});
-	},
-
-	setGoToDock: function (on, callback) {
-		let that = this;
-		this.updateRobot(function (error, result) {
-			if (on) {
-				if (that.robot.canPause) {
-					debug(that.name + ": Pause cleaning to go to dock");
-					that.robot.pauseCleaning(function (error, result) {
-						setTimeout(function () {
-							debug("Go to dock");
-							that.robot.sendToBase(callback);
-						}, 1000);
-					});
-				}
-				else if (that.robot.canGoToBase) {
-					debug(that.name + ": Go to dock");
-					that.robot.sendToBase(callback);
-				}
-				else {
-					that.log.warn(that.name + ": Can't go to dock at the moment");
-					callback();
-				}
-			} else {
-				callback();
-			}
-		});
-	},
-
-	setEco: function (on, callback) {
-		debug(this.name + ": " + (on ? "Enable eco mode" : "Disable eco mode"));
-		this.robot.eco = on;
-		callback();
-	},
-
-	setNoGoLines: function (on, callback) {
-		debug(this.name + ": " + (on ? "Enable nogo lines" : "Disable nogo lines"));
-		this.robot.noGoLines = on;
-		callback();
-	},
-
-	setExtraCare: function (on, callback) {
-		debug(this.name + ": " + (on ? "Enable extra care navigation" : "Disable extra care navigation"));
-		this.robot.navigationMode = on ? 2 : 1;
-		callback();
-	},
-
-	setSchedule: function (on, callback) {
-		let that = this;
-		this.updateRobot(function (error, result) {
-			if (on) {
-				debug(that.name + ": Enable schedule");
-				that.robot.enableSchedule(callback);
-			}
-			else {
-				debug(that.name + ": Disable schedule");
-				that.robot.disableSchedule(callback);
-			}
-		});
-	},
-
-	getClean: function (callback) {
-		let that = this;
-		this.updateRobot(function (error, result) {
-			debug(that.name + ": Is cleaning: " + that.robot.canPause);
-			callback(false, that.robot.canPause);
-		});
-	},
-
-	getGoToDock: function (callback) {
-		callback(false, false);
-	},
-
-	getDock: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Is docked: " + that.robot.isDocked);
-			callback(false, that.robot.isDocked ? 1 : 0);
-		});
-	},
-
-	getEco: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Is eco: " + that.robot.eco);
-			callback(false, that.robot.eco);
-		});
-	},
-
-	getNoGoLines: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Is nogo lines: " + that.robot.noGoLines);
-			callback(false, that.robot.noGoLines ? 1 : 0);
-		});
-	},
-
-	getExtraCare: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Is extra care navigation: " + (that.robot.navigationMode == 2 ? true : false));
-			callback(false, that.robot.navigationMode == 2 ? 1 : 0);
-		});
-	},
-
-	getSchedule: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Is schedule: " + that.robot.isScheduleEnabled);
-			callback(false, that.robot.isScheduleEnabled);
-		});
-	},
-
-
-	getBatteryLevel: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Battery: " + that.robot.charge + "%");
-			callback(false, that.robot.charge);
-		});
-	},
-
-	getBatteryChargingState: function (callback) {
-		let that = this;
-		this.updateRobot(function () {
-			debug(that.name + ": Is charging: " + that.robot.isCharging);
-			callback(false, that.robot.isCharging);
-		});
-	},
-
-	updateRobot: function (callback) {
-		let that = this;
-		if (this.lastUpdate !== null && new Date() - this.lastUpdate < 2000) {
-			callback();
-		}
-		else {
-			debug(this.name + ": Updating robot state");
-			this.robot.getState(function (error, result) {
-				if (error) {
-					that.log.error(error + ": " + result);
-				}
-				that.lastUpdate = new Date();
-				callback();
-			});
-		}
-	},
-
-	updateRobotTimer: function () {
-		let that = this;
-		this.updateRobot(function (error, result) {
-
-			// only update these values if the state is different from the current one, otherwise we might accidentally start an action
-			if (that.vacuumRobotCleanService.getCharacteristic(Characteristic.On).value !== that.robot.canPause) {
-				that.vacuumRobotCleanService.setCharacteristic(Characteristic.On, that.robot.canPause);
-			}
-
-			// dock switch is on (dock not seen before) and dock has just been seen -> turn switch off
-			if (that.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).value == true && that.robot.dockHasBeenSeen) {
-				that.vacuumRobotGoToDockService.setCharacteristic(Characteristic.On, false);
-			}
-
-			if (that.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).value !== that.robot.isScheduleEnabled) {
-				that.vacuumRobotScheduleService.setCharacteristic(Characteristic.On, that.robot.isScheduleEnabled);
-			}
-
-			// no commands here, values can be updated without problems
-			that.vacuumRobotDockStateService.setCharacteristic(Characteristic.OccupancyDetected, that.robot.isDocked ? 1 : 0);
-			that.vacuumRobotEcoService.setCharacteristic(Characteristic.On, that.robot.eco);
-			that.vacuumRobotNoGoLinesService.setCharacteristic(Characteristic.On, that.robot.noGoLines);
-			that.vacuumRobotExtraCareService.setCharacteristic(Characteristic.On, that.robot.navigationMode == 2 ? true : false);
-			that.vacuumRobotBatteryService.setCharacteristic(Characteristic.BatteryLevel, that.robot.charge);
-			that.vacuumRobotBatteryService.setCharacteristic(Characteristic.ChargingState, that.robot.isCharging);
-
-			// robot is currently cleaning, update if refresh is set to auto or a specific interval
-			if (that.robot.canPause && that.refresh !== 0) {
-				let refreshTime = that.refresh === 'auto' ? 60 : that.refresh
-				debug("Updating state in background every " + refreshTime + " seconds while cleaning");
-				that.timer = setTimeout(that.updateRobotTimer.bind(that), refreshTime * 1000);
-			}
-			// robot is not cleaning, but a specific refresh interval is set
-			else if (that.refresh !== 'auto' && that.refresh !== 0) {
-				debug("Updating state in background every " + that.refresh + " seconds (user setting)");
-				that.timer = setTimeout(that.updateRobotTimer.bind(that), that.refresh * 1000);
-			}
-			else {
-				debug("Updating state in background disabled");
-			}
-		});
-	},
-}
--- a/nodemon.json
+++ b/nodemon.json
@@ -0,0 +1,12 @@
+{
+  "watch": [
+    "src"
+  ],
+  "ext": "ts",
+  "ignore": [],
+  "exec": "tsc",
+  "signal": "SIGTERM",
+  "env": {
+    "NODE_OPTIONS": "--trace-warnings"
+  }
+}
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,26 +1,55 @@
 {
-  "name": "homebridge-neato",
-  "version": "0.5.0",
-  "description": "A Neato vacuum robot plugin for homebridge.",
+  "name": "homebridge-kobold",
+  "version": "1.0.0",
+  "description": "A Vorwerk Kobold vacuum robot plugin for homebridge.",
  "license": "MIT",
  "keywords": [
    "homebridge-plugin",
-    "neato",
-    "botvac"
+    "vorwerk",
+    "kobold"
  ],
  "engines": {
-    "node": ">=0.12.0",
-    "homebridge": ">=0.2.0"
+    "node": ">=10.17.0",
+    "homebridge": ">=1.3.0"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "lint": "eslint src/**.ts --max-warnings=0",
+    "build": "rimraf ./dist && tsc",
+    "watch": "npm run build && npm link && nodemon"
  },
  "author": {
-    "name": "Arne Blumentritt"
+    "name": "Luis R.",
+    "url2": "https://github.com/himbeles"
  },
+  "contributors": [
+    {
+      "name": "Alexandre L.",
+      "url": "https://github.com/aluini"
+    }
+  ],
  "repository": {
    "type": "git",
-    "url": "git://github.com/naofireblade/homebridge-neato.git"
+    "url": "git://github.com/himbeles/homebridge-kobold.git"
+  },
+  "bugs": {
+    "url": "https://github.com/himbeles/homebridge-kobold/issues"
  },
  "dependencies": {
-    "node-botvac": ">=0.1.6",
-    "debug": "^2.2.0"
+    "colors": "^1.4.0",
+    "debug": "^4.1.1",
+    "node-kobold-control": ">=0.5.0",
+    "uuid": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^14.14.31",
+    "@typescript-eslint/eslint-plugin": "^4.16.1",
+    "@typescript-eslint/parser": "^4.16.1",
+    "eslint": "^7.21.0",
+    "homebridge": "^1.3",
+    "nodemon": "^2.0.7",
+    "rimraf": "^3.0.2",
+    "ts-node": "^9.1.1",
+    "typescript": "^4.2.2"
  }
 }
--- a/src/accessories/koboldVacuumRobot.ts
+++ b/src/accessories/koboldVacuumRobot.ts
@@ -0,0 +1,818 @@
+import {
+  CharacteristicValue,
+  Logger,
+  PlatformAccessory,
+  PlatformAccessoryEvent,
+  PlatformConfig,
+  Service,
+  WithUUID,
+} from 'homebridge';
+import { HomebridgeKoboldPlatform } from '../homebridgeKoboldPlatform';
+import spotRepeat from '../characteristics/spotRepeat';
+import spotWidth from '../characteristics/spotWidth';
+import spotHeight from '../characteristics/spotHeight';
+import { Options } from '../models/options';
+
+import { RobotService, CleanType } from '../models/services';
+import { ALL_SERVICES, BACKGROUND_INTERVAL, LOCALE, PREFIX } from '../defaults';
+import { availableLocales, localize } from '../localization';
+import { CharacteristicHandler } from '../characteristics/characteristicHandler';
+
+/**
+ * Platform Accessory
+ * An instance of this class is created for each accessory your platform registers
+ * Each accessory may expose multiple services of different service types.
+ */
+export class KoboldVacuumRobotAccessory {
+  // Homebridge
+  private log: Logger;
+  private readonly batteryService?: Service;
+  private readonly cleanService?: Service;
+  private readonly findMeService?: Service;
+  private readonly goToDockService?: Service;
+  private readonly dockStateService?: Service;
+  private readonly binFullService?: Service;
+  private readonly ecoService?: Service;
+  private readonly noGoLinesService?: Service;
+  private readonly extraCareService?: Service;
+  private readonly scheduleService?: Service;
+  private readonly spotCleanService?: Service;
+  private spotPlusFeatures: boolean;
+
+  // Context
+  private robot: any;
+  private readonly options: Options;
+
+  // Config
+  private readonly backgroundUpdateInterval: number;
+  private readonly locale: availableLocales;
+  private readonly prefix: boolean;
+  private readonly availableServices: Set<RobotService>;
+
+  // Transient
+  private isSpotCleaning: boolean;
+  private timer: any;
+
+  /**
+   * These are just used to create a working example
+   * You should implement your own code to track the state of your accessory
+   */
+
+  constructor(
+    private readonly platform: HomebridgeKoboldPlatform,
+    private readonly accessory: PlatformAccessory,
+    private readonly config: PlatformConfig,
+  ) {
+    this.log = platform.log;
+
+    this.robot = accessory.context.robot;
+    this.options = accessory.context.options || new Options();
+    this.spotPlusFeatures = false;
+
+    this.backgroundUpdateInterval =
+      KoboldVacuumRobotAccessory.parseBackgroundUpdateInterval(
+        this.config['backgroundUpdate'],
+      );
+    this.prefix = this.config['prefix'] || PREFIX;
+    this.locale = this.config['language'] || LOCALE;
+    this.availableServices = new Set(this.config['services']) || ALL_SERVICES;
+
+    this.isSpotCleaning = false;
+
+    // Information
+    this.accessory
+      .getService(this.platform.Service.AccessoryInformation)!
+      .setCharacteristic(
+        this.platform.Characteristic.Manufacturer,
+        'Vorwerk Deutschland Stiftung & Co. KG',
+      )
+      .setCharacteristic(
+        this.platform.Characteristic.Model,
+        this.robot.meta.modelName,
+      )
+      .setCharacteristic(
+        this.platform.Characteristic.SerialNumber,
+        this.robot._serial,
+      )
+      .setCharacteristic(
+        this.platform.Characteristic.FirmwareRevision,
+        this.robot.meta.firmware,
+      )
+      .setCharacteristic(this.platform.Characteristic.Name, this.robot.name);
+
+    // Identify
+    this.accessory.on(PlatformAccessoryEvent.IDENTIFY, () => {
+      this.robot.findMe();
+
+      this.robot.getState((error, result) => {
+        this.log.info('[' + this.robot.name + '] Identified');
+        if (error) {
+          this.debug(DebugType.INFO, JSON.stringify('Error: ' + error));
+        }
+        this.debug(DebugType.INFO, 'Status: ' + JSON.stringify(result));
+        this.debug(
+          DebugType.INFO,
+          'Config: Background Update Interval: ' +
+            this.backgroundUpdateInterval +
+            ', Prefix: ' +
+            this.prefix +
+            ', Enabled services: ' +
+            JSON.stringify(this.availableServices),
+        );
+      });
+    });
+
+    [
+      this.getClean,
+      this.setClean,
+      this.getSpotClean,
+      this.setSpotClean,
+      this.getGoToDock,
+      this.setGoToDock,
+      this.getDocked,
+      this.getBinFull,
+      this.getFindMe,
+      this.setFindMe,
+      this.getSchedule,
+      this.setSchedule,
+      this.getEco,
+      this.setEco,
+      this.getNoGoLines,
+      this.setNoGoLines,
+      this.getExtraCare,
+      this.setExtraCare,
+    ].forEach((f) => {
+      f = f.bind(this);
+    });
+
+    // Services
+    this.cleanService = this.registerService(
+      RobotService.CLEAN,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getClean,
+          setCharacteristicHandler: this.setClean,
+        },
+      ],
+    );
+    this.spotCleanService = this.registerService(
+      RobotService.CLEAN_SPOT,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getSpotClean,
+          setCharacteristicHandler: this.setSpotClean,
+        },
+      ],
+    );
+    this.goToDockService = this.registerService(
+      RobotService.GO_TO_DOCK,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getGoToDock,
+          setCharacteristicHandler: this.setGoToDock,
+        },
+      ],
+    );
+    this.dockStateService = this.registerService(
+      RobotService.DOCKED,
+      this.platform.Service.OccupancySensor,
+      [
+        {
+          characteristic:
+            this.platform.Characteristic.OccupancyDetected.OccupancyDetected,
+          getCharacteristicHandler: this.getDocked,
+        },
+      ],
+    );
+    this.binFullService = this.registerService(
+      RobotService.BIN_FULL,
+      this.platform.Service.OccupancySensor,
+      [
+        {
+          characteristic:
+            this.platform.Characteristic.OccupancyDetected.OccupancyDetected,
+          getCharacteristicHandler: this.getBinFull,
+        },
+      ],
+    );
+    this.findMeService = this.registerService(
+      RobotService.FIND_ME,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getFindMe,
+          setCharacteristicHandler: this.setFindMe,
+        },
+      ],
+    );
+    this.scheduleService = this.registerService(
+      RobotService.SCHEDULE,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getSchedule,
+          setCharacteristicHandler: this.setSchedule,
+        },
+      ],
+    );
+    this.ecoService = this.registerService(
+      RobotService.ECO,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getEco,
+          setCharacteristicHandler: this.setEco,
+        },
+      ],
+    );
+    this.noGoLinesService = this.registerService(
+      RobotService.NOGO_LINES,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getNoGoLines,
+          setCharacteristicHandler: this.setNoGoLines,
+        },
+      ],
+    );
+    this.extraCareService = this.registerService(
+      RobotService.EXTRA_CARE,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getExtraCare,
+          setCharacteristicHandler: this.setExtraCare,
+        },
+      ],
+    );
+    this.batteryService = this.registerService(
+      RobotService.BATTERY,
+      this.platform.Service.Battery,
+    );
+
+    // This should be the main switch if the accessory is grouped in homekit
+    if (this.cleanService) {
+      this.cleanService.setPrimaryService(true);
+    }
+
+    // Start background update
+    this.updateRobotPeriodically().then(() => {
+      // Add special characteristics to set spot cleaning options
+      this.spotPlusFeatures =
+        typeof this.robot.availableServices.spotCleaning !== 'undefined' &&
+        this.robot.availableServices.spotCleaning.includes('basic');
+      this.addSpotCleanCharacteristics();
+
+      // Save/Load options
+      if (!accessory.context.options) {
+        this.options.eco = this.robot.eco;
+        this.options.noGoLines = this.robot.noGoLines;
+        this.options.extraCare = this.robot.navigationMode === 2;
+        this.debug(
+          DebugType.INFO,
+          'Options initially set to eco: ' +
+            this.options.eco +
+            ', noGoLines: ' +
+            this.options.noGoLines +
+            ', extraCare: ' +
+            this.options.extraCare,
+        );
+        accessory.context.options = this.options;
+      } else {
+        this.debug(
+          DebugType.INFO,
+          'Options loaded from cache eco: ' +
+            this.options.eco +
+            ', noGoLines: ' +
+            this.options.noGoLines +
+            ', extraCare: ' +
+            this.options.extraCare,
+        );
+      }
+    });
+  }
+
+  private addSpotCleanCharacteristics() {
+    // Only add characteristics of service is available ond characteristics are not added yet
+    if (this.spotCleanService && !this.options.spotCharacteristics) {
+      this.spotCleanService
+        .addCharacteristic(spotRepeat(this.platform.Characteristic))
+        .onGet(this.getSpotRepeat.bind(this))
+        .onSet(this.setSpotRepeat.bind(this));
+
+      // Add these only if the robot supports them
+      if (this.spotPlusFeatures) {
+        this.spotCleanService
+          .addCharacteristic(spotWidth(this.platform.Characteristic))
+          .onGet(this.getSpotWidth.bind(this))
+          .onSet(this.setSpotWidth.bind(this));
+        this.spotCleanService
+          .addCharacteristic(spotHeight(this.platform.Characteristic))
+          .onGet(this.getSpotHeight.bind(this))
+          .onSet(this.setSpotHeight.bind(this));
+      }
+      this.options.spotCharacteristics = true;
+    } else if (this.spotCleanService === null) {
+      this.options.spotCharacteristics = false;
+    }
+  }
+
+  private registerService(
+    serviceName: RobotService,
+    serviceType: WithUUID<typeof Service>,
+    characteristicHandlers: CharacteristicHandler[] = [],
+  ): Service | undefined {
+    const displayName =
+      (this.prefix ? this.robot.name + ' ' : '') +
+      localize(serviceName, this.locale);
+
+    // query existing service by type and subtype
+    const existingService = this.accessory.getServiceById(
+      serviceType,
+      serviceName,
+    );
+
+    if (this.availableServices.has(serviceName)) {
+      let service: Service;
+      if (existingService && existingService.displayName === displayName) {
+        service = existingService;
+      } else {
+        if (existingService) {
+          this.accessory.removeService(existingService);
+        } // delete to reset display name in case of locale or prefix change
+        service = this.accessory.addService(
+          serviceType,
+          displayName,
+          serviceName,
+        );
+      }
+      characteristicHandlers.forEach((ch) => {
+        const char = service.getCharacteristic(ch.characteristic);
+        if (ch.getCharacteristicHandler) {
+          char.onGet(ch.getCharacteristicHandler);
+        }
+        if (ch.setCharacteristicHandler) {
+          char.onSet(ch.setCharacteristicHandler);
+        }
+      });
+      return service;
+    } else {
+      if (existingService) {
+        this.accessory.removeService(existingService);
+      }
+    }
+  }
+
+  private static parseBackgroundUpdateInterval(configValue: any) {
+    // Parse as number
+    let backgroundUpdateInterval = parseInt(configValue) || BACKGROUND_INTERVAL;
+
+    // must be integer and positive
+    backgroundUpdateInterval =
+      backgroundUpdateInterval % 1 !== 0 || backgroundUpdateInterval < 0
+        ? BACKGROUND_INTERVAL
+        : backgroundUpdateInterval;
+
+    return backgroundUpdateInterval;
+  }
+
+  async getClean(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.canPause && !this.isSpotCleaning;
+    } catch (error) {
+      this.log.error('Cannot get cleaning status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async setClean(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set CLEAN HOUSE: ' + on);
+    try {
+      await this.updateRobot();
+
+      // Start
+      if (on) {
+        // Resume cleaning
+        if (this.robot.canResume) {
+          this.debug(DebugType.ACTION, 'Resume cleaning');
+          await this.robot.resumeCleaning();
+        }
+        // Start cleaning
+        else if (this.robot.canStart) {
+          await this.clean(CleanType.ALL);
+        }
+        // Cannot start
+        else {
+          this.debug(
+            DebugType.INFO,
+            'Cannot start, maybe already cleaning (expected)',
+          );
+        }
+      }
+      // Stop
+      else {
+        if (this.robot.canPause) {
+          this.debug(DebugType.ACTION, 'Pause cleaning');
+          await this.robot.pauseCleaning();
+        } else {
+          this.debug(DebugType.INFO, 'Already paused');
+        }
+      }
+    } catch (error) {
+      this.log.error('Error setting cleaning to: ' + on + '. ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async getSpotClean(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.canPause && this.isSpotCleaning;
+    } catch (error) {
+      this.log.error('Cannot get spot cleaning status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async setSpotClean(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT CLEAN: ' + on);
+    try {
+      if (on) {
+        await this.clean(CleanType.SPOT);
+      } else {
+        // TODO stop/pause
+      }
+    } catch (error) {
+      this.log.error('Error setting spot cleaning to: ' + on + '. ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  getGoToDock() {
+    return false;
+  }
+
+  async setGoToDock(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set GO TO DOCK: ' + on);
+    if (on) {
+      await this.updateRobot();
+
+      setTimeout(() => {
+        if (this.goToDockService) {
+          this.goToDockService.updateCharacteristic(
+            this.platform.Characteristic.On,
+            false,
+          );
+        }
+      }, 10000);
+
+      try {
+        if (this.robot.canPause) {
+          this.debug(DebugType.ACTION, 'Pause cleaning to go to dock');
+          await this.robot.pauseCleaning();
+          setTimeout(async () => {
+            await this.robot.sendToBase();
+          }, 1000);
+        } else if (this.robot.canGoToBase) {
+          this.debug(DebugType.ACTION, 'Going to dock');
+          await this.robot.sendToBase();
+        } else {
+          this.log.warn(
+            '[' + this.robot.name + '] Can\'t go to dock at the moment',
+          );
+        }
+      } catch (error) {
+        this.log.error('Error setting go to dock to: ' + on + '. ' + error);
+        throw new this.platform.api.hap.HapStatusError(
+          this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+        );
+      }
+    }
+  }
+
+  async getDocked(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.isDocked;
+    } catch (error) {
+      this.log.error('Cannot get docked status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async getBinFull(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.isBinFull;
+    } catch (error) {
+      this.log.error('Cannot get bin full status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async getSchedule(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.isScheduleEnabled;
+    } catch (error) {
+      this.log.error('Cannot get schedule status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async setSchedule(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SCHEDULE: ' + on);
+    try {
+      if (on) {
+        await this.robot.enableSchedule();
+      } else {
+        await this.robot.disableSchedule();
+      }
+    } catch (error) {
+      this.log.error('Error setting schedule to: ' + on + '. ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  getEco() {
+    return this.options.eco;
+  }
+
+  setEco(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set ECO: ' + on);
+    this.options.eco = <boolean>on;
+  }
+
+  getExtraCare() {
+    return this.options.extraCare;
+  }
+
+  setExtraCare(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set EXTRA CARE: ' + on);
+    this.options.extraCare = <boolean>on;
+  }
+
+  getNoGoLines() {
+    return this.options.noGoLines;
+  }
+
+  setNoGoLines(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set NOGO LINES: ' + on);
+    this.options.noGoLines = <boolean>on;
+  }
+
+  getSpotRepeat() {
+    return this.options.spotRepeat;
+  }
+
+  setSpotRepeat(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT REPEAT: ' + on);
+    this.options.spotRepeat = <boolean>on;
+  }
+
+  getSpotWidth() {
+    return this.options.spotWidth;
+  }
+
+  setSpotWidth(length: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT WIDTH: ' + length + ' cm');
+    this.options.spotWidth = <number>length;
+  }
+
+  getSpotHeight() {
+    return this.options.spotHeight;
+  }
+
+  setSpotHeight(length: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT HEIGHT: ' + length + ' cm');
+    this.options.spotHeight = <number>length;
+  }
+
+  getFindMe() {
+    return false;
+  }
+
+  async setFindMe(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set FIND ME: ' + on);
+    if (on) {
+      this.debug(DebugType.ACTION, 'Find me');
+      setTimeout(() => {
+        if (this.findMeService) {
+          this.findMeService.updateCharacteristic(
+            this.platform.Characteristic.On,
+            false,
+          );
+        }
+      }, 1000);
+
+      try {
+        await this.robot.findMe();
+      } catch (error) {
+        this.log.error(this.robot.name + ' ## Cannot start find me. ' + error);
+        throw new this.platform.api.hap.HapStatusError(
+          this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+        );
+      }
+    }
+  }
+
+  async clean(cleanType: CleanType) {
+    // Enable shorter background update while cleaning
+    setTimeout(() => {
+      this.updateRobotPeriodically();
+    }, 2 * 60 * 1000);
+
+    this.log.info(
+      '[' +
+        this.robot.name +
+        '] > Start cleaning with options type: ' +
+        CleanType[cleanType] +
+        ', eco: ' +
+        this.options.eco +
+        ', noGoLines: ' +
+        this.options.noGoLines +
+        ', extraCare: ' +
+        this.options.extraCare,
+    );
+
+    try {
+      switch (cleanType) {
+        case CleanType.ALL:
+          await this.robot.startCleaning(
+            this.options.eco,
+            this.options.extraCare ? 2 : 1,
+            this.options.noGoLines,
+          );
+          break;
+        case CleanType.SPOT:
+          await this.robot.startSpotCleaning(
+            this.options.eco,
+            this.options.spotWidth,
+            this.options.spotHeight,
+            this.options.spotRepeat,
+            this.options.extraCare ? 2 : 1,
+          );
+          break;
+      }
+    } catch (error) {
+      this.log.error('Cannot start cleaning. ' + error);
+    }
+  }
+
+  async updateRobot() {
+    // Data is outdated
+    if (
+      typeof this.robot.lastUpdate === 'undefined' ||
+      new Date().getTime() - this.robot.lastUpdate > 2000
+    ) {
+      this.robot.lastUpdate = new Date().getTime();
+      try {
+        this.robot.getState((error, result) => {
+          this.isSpotCleaning = result !== null && result.action === 2;
+
+          // Battery
+          this.batteryService?.updateCharacteristic(
+            this.platform.Characteristic.BatteryLevel,
+            this.robot.charge,
+          );
+          this.batteryService?.updateCharacteristic(
+            this.platform.Characteristic.ChargingState,
+            this.robot.isCharging,
+          );
+        });
+      } catch (error) {
+        this.log.error(
+          'Cannot update robot ' +
+            this.robot.name +
+            '. Check if robot is online. ' +
+            error,
+        );
+        return false;
+      }
+    }
+  }
+
+  async updateRobotPeriodically() {
+    this.debug(DebugType.INFO, 'Performing background update');
+
+    await this.updateRobot();
+    await this.updateCharacteristics();
+
+    // Clear any other overlapping timers for this robot
+    clearTimeout(this.timer);
+
+    // Tell all accessories of this robot (mainAccessory and roomAccessories) that updated robot data is available
+    // this.robot.mainAccessory.updated();
+    // this.robot.roomAccessories.forEach(accessory => {
+    // 	accessory.updated();
+    // });
+
+    // Periodic refresh interval set in config
+    let interval;
+    if (this.robot.canPause) {
+      interval = 1;
+    } else {
+      interval = this.backgroundUpdateInterval;
+    }
+
+    this.debug(
+      DebugType.INFO,
+      'Background update done. Next update in ' +
+        interval +
+        ' minute' +
+        (interval === 1 ? '' : 's') +
+        (this.robot.canPause ? ', robot is currently cleaning.' : '.'),
+    );
+    this.timer = setTimeout(
+      this.updateRobotPeriodically.bind(this),
+      interval * 60 * 1000,
+    );
+  }
+
+  async updateCharacteristics() {
+    if (this.cleanService) {
+      this.cleanService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getClean(),
+      );
+    }
+    if (this.spotCleanService) {
+      this.spotCleanService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getSpotClean(),
+      );
+    }
+    if (this.goToDockService) {
+      this.goToDockService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getGoToDock(),
+      );
+    }
+    if (this.dockStateService) {
+      this.dockStateService.updateCharacteristic(
+        this.platform.Characteristic.OccupancyDetected,
+        await this.getDocked(),
+      );
+    }
+    if (this.binFullService) {
+      this.binFullService.updateCharacteristic(
+        this.platform.Characteristic.OccupancyDetected,
+        await this.getBinFull(),
+      );
+    }
+    if (this.scheduleService) {
+      this.scheduleService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getSchedule(),
+      );
+    }
+  }
+
+  private debug(debugType: DebugType, message: string) {
+    switch (debugType) {
+      case DebugType.ACTION:
+        this.log.debug('[' + this.robot.name + '] > ' + message);
+        break;
+      case DebugType.STATUS:
+        this.log.debug('[' + this.robot.name + '] ' + message);
+        break;
+      case DebugType.INFO:
+        this.log.debug('[' + this.robot.name + '] ' + message);
+        break;
+    }
+  }
+}
+
+enum DebugType {
+  ACTION,
+  STATUS,
+  INFO,
+}
--- a/src/accessories/room.ts
+++ b/src/accessories/room.ts
@@ -0,0 +1,37 @@
+// import {CharacteristicValue, Logger, PlatformAccessory, PlatformConfig, Service} from 'homebridge';
+// import {HomebridgeNeatoPlatform} from '../homebridgeNeatoPlatform';
+//
+// const debug = require('debug')('my-app:my-module');
+//
+// /**
+//  * Platform Accessory
+//  * An instance of this class is created for each accessory your platform registers
+//  * Each accessory may expose multiple services of different service types.
+//  */
+// export class Room
+// {
+//
+// 	private robot: any;
+// 	private log: Logger;
+// 	private readonly refresh: any;
+//	
+//
+// 	/**
+// 	 * These are just used to create a working example
+// 	 * You should implement your own code to track the state of your accessory
+// 	 */
+//
+// 	constructor(
+// 			private readonly platform: HomebridgeNeatoPlatform,
+// 			private readonly accessory: PlatformAccessory,
+// 			private readonly isNew: Boolean,
+// 			private readonly config: PlatformConfig)
+// 	{
+//		
+// 	}
+//	
+// 	async setCleanRoom()
+// 	{
+//		
+// 	}
+// }
--- a/src/characteristics/characteristicHandler.ts
+++ b/src/characteristics/characteristicHandler.ts
@@ -0,0 +1,7 @@
+import { Characteristic, CharacteristicGetHandler, CharacteristicSetHandler, WithUUID } from 'homebridge';
+
+export declare interface CharacteristicHandler{
+    characteristic: WithUUID<new () => Characteristic>;
+    getCharacteristicHandler?: CharacteristicGetHandler;
+    setCharacteristicHandler?: CharacteristicSetHandler;
+}
--- a/src/characteristics/spotHeight.ts
+++ b/src/characteristics/spotHeight.ts
@@ -0,0 +1,21 @@
+import type { Characteristic, WithUUID } from 'homebridge';
+import { Formats, Perms } from 'homebridge';
+
+export default function spotHeight(
+  CustomCharacteristic: typeof Characteristic,
+): WithUUID<new () => Characteristic> {
+  return class SpotHeight extends CustomCharacteristic {
+    static readonly UUID = 'CA282DB2-62BF-4325-A1BE-F8BB5478781A';
+
+    constructor() {
+      super('Spot ↕', SpotHeight.UUID, {
+        format: Formats.INT,
+        unit: 'cm',
+        maxValue: 400,
+        minValue: 100,
+        minStep: 50,
+        perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE],
+      });
+    }
+  };
+}
--- a/src/characteristics/spotRepeat.ts
+++ b/src/characteristics/spotRepeat.ts
@@ -0,0 +1,17 @@
+import type { Characteristic, WithUUID } from 'homebridge';
+import { Formats, Perms } from 'homebridge';
+
+export default function spotRepeat(
+  CustomCharacteristic: typeof Characteristic,
+): WithUUID<new () => Characteristic> {
+  return class SpotRepeat extends CustomCharacteristic {
+    static readonly UUID = '1E79C603-63B8-4E6A-9CE1-D31D67981831';
+
+    constructor() {
+      super('Spot 2x', SpotRepeat.UUID, {
+        format: Formats.BOOL,
+        perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE],
+      });
+    }
+  };
+}
--- a/src/characteristics/spotWidth.ts
+++ b/src/characteristics/spotWidth.ts
@@ -0,0 +1,21 @@
+import type { Characteristic, WithUUID } from 'homebridge';
+import { Formats, Perms } from 'homebridge';
+
+export default function spotWidth(
+  CustomCharacteristic: typeof Characteristic,
+): WithUUID<new () => Characteristic> {
+  return class SpotWidth extends CustomCharacteristic {
+    static readonly UUID = 'A7889A9A-2F27-4293-BEF8-3FE805B36F4E';
+
+    constructor() {
+      super('Spot ↔', SpotWidth.UUID, {
+        format: Formats.INT,
+        unit: 'cm',
+        maxValue: 400,
+        minValue: 100,
+        minStep: 50,
+        perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE],
+      });
+    }
+  };
+}
--- a/src/defaults.ts
+++ b/src/defaults.ts
@@ -0,0 +1,6 @@
+import { RobotService } from './models/services';
+
+export const BACKGROUND_INTERVAL = 30;
+export const PREFIX = false;
+export const ALL_SERVICES = new Set(Object.values(RobotService));
+export const LOCALE = 'en';
--- a/src/homebridgeKoboldPlatform.ts
+++ b/src/homebridgeKoboldPlatform.ts
@@ -0,0 +1,273 @@
+import {
+  API,
+  Characteristic,
+  DynamicPlatformPlugin,
+  Logger,
+  PlatformAccessory,
+  PlatformConfig,
+  Service,
+} from 'homebridge';
+import KoboldApi from 'node-kobold-control';
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings';
+import { KoboldVacuumRobotAccessory } from './accessories/koboldVacuumRobot';
+
+/**
+ * HomebridgePlatform
+ * This class is the main constructor for your plugin, this is where you should
+ * parse the user config and discover/register accessories with Homebridge.
+ */
+export class HomebridgeKoboldPlatform implements DynamicPlatformPlugin {
+  public readonly Service: typeof Service = this.api.hap.Service;
+  public readonly Characteristic: typeof Characteristic =
+    this.api.hap.Characteristic;
+
+  // this is used to track restored cached accessories
+  public readonly cachedRobotAccessories: PlatformAccessory[] = [];
+
+  constructor(
+    public readonly log: Logger,
+    public readonly config: PlatformConfig,
+    public readonly api: API,
+  ) {
+    this.api.on('didFinishLaunching', () => {
+      this.discoverRobots();
+    });
+  }
+
+  /**
+   * This function is invoked when homebridge restores cached accessories from disk at startup.
+   * It should be used to setup event handlers for characteristics and update respective values.
+   */
+  configureAccessory(accessory: PlatformAccessory) {
+    // add the restored accessory to the accessories cache so we can track if it has already been registered
+    this.cachedRobotAccessories.push(accessory);
+  }
+
+  discoverRobots() {
+    const client = new KoboldApi.Client();
+
+    try {
+      // Login
+      client.authorize(this.config['token'], (error) => {
+        if (error) {
+          this.log.error(
+            `Cannot connect to Vorwerk server. 
+			No new robots will be found and existing robots will be unresponsive. 
+			Retrying in 5 minutes.`,
+          );
+          this.log.error('Error: ' + error);
+
+          setTimeout(() => {
+            this.discoverRobots();
+          }, 5 * 60 * 1000);
+          return;
+        }
+
+        // Get all robots from account
+        client.getRobots((error, robots) => {
+          if (error) {
+            this.log.error(
+              'Successful login but can\'t list the robots in your Vorwerk robots. Retrying in 5 minutes.',
+            );
+            this.log.error('Error: ' + error);
+
+            setTimeout(() => {
+              this.discoverRobots();
+            }, 5 * 60 * 1000);
+            return;
+          }
+
+          // Vorwerk robots in account
+          if (robots.length === 0) {
+            this.log.error('Vorwerk account has no robots.');
+          } else {
+            this.log.info(
+              'Vorwerk account has ' +
+                robots.length +
+                ' robot' +
+                (robots.length === 1 ? '' : 's'),
+            );
+          }
+
+          // Vorwerk robots in cache
+          this.log.debug(
+            'Plugin Cache has ' +
+              this.cachedRobotAccessories.length +
+              ' robot' +
+              (this.cachedRobotAccessories.length === 1 ? '' : 's'),
+          );
+          for (const cachedRobot of this.cachedRobotAccessories) {
+            const accountRobot = robots.find(
+              (robot) =>
+                this.api.hap.uuid.generate(robot._serial) === cachedRobot.UUID,
+            );
+            if (accountRobot) {
+              this.log.debug(
+                '[' +
+                  cachedRobot.displayName +
+                  '] Cached robot found in Vorwerk account.',
+              );
+            } else {
+              this.log.error(
+                '[' +
+                  cachedRobot.displayName +
+                  '] Cached robot not found in Vorwerk account. Robot will now be removed from homebridge.',
+              );
+              this.api.unregisterPlatformAccessories(
+                PLUGIN_NAME,
+                PLATFORM_NAME,
+                [cachedRobot],
+              );
+            }
+          }
+
+          // Add / Update homebridge accessories with robot information from Vorwerk.
+          // This must be done for new and existing robots to reflect changes in the name, firmware, pluginconfig etc.
+          for (const robot of robots) {
+            // Check if robot already exists as an accessory
+            const uuid = this.api.hap.uuid.generate(robot._serial);
+            const cachedRobot = this.cachedRobotAccessories.find(
+              (accessory) => accessory.UUID === uuid,
+            );
+
+            if (cachedRobot) {
+              this.log.debug(
+                '[' +
+                  robot.name +
+                  '] Connecting to cached robot and updating information.',
+              );
+            } else {
+              this.log.debug(
+                '[' +
+                  robot.name +
+                  '] Connecting to new robot and updating information.',
+              );
+            }
+
+            robot.getState((error, state) => {
+              if (error) {
+                this.log.error(
+                  '[' +
+                    robot.name +
+                    '] Cannot connect to robot. Is the robot connected to the internet? Retrying in 5 minutes.',
+                );
+                this.log.error('Error: ' + error);
+                setTimeout(() => {
+                  this.discoverRobots();
+                }, 5 * 60 * 1000);
+              } else {
+                try {
+                  robot.meta = state.meta;
+                  robot.availableServices = state.availableServices;
+
+                  // Update existing robot accessor
+                  if (cachedRobot) {
+                    // TODO update maps
+
+                    cachedRobot.context.robot = robot;
+                    this.api.updatePlatformAccessories([cachedRobot]);
+                    new KoboldVacuumRobotAccessory(
+                      this,
+                      cachedRobot,
+                      this.config,
+                    );
+                    this.log.info(
+                      '[' +
+                        robot.name +
+                        '] Successfully loaded robot from cache',
+                    );
+                  } else {
+                    // Create new robot accessory
+                    // TODO get maps
+
+                    const newRobot = new this.api.platformAccessory(
+                      robot.name,
+                      uuid,
+                    );
+                    newRobot.context.robot = robot;
+                    new KoboldVacuumRobotAccessory(this, newRobot, this.config);
+                    this.api.registerPlatformAccessories(
+                      PLUGIN_NAME,
+                      PLATFORM_NAME,
+                      [newRobot],
+                    );
+                    this.log.info(
+                      '[' + robot.name + '] Successfully created as new robot',
+                    );
+                  }
+                } catch (error) {
+                  this.log.error(
+                    '[' +
+                      robot.name +
+                      '] Creating accessory failed. Error: ' +
+                      error,
+                  );
+                  throw new this.api.hap.HapStatusError(
+                    this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+                  );
+                }
+              }
+
+              // // Get all maps for each robot
+              // robot.getPersistentMaps((error, maps) => {
+              // 	if (error)
+              // 	{
+              // 		this.log.error("Error updating persistent maps: " + error + ": " + maps);
+              // 		callback();
+              // 	}
+              // 	// Robot has no maps
+              // 	else if (maps.length === 0)
+              // 	{
+              // 		robot.maps = [];
+              // 		this.robotAccessories.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+              // 		loadedRobots++;
+              // 		if (loadedRobots === robots.length)
+              // 		{
+              // 			callback();
+              // 		}
+              // 	}
+              // 	// Robot has maps
+              // 	else
+              // 	{
+              // 		robot.maps = maps;
+              // 		let loadedMaps = 0;
+              // 		robot.maps.forEach((map) => {
+              // 			// Save zones in each map
+              // 			robot.getMapBoundaries(map.id, (error, result) => {
+              // 				if (error)
+              // 				{
+              // 					this.log.error("Error getting boundaries: " + error + ": " + result)
+              // 				}
+              // 				else
+              // 				{
+              // 					map.boundaries = result.boundaries;
+              // 				}
+              // 				loadedMaps++;
+              //
+              // 				// Robot is completely requested if zones for all maps are loaded
+              // 				if (loadedMaps === robot.maps.length)
+              // 				{
+              // 					this.robotAccessories.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+              // 					loadedRobots++;
+              // 					if (loadedRobots === robots.length)
+              // 					{
+              // 						callback();
+              // 					}
+              // 				}
+              // 			})
+              // 		});
+              // 	}
+              // });
+            });
+          }
+        });
+      });
+    } catch (error) {
+      this.log.error(
+        `Can't log on to Vorwerk cloud. Please check your internet connection and your credentials.
+		Try again later if the neato servers have issues. Error: ` +
+          error,
+      );
+    }
+  }
+}
--- a/src/index.ts
+++ b/src/index.ts
@@ -0,0 +1,11 @@
+import { API } from 'homebridge';
+
+import { PLATFORM_NAME } from './settings';
+import { HomebridgeKoboldPlatform } from './homebridgeKoboldPlatform';
+
+/**
+ * This method registers the platform with Homebridge
+ */
+export = (api: API) => {
+  api.registerPlatform(PLATFORM_NAME, HomebridgeKoboldPlatform);
+};
--- a/src/localization.ts
+++ b/src/localization.ts
@@ -0,0 +1,57 @@
+export enum availableLocales {
+    EN = "en",
+    DE = "de",
+    FR = "fr",
+}
+
+const localizationDicts = {
+    'en': {
+        "clean": "Clean",
+        "cleanZone": "Clean Zone",
+        "cleanThe": "Clean the",
+        "goToDock": "Go to Dock",
+        "dockState": "Docked",
+        "binFull": "Bin Full",
+        "eco": "Eco Mode",
+        "noGoLines": "NoGo Lines",
+        "extraCare": "Extra Care",
+        "schedule": "Schedule",
+        "findMe": "Find me",
+        "cleanSpot": "Clean Spot",
+        "battery": "Battery"
+    },
+    'de': {
+        "clean": "Sauge",
+        "cleanZone": "Sauge Zone",
+        "cleanThe": "Sauge",
+        "goToDock": "Zur Basis",
+        "dockState": "In der Basis",
+        "binFull": "Behälter voll",
+        "eco": "Eco Modus",
+        "noGoLines": "NoGo Linien",
+        "extraCare": "Extra Care",
+        "schedule": "Zeitplan",
+        "findMe": "Finde mich",
+        "cleanSpot": "Spot Reinigung",
+        "battery": "Batterie"
+    },
+    'fr': {
+        "clean": "Aspirer",
+        "cleanZone": "Aspirer Zone",
+        "cleanThe": "Aspirer",
+        "goToDock": "Retour à la base",
+        "dockState": "Sur la base",
+        "binFull": "Conteneur plein",
+        "eco": "Eco mode",
+        "noGoLines": "Lignes NoGo",
+        "extraCare": "Extra Care",
+        "schedule": "Planifier",
+        "findMe": "Me retrouver",
+        "cleanSpot": "Nettoyage local",
+        "battery": "Batterie"
+    }
+}
+
+export function localize(label: string, locale: availableLocales) : string {
+    return localizationDicts[locale][label] ?? label
+}
--- a/src/models/options.ts
+++ b/src/models/options.ts
@@ -0,0 +1,19 @@
+export class Options {
+  public eco: boolean;
+  public extraCare: boolean;
+  public noGoLines: boolean;
+  public spotCharacteristics: boolean;
+  public spotRepeat: boolean;
+  public spotWidth: number;
+  public spotHeight: number;
+
+  constructor() {
+    this.eco = false;
+    this.extraCare = false;
+    this.noGoLines = false;
+    this.spotCharacteristics = false;
+    this.spotRepeat = false;
+    this.spotWidth = 200;
+    this.spotHeight = 200;
+  }
+}
--- a/src/models/services.ts
+++ b/src/models/services.ts
@@ -0,0 +1,19 @@
+export enum CleanType {
+  ALL,
+  SPOT,
+}
+
+export enum RobotService {
+  CLEAN = 'clean',
+  CLEAN_SPOT = 'cleanSpot',
+  CLEAN_ZONE = 'cleanZone',
+  GO_TO_DOCK = 'goToDock',
+  DOCKED = 'dockState',
+  BIN_FULL = 'binFull',
+  FIND_ME = 'findMe',
+  SCHEDULE = 'schedule',
+  ECO = 'eco',
+  NOGO_LINES = 'noGoLines',
+  EXTRA_CARE = 'extraCare',
+  BATTERY = 'battery',
+}
--- a/src/settings.ts
+++ b/src/settings.ts
@@ -0,0 +1,9 @@
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+export const PLATFORM_NAME = "KoboldVacuumRobot";
+
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+export const PLUGIN_NAME = "homebridge-kobold";
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2018", // ~node10
+    "module": "commonjs",
+    "lib": [
+      "es2015",
+      "es2016",
+      "es2017",
+      "es2018"
+    ],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "noImplicitAny": false
+  },
+  "include": [
+    "src/"
+  ],
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}
Author	SHA1	Message	Date
Luis Riegger	82808d7850	eslint compliance	2021-05-10 20:51:29 +02:00
Luis Riegger	9a9789328f	eslint conformance for	2021-05-10 20:43:56 +02:00
Luis Riegger	38660ebea7	add .eslintrc	2021-05-10 20:43:35 +02:00
Luis Riegger	950a3eed4d	newest neato change: fix spot cleaning	2021-05-10 10:06:49 +02:00
Luis Riegger	0d54f15382	minor restructuring	2021-05-10 09:53:47 +02:00
Luis Riegger	969f843662	merge newest neato changes	2021-05-10 09:30:07 +02:00
Luis Riegger	7064a5c8cb	characteristic handlers	2021-05-10 09:13:06 +02:00
Luis Riegger	28a35cbdb6	fix registering	2021-05-09 19:02:02 +02:00
Luis Riegger	ca4b672bee	fix localization logic	2021-05-09 18:34:46 +02:00
Luis Riegger	4c00c67819	make register service independent of display name	2021-05-09 18:31:28 +02:00
Luis Riegger	66f8f2e277	rename defaults	2021-05-09 16:32:02 +02:00
Luis Riegger	0e50126a34	fix schema	2021-05-09 16:30:29 +02:00
Luis Riegger	449bef0aa0	integrate localization	2021-05-09 16:27:32 +02:00
Luis Riegger	65227077c8	update gitignore	2021-05-09 16:19:28 +02:00
Luis Riegger	acb50b3c95	update config schema	2021-05-09 16:11:40 +02:00
Luis Riegger	4f9e2ee7f2	neato -> kobold	2021-05-08 20:02:25 +02:00
Luis Riegger	369a6f6412	initial merge attempt	2021-05-08 19:33:37 +02:00
Luis Riegger	750b25066b	add tsconfig	2021-05-08 18:55:09 +02:00
Luis Riegger	06c2483c57	update package	2021-05-08 18:53:18 +02:00
Luis Riegger	c2050afa21	update config.schema	2021-05-08 18:45:41 +02:00
Luis Riegger	1b10a91d96	add nodemon script	2021-05-08 18:30:20 +02:00
Luis Riegger	984d75b00a	update changelog	2021-05-08 18:30:02 +02:00
Luis Riegger	56364f2ff3	Update Changelog	2021-05-04 08:04:20 +02:00
Luis Riegger	76dad58bbe	0.8.4	2021-05-04 08:03:07 +02:00
Luis Riegger	1e494ae683	Link to token getter in UI	2021-05-04 08:02:18 +02:00
Luis R	f206d3ddaf	Update README.md	2021-05-03 13:16:30 +02:00
Luis Riegger	70099e3c5a	Bump node-kobold-control version	2021-05-02 10:06:32 +02:00
Luis R	15f93ba1d7	Update README.md Add npm shield tag	2021-04-30 15:18:10 +02:00
Luis R	bd6c77a4da	Bump version to 0.8.3	2021-04-30 15:12:17 +02:00
Luis R	81d3385c48	Merge pull request #1 from aluini/feature/lang-fr Add french plugin language	2021-04-30 15:11:38 +02:00
Luis R	6c7d669a43	Merge branch 'master' into feature/lang-fr	2021-04-30 15:08:46 +02:00
Luis Riegger	8ae17f6a4a	Merge branch 'master' of https://github.com/himbeles/homebridge-kobold	2021-04-30 15:00:55 +02:00
Luis Riegger	13846a9322	update changelog and bump version to 0.8.2	2021-04-30 15:00:52 +02:00
Arne Blumentritt	ae7138e245	Fixed homebridge 1.3 warning because of additional parameter in setter callback	2021-04-30 14:52:26 +02:00
Arne Blumentritt	16140dc71e	Fixed #61 Warnings in homebridge 1.3 because of illegal characteristic values	2021-04-30 14:51:47 +02:00
Luis R	310ed41e28	Update npm.yml	2021-04-30 14:41:40 +02:00
Luis R	b9e0e64390	Create Github Action for publishing to npm	2021-04-30 14:29:01 +02:00
Alexandre Luini	0376dc09d5	add french plugin language	2021-03-10 16:49:40 +01:00
Luis Riegger	4b6002f686	bump npm version	2021-02-07 15:31:31 +01:00
Luis Riegger	c847481487	Include Include Robot name in Homekit battery service name	2021-02-07 15:27:57 +01:00
Luis Riegger	cc99ecef0d	add german plugin language	2021-02-07 11:15:08 +01:00
Luis Riegger	721db866ff	remove _config.yml	2021-02-07 10:25:02 +01:00
Luis R	6821adc1e3	Update README.md	2020-12-13 22:51:05 +01:00
Luis R	df52bd103f	Update README.md	2020-12-13 22:49:48 +01:00
Luis Riegger	28cdabe47c	correct typos in config.schema.json	2020-12-13 22:20:01 +01:00
Luis Riegger	6fd2e46bff	Update README	2020-12-13 18:33:13 +01:00
Luis Riegger	a99359f6ac	adapt for node-kobold-control api	2020-12-13 18:31:44 +01:00
Luis Riegger	49e3fdf191	adapt package dependency	2020-12-13 10:23:59 +01:00
Luis Riegger	295c9b01a1	Further adapt README.md, Licence and Package	2020-12-12 15:52:26 +01:00
Luis Riegger	eecf7f21f8	Adapt README.md	2020-12-12 15:42:06 +01:00
Arne	5ff3951668	Update README.md	2020-10-08 12:10:43 +02:00
Arne	b83d30cfad	Update README.md	2020-03-14 00:33:45 +01:00
Arne	b53ef4ff2f	Update README.md	2020-03-14 00:32:48 +01:00
Arne	d8ca308338	Updated changelog	2019-10-19 17:33:58 +02:00
Arne	75180b27cb	Bumped version to v0.7.2	2019-10-19 17:31:38 +02:00
Arne	b8971b64a9	Updated readme	2019-10-18 10:02:55 +02:00
Arne	32e47d0a8f	Fixed launch error with multiple robots	2019-10-16 22:32:53 +02:00
Arne	f0dd89353e	Bumped version to v0.7.1	2019-10-15 09:33:32 +02:00
Arne	d809be5b03	Fixed robot without floorplan cannot start cleaning	2019-10-14 22:33:08 +02:00
Arne	6e5b0d522c	Fixed robot not shown before setting up a floor plan	2019-10-14 12:47:52 +02:00
Arne	9af5fe8a26	Bumped version to v0.7.0	2019-10-12 11:29:10 +02:00
Arne	61b66444ac	Fixed missing callback when sending to another room	2019-10-12 11:28:09 +02:00
Arne	7197d78f33	Fixed a bug in spot cleaning	2019-10-11 12:17:24 +02:00
Arne	fa25b0d6a5	Bumped version to v0.7.0-beta.10	2019-09-26 09:08:35 +02:00
Arne	b7c2f82173	Bumped version to v0.7.8-beta.9	2019-09-26 08:59:35 +02:00
Arne	09e19d38cf	Refactored zone cleaning and improved debugging	2019-09-26 08:59:17 +02:00
Arne	500ae64e0f	Renamed hidden config option (backwards compatible)	2019-09-25 09:57:23 +02:00
Arne	12dd6d4676	Renamed spot repeat button	2019-09-24 20:32:09 +02:00
Arne	5402123340	Bumped version to v0.7.0-beta.8 and enabled find me	2019-09-24 20:09:16 +02:00
Arne	e75686e665	Bumped version to v0.7.0-beta.7	2019-09-24 20:06:20 +02:00
Arne	bef37d88c8	Fixed a bug that crashed the plugin on devices with zone cleaning Fixed a bug in the update cache timing	2019-09-24 20:06:04 +02:00
Arne	af54046927	Fixed a bug that caused the cleaning of all rooms at once	2019-09-23 12:12:18 +02:00
Arne	1a4308ac40	Bumped version to v0.7.0-beta.6	2019-09-23 11:48:50 +02:00
Arne	46ba5e5f30	Added spot cleaning function with individual spot size (D7)	2019-09-23 11:48:35 +02:00
Arne	b8fa1db8ae	Merge pull request #23 from nicoh88/patch-1 Added support for spot cleaning, added repeat and 4x4 mode for spot cleaning	2019-09-23 09:31:33 +02:00
Arne	0e92f09079	Merge branch 'master' into patch-1	2019-09-23 09:12:25 +02:00
Arne	73bc399d64	Bumped version to v0.7.0-beta.5	2019-09-22 22:30:29 +02:00
Arne	e49b4af85a	Bumped version to v0.7.0-beta.4	2019-09-22 22:16:58 +02:00
Arne	139f415a42	Prepared find me function and fixed room cleaning exception	2019-09-22 22:16:43 +02:00
Arne	c789598019	Bumped version to v0.7.0-beta.3	2019-09-22 16:08:02 +02:00
Arne	c6def8c0fc	Fixed some issues and added more device info	2019-09-22 16:07:35 +02:00
Arne	114ff70d60	Moved update logic to platform to reduce server requests for multiple rooms	2019-09-21 23:43:44 +02:00
Arne	7594843bb3	Fixed boundary issues	2019-09-21 14:47:41 +02:00
Arne	0ac882414a	Added feature to start cleaning of a new room.	2019-09-21 14:28:31 +02:00
Arne	6a57eaa57e	Bumped version to 0.7.0-beta.0	2019-09-21 14:25:49 +02:00
Arne	8822670f9b	Fixed boundary cleaning	2019-09-19 12:10:17 +02:00
Arne	150b8973ee	Changed coffee button	2019-09-19 11:26:42 +02:00
Arne	ca2af3968c	Updated debug lib	2019-09-19 11:26:27 +02:00
Arne	6f19a189b2	Reworked room cleaning (WIP)	2019-09-19 11:25:36 +02:00
Arne	5139929bce	Formatting only	2019-09-19 09:37:16 +02:00
Arne	a3b64b7c53	Added option to buy me a coffee	2019-09-17 22:27:06 +02:00
Arne	0338580c0a	Version 0.6.3	2019-08-14 23:45:19 +02:00
Arne	54f303394e	Fixed homebridge crash when 2 zones have the same name	2019-08-14 23:43:03 +02:00
Arne	c43a666378	Fixed homebridge crash when homebridge has no internet connection or the neato servers are offline	2019-08-14 23:06:03 +02:00
Arne	20c54a02e8	Fixed homebridge crash when robot has a map without zones	2019-08-14 22:48:23 +02:00
Arne	1436e4b342	Fixed homebridge startup failed when robot does not support mapping	2019-07-31 10:05:59 +02:00
Arne	db8305bbee	Fixed homebridge startup failed when robot does not support zone cleaning	2019-07-20 22:37:27 +02:00
Arne	f795781d2a	Code cleanup	2019-07-20 22:27:16 +02:00
Arne	3cfde323a8	Added gitignore	2019-07-20 22:20:31 +02:00
Arne	4a97487400	Added contributor and bumped version to v0.6.0	2019-07-14 23:35:09 +02:00
Arne	5ea9dde49c	Merge pull request #28 from az0uz/feature/zone_cleaning Support for zone cleaning	2019-07-14 23:32:43 +02:00
Arne	8ef24c9d40	Update package.json	2019-07-10 10:27:11 +02:00
Antoine de Maleprade	979dc40ccf	fixed uuid reset when restarting homebridge, removed logs	2019-05-06 20:11:04 -07:00
Antoine de Maleprade	7d824ee0b9	Working zone cleaning, implemented multiple accesories to have a room per switch in homekit	2019-04-28 17:35:49 -07:00
Antoine de Maleprade	b87e49e12f	fix: zone services discovery	2019-04-27 22:52:49 -07:00
Antoine de Maleprade	afe7d690ef	Added zone cleaning	2019-04-27 22:06:07 -07:00
Arne	442b91c347	Versionbump to v0.5.2	2019-04-09 12:46:08 +02:00
Arne	55020c005b	Merge pull request #26 from btutal/master Add Schema for Config	2019-04-09 12:43:31 +02:00
Berkay	7c72aabb25	Add Schema for Config Add schema file for homebridge-config-ui-x and similar plugins	2019-04-08 22:26:30 +02:00
Nico Hartung	769712405a	Update README.md for new spot cleaning	2019-01-03 23:25:38 +01:00
Nico Hartung	7b70d8f076	Added support for spot cleaning, added repeat and 4x4 mode for spot cleaning Repeat and 4x4 mode are not persistent - node-botvac api not supported. After a reboot of homebridge set it to off/false - use it for spot cleaning in compination with homekit scenes or automations.	2019-01-03 23:23:14 +01:00
Arne	e1754e02ed	Fixed console log in node-botvac	2018-11-17 13:27:33 +01:00
Arne	0b864eb229	Updated readme	2018-11-14 22:42:38 +01:00
Arne	1d1fa121a4	Updated readme	2018-11-14 18:24:52 +01:00