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 9451 additions and 313 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/.gitattributes
+++ b/.gitattributes
@@ -1,17 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto
-
-# Custom for Visual Studio
-*.cs     diff=csharp
-
-# Standard to msysgit
-*.doc	 diff=astextplain
-*.DOC	 diff=astextplain
-*.docx diff=astextplain
-*.DOCX diff=astextplain
-*.dot  diff=astextplain
-*.DOT  diff=astextplain
-*.pdf  diff=astextplain
-*.PDF	 diff=astextplain
-*.rtf	 diff=astextplain
-*.RTF	 diff=astextplain
--- 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
@@ -1,47 +1,120 @@
-# Windows image file caches
-Thumbs.db
-ehthumbs.db
+# Ignore compiled code
+dist

-# Folder config file
-Desktop.ini
+# ------------- Defaults ------------- #

-# Recycle Bin used on file shares
-$RECYCLE.BIN/
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*

-# Windows Installer files
-*.cab
-*.msi
-*.msm
-*.msp
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json

-# Windows shortcuts
-*.lnk
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock

-# =========================
-# Operating System Files
-# =========================
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov

-# OSX
-# =========================
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov

-.DS_Store
-.AppleDouble
-.LSOverride
+# nyc test coverage
+.nyc_output

-# Thumbnails
-._*
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt

-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
+# Bower dependency directory (https://bower.io/)
+bower_components

-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
+# 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
@@ -4,4 +4,150 @@
 * Added return to base
 * Added enable and disable schedule
 * Added enable and disable eco mode
-* Added battery info
+* Added battery info
+
+## 0.2.0
+
+* Added dock info
+* Improved logging to use a debug library
+
+## 0.2.1
+
+* Improved the go to dock command
+
+## 0.3.0
+
+* Added periodic refresh of robot state while cleaning
+* Added optional periodic refresh of robot state while not cleaning
+* Added error messages when cant login or get robot
+* Improved go to dock switch to be enabled as soon as possible without manual refresh
+* Improved switches to indicate the time an action needs to complete
+* Improved eco mode to not be overwritten by robot state update
+
+## 0.3.1
+
+* Added support for Neato BotVac D5 Connected
+
+## 0.3.2
+
+* Fixed a bug that refresh is not disabled when set to 0
+
+## 0.4.0
+
+* Added support for multiple robots
+* Added log output when user requests accessory identify
+* Changed plugin to platform instead of single accessory
+* Removed parameter name from config
+
+## 0.4.1
+
+* Added config parameter for extraCareNavigation
+
+## 0.4.2
+
+* Added config parameter to disable switches/sensors
+
+## 0.4.4
+
+* Fixed config parameter to disable switches/sensors not optional
+
+## 0.4.5
+
+* Fixed compatibility with homebridge 0.4.23 (occupancy sensor not working)
+
+## 0.4.6
+
+* Added error log while refreshing robot state
+* Fixed a rare bug where the robot stops after some seconds of cleaning
+
+## 0.4.7
+
+* Fixed an exception when no robot is associated with the account
+
+## 0.5.0
+
+* Added noGo lines button
+* Added extra care navigation button
+* Added syncing cleaning options from last run
+* Added option to disable background state update completely
+* Changed goto dock button is now always off
+* Changed error handling
+* Changed debug messages
+* Updated node-botvac dependency to 0.1.6
+* 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,40 +1,129 @@
-# 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 to control your [Neato](https://www.neatorobotics.com/) vacuum robot.
+# homebridge-kobold

-# Installation
+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).

-1. Install homebridge using: npm install -g homebridge
-2. Install this plugin using: npm install -g homebridge-neato
+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
+
+- 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
+- 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-kobold`
 3. Update your configuration file. See the sample below.

-# Configuration
+## Configuration

-Configuration sample:
+Add the following information to your config file. Adapt the value for `token`.

-Add the following information to your config file. Change the values for name, email and password.
+### Simple

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

-# Features
+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:

- Atart and pause cleaning
- Return to base
- Enable and disable schedule
- Enable and disable eco mode
- Get battery info
+```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 ====

-# Tested robots
+```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"
+}'
+```

- BotVac Connected Firmware 2.2.0
+From the output, you want to copy the `id_token` value.

-if you have another connected neato robot, please [tell me](https://github.com/naofireblade/homebridge-neato/issues/new) your experience with this plugin.
+The `language` can be `de` for German, `en` for English, or `fr` for French.
+
+### Advanced
+
+Below are explanations for advanced parameters to adjust the plugin to your needs. All parameters are *optional*.
+
+**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.
+
+**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": "KoboldVacuumRobot",
+    "token": "YourToken",
+    "refresh": "120",
+    "hidden": ["dock", "dockstate", "eco", "nogolines", "extracare", "schedule", "find", "spot"],
+    "language": "de"
+  }
+]
+```
+
+## Tested robots
+
+- Vorwerk Kobold VR300
--- 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,223 +0,0 @@
-"use strict";
-var inherits = require('util').inherits;
-var botvac = require('node-botvac');
-
-var Service, Characteristic;
-
-module.exports = function (homebridge) {
-	Service = homebridge.hap.Service;
-	Characteristic = homebridge.hap.Characteristic;
-	homebridge.registerAccessory("homebridge-neato", "NeatoVacuumRobot", NeatoVacuumRobot);
-}
-
-function NeatoVacuumRobot(log, config) {
-	this.log = log;
-	this.name = config['name'];
-	this.serial = "1-3-3-7";
-	this.email = config['email'];
-	this.password = config['password'];
-
-	this.lastUpdate = null;
-	this.robot = null;
-}
-
-NeatoVacuumRobot.prototype = {
-	identify: function (callback) {
-		this.log("Identify requested");
-		callback();
-	},
-
-	getServices: function () {
-		this.informationService = new Service.AccessoryInformation();
-		this.informationService
-		.setCharacteristic(Characteristic.Manufacturer, "Neato Robotics")
-		.setCharacteristic(Characteristic.Model, this.name)
-		.setCharacteristic(Characteristic.SerialNumber, this.serial);
-
-		this.vacuumRobotCleanService = new Service.Switch(this.name + " Clean", "clean");
-		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('set', this.clean.bind(this));
-		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));
-
-		this.vacuumRobotDockService = new Service.Switch(this.name + " Dock", "dock");
-		this.vacuumRobotDockService.getCharacteristic(Characteristic.On).on('set', this.dock.bind(this));
-		this.vacuumRobotDockService.getCharacteristic(Characteristic.On).on('get', this.getDock.bind(this));
-
-		this.vacuumRobotEcoService = new Service.Switch(this.name + " Eco Mode", "eco");
-		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('set', this.eco.bind(this));
-		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
-
-		this.vacuumRobotScheduleService = new Service.Switch(this.name + " Schedule", "schedule");
-		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('set', this.schedule.bind(this));
-		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
-
-		this.vacuumRobotBatteryService = new Service.BatteryService("Battery", "battery");
-		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
-		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
-
-		return [this.informationService, this.vacuumRobotCleanService, this.vacuumRobotDockService, this.vacuumRobotEcoService,
-			this.vacuumRobotScheduleService, this.vacuumRobotBatteryService];
-	},
-
-	clean: function (on, callback) {
-		let that = this;
-		if (on) {
-			this.getState(function (error, result) {
-				that.log(that.robot);
-				if (that.robot.canResume === true) {
-					that.log("Resume cleaning");
-					that.robot.resumeCleaning(function (error, result) {
-						that.log(result);
-					});
-				}
-				else {
-					that.log("Start cleaning");
-					that.robot.startCleaning(that.robot.eco, function (error, result) {
-						that.log(result);
-					});
-				}
-			});
-		}
-		else {
-			this.log("Pause cleaning");
-			this.robot.pauseCleaning(false, function (error, result) {
-				that.log(result);
-			});
-		}
-		callback();
-	},
-
-	dock: function (on, callback) {
-		let that = this;
-		that.log(that.robot);
-		if (on) {
-			that.log("Send to dock");
-			that.robot.sendToBase(false, function (error, result) {
-				that.log(result);
-			});
-		}
-		callback();
-	},
-
-	eco: function (on, callback) {
-		this.log(on ? "Enable eco mode" : "Disable eco mode");
-		this.robot.eco = on;
-		callback();
-	},
-
-	schedule: function (on, callback) {
-		if (on) {
-			this.log("Enable schedule");
-			this.robot.enableSchedule(false, function (error, result) {
-				onsole.log(result);
-			}); 
-		}
-		else {
-			this.log("Disable schedule");
-			this.robot.disableSchedule(false, function (error, result) {
-				onsole.log(result);
-			}); 
-		}
-		callback();
-	},
-
-	getClean: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Is cleaning: " + that.robot.canPause);
-			callback(false, that.robot.canPause);
-		});
-	},
-
-	getDock: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Can go to dock: " + that.robot.canGoToBase);
-			that.log("Is docked: " + that.robot.isDocked);
-			callback(false, that.robot.isDocked);
-		});
-	},
-
-	getEco: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Eco mode: " + that.robot.eco);
-			callback(false, that.robot.eco);
-		});
-	},
-
-	getSchedule: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Schedule: " + that.robot.isScheduleEnabled);
-			callback(false, that.robot.isScheduleEnabled);
-		});
-	},
-
-
-	getBatteryLevel: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Battery: " + that.robot.charge);
-			callback(false, that.robot.charge);
-		});
-	},
-
-	getBatteryChargingState: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Is charging: " + that.robot.isCharging);
-			callback(false, that.robot.isCharging);
-		});
-	},
-
-	getState: function(callback) {
-		let that = this;
-		if (this.robot === null)
-		{
-			this.getRobot(function (error, result) {
-				that._getState(callback);
-			});
-		}
-		else {
-			that._getState(callback);
-		}	
-	},
-
-	_getState: function(callback) {
-		if (this.lastUpdate !== null && new Date() - this.lastUpdate < 2000) {
-			//this.log("Get state (cached)");
-			callback();
-		}
-		else {
-			//this.log("Get state (new)");
-			let that = this;
-			this.robot.getState(function (error, result) {
-				that.lastUpdate = new Date();
-				callback();
-			});
-		}
-	},
-
-	getRobot: function(callback) {
-		//this.log("Get robot");
-		let client = new botvac.Client();
-		let that = this;
-		client.authorize(this.email, this.password, false, function (error) {
-			if (error) {
-				that.log(error);
-			}
-			else {
-				client.getRobots(function (error, robots) {
-					if (error) {
-						that.log(error);
-					}
-					else {
-						that.robot = robots[0];
-						that.log("Found robot: " + that.robot.name);
-						callback();
-					}
-				});
-			}
-		});
-	}
-}
--- 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,23 +1,55 @@
 {
-  "name": "homebridge-neato",
-  "version": "0.1.0",
-  "description": "control your neato vacuum robot",
+  "name": "homebridge-kobold",
+  "version": "1.0.0",
+  "description": "A Vorwerk Kobold vacuum robot plugin for homebridge.",
  "license": "MIT",
  "keywords": [
-    "homebridge-plugin"
+    "homebridge-plugin",
+    "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.4"
+    "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
Arne	6c6bb1c204	Updated readme and changelog	2018-11-14 18:22:27 +01:00
Arne	577e62ea32	Improved refresh interval	2018-11-13 21:47:39 +01:00
Arne	fbec31602f	NoGo Lines and options sync ADDED - NoGo lines button - Extra care navigation button - Syncing cleaning options from last run CHANGED - Goto dock button is now always off - Better error handling - More detailed debug messages - Updated node-botvac dependency to 0.1.6 REMOVED - Extra care navigation option parameter (is now a button)	2018-11-11 15:53:50 +01:00
naofireblade	42fa0399f8	Version 0.4.7 * Fixed an exception when no robot is associated with the account	2018-03-26 19:14:54 +02:00
Arne	0de549dd41	Merge pull request #12 from ghulands/fix_no_robots Set an empty array if there are no robots on the account	2018-03-25 22:01:32 +02:00
Greg Hulands	7fef07df0a	Set an empty array if there are no robots on the account	2018-03-24 22:54:12 -07:00
Arne	9e9dd80547	Added badges	2018-02-08 12:14:48 +01:00
Arne	b7ec93953e	Updated list of supported robots	2018-01-11 08:01:18 +01:00
naofireblade	ad41c1679d	Version 0.4.6 * Added error log while refreshing robot state * Fixed a rare bug where the robot stops after some seconds of cleaning	2017-12-10 13:14:12 +01:00
naofireblade	89f6f233a5	Added errorlog while refreshing robot state	2017-10-15 19:34:02 +02:00
naofireblade	88f217e2b1	Version 0.4.5 * Fixed compatibility with homebridge 0.4.23 (occupancy sensor not working)	2017-09-04 00:13:44 +02:00
naofireblade	2fec762498	Version 0.4.4 * Fixed config parameter to disable switches/sensors not optional	2017-07-25 08:54:52 +02:00
naofireblade	857af55e99	Version 0.4.3 * Fixed config parameter to disable switches/sensors not optional	2017-07-25 08:52:17 +02:00
naofireblade	20e0a9b909	Version 0.4.2 * Added config parameter to disable switches/sensors	2017-07-24 19:52:32 +02:00
Arne	afdff765b0	Wording	2017-06-07 10:51:14 +02:00
Arne	dcef6653ff	Wording	2017-06-07 10:50:44 +02:00
Arne	82bf19c548	Wording	2017-06-07 10:48:46 +02:00
Arne	1084bff0ee	Wording	2017-06-07 10:48:11 +02:00
Arne	5aa66835dd	Wording	2017-06-07 10:47:01 +02:00
naofireblade	08ef90f7b0	Version 0.4.1 * Added config parameter for extraCareNavigation	2017-06-06 17:25:02 +02:00
naofireblade	bfb03b5d5d	Version 0.4.0 * Added support for multiple robots * Added log output when user requests accessory identify * Changed plugin to platform instead of single accessory * Removed parameter name from config	2017-06-05 16:46:45 +02:00
naofireblade	56e85c92e0	Wording and Bugfixes * Fixed a bug that refresh is not disabled when set to 0	2017-05-20 19:41:25 +02:00
naofireblade	d6dd94979b	Offical support for D5 Connected	2017-05-20 13:34:21 +02:00
naofireblade	6deca89d27	Updated dependencies	2017-05-18 19:14:59 +02:00
naofireblade	5eb5b9934d	Support for basic-2 services	2017-05-18 18:59:14 +02:00
naofireblade	9a5c3f942c	Error Handling	2017-05-13 21:17:46 +02:00
naofireblade	8f6f3dc72d	Wording	2017-05-13 21:15:13 +02:00
naofireblade	0f8fb1dedf	Wording	2017-05-07 17:20:54 +02:00
naofireblade	e01fb8df28	Bugfixes and changes in periodic refresh * periodic refresh is now optional (minimum 60s) * refresh while cleaning is now 30s * fixed a bug where the robot starts to drive home after some minutes of cleaning	2017-05-07 16:31:41 +02:00
naofireblade	8cb6ecf8a5	Improved refresh parameter	2017-05-06 23:57:36 +02:00
naofireblade	36e8496108	Version 0.3.0 * Added periodic refresh of robot state * Improved go to dock switch to be enabled as soon as possible without manual refresh * Improved switches to indicate the time an action lasts * Improved eco mode to not be overwritten by robot state	2017-05-06 23:51:58 +02:00
naofireblade	b2ddecc827	Improved go to dock command	2017-05-04 19:24:38 +02:00
naofireblade	5dbdb18c58	Set theme jekyll-theme-cayman	2017-04-30 18:07:17 +02:00
naofireblade	d49cab1e97	Set theme jekyll-theme-cayman	2017-04-30 18:06:45 +02:00
naofireblade	92eabfe5cd	Wording	2017-04-30 14:35:23 +02:00
naofireblade	67b930653f	Wording	2017-04-30 14:17:21 +02:00
naofireblade	579bd32a93	Readme	2017-04-28 18:12:22 +02:00
naofireblade	a606d4c632	Version 0.2.0 * Added dock info * Changed logging to debug library	2017-04-22 22:57:09 +02:00
naofireblade	3a4327f7e9	spelling	2017-04-18 02:59:07 +02:00
naofireblade	cbfbb26b14	spelling	2017-04-18 02:51:59 +02:00