Fixed boundary issues

CHANGELOG.md

@@ -94,4 +94,16 @@
 
 ## 0.6.2
 
-* Fixed homebridge startup failed when robot does not support mapping
+* 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
+
+* Fixed room switches not taking eco and extraCare mode into account
+* Fixed room switches to support pause/resume of cleaning
+* Added feature that enabling another room switch, returns to robot to dock and starts cleaning the new room automatically

README.md

@@ -5,6 +5,10 @@
 
 This is a plugin for [homebridge](https://github.com/nfarina/homebridge) to control your [Neato](https://www.neatorobotics.com/) vacuum robot. You can download it via [npm](https://www.npmjs.com/package/homebridge-neato).
 
+If you like this plugin, I would be very grateful for your support:
+
+<a href="https://www.buymeacoffee.com/2D1nUuK36" target="_blank"><img width="140" src="https://bmc-cdn.nyc3.digitaloceanspaces.com/BMC-button-images/custom_images/orange_img.png" alt="Buy Me A Coffee"></a>
+
 Feel free to leave any feedback [here](https://github.com/naofireblade/homebridge-neato/issues).
 
 ## Features
@@ -77,4 +81,5 @@ The plugin should work with D4 and D6 as well. If you have connected neato robot
 Many thanks go to
 - [ghulands](https://github.com/ghulands) for finding and fixing a bug when no robot is associated with the neato account
 - [Berkay](https://github.com/btutal) for adding the schema file to use the plugin with homebridge-config-ui-x
-- [Antoine de Maleprade](https://github.com/az0uz) for adding the zone cleaning feature
+- [Antoine de Maleprade](https://github.com/az0uz) for adding the zone cleaning feature
+- [DJay](https://github.com/DJay-X) for testing new beta versions

accessories/neatVacuumRobot.js

@@ -0,0 +1,570 @@
+const debug = require('debug')('homebridge-neato');
+
+let Service,
+	Characteristic;
+
+module.exports = function (_Service, _Characteristic)
+{
+	Service = _Service;
+	Characteristic = _Characteristic;
+
+	return NeatoVacuumRobotAccessory;
+};
+
+function NeatoVacuumRobotAccessory(robot, platform, boundary = undefined)
+{
+	this.platform = platform;
+	this.boundary = boundary;
+	this.log = platform.log;
+	this.refresh = platform.refresh;
+	this.hiddenServices = platform.hiddenServices;
+	this.robot = robot;
+	this.nextRoom = null;
+
+	if (typeof boundary === 'undefined')
+	{
+		this.name = 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.lastUpdate = null;
+
+	this.vacuumRobotBatteryService = new Service.BatteryService("Battery", "battery");
+
+	if (typeof boundary === 'undefined')
+	{
+		this.vacuumRobotCleanService = new Service.Switch("Clean", "clean");
+		this.vacuumRobotGoToDockService = new Service.Switch(this.name + " Go to Dock", "goToDock");
+		this.vacuumRobotDockStateService = new Service.OccupancySensor(this.name + " Dock", "dockState");
+		this.vacuumRobotEcoService = new Service.Switch(this.name + " Eco Mode", "eco");
+		this.vacuumRobotNoGoLinesService = new Service.Switch(this.name + " NoGo Lines", "noGoLines");
+		this.vacuumRobotExtraCareService = new Service.Switch(this.name + " Extra Care", "extraCare");
+		this.vacuumRobotScheduleService = new Service.Switch(this.name + " Schedule", "schedule");
+	}
+	else
+	{
+		const splitName = boundary.name.split(' ');
+		let serviceName = "Clean the " + boundary.name;
+		if (splitName.length >= 2 && splitName[splitName.length - 2].match(/[']s$/g))
+		{
+			serviceName = "Clean " + boundary.name;
+		}
+		this.vacuumRobotCleanBoundaryService =
+			new Service.Switch(serviceName, "cleanBoundary:" + boundary.id);
+		this.log("Adding zone cleaning for: " + boundary.name);
+	}
+
+	this.updateRobotTimer();
+}
+
+NeatoVacuumRobotAccessory.prototype = {
+	identify: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			// hide serial and secret in log
+			let _serial = that.robot._serial;
+			let _secret = that.robot._secret;
+			that.robot._serial = "*****";
+			that.robot._secret = "*****";
+			that.log(that.robot);
+			that.robot._serial = _serial;
+			that.robot._secret = _secret;
+		});
+	},
+
+	getServices: function ()
+	{
+		this.informationService = new Service.AccessoryInformation();
+		this.informationService
+		.setCharacteristic(Characteristic.Manufacturer, "Neato Robotics")
+		.setCharacteristic(Characteristic.Model, "Coming soon")
+		.setCharacteristic(Characteristic.SerialNumber, this.robot._serial);
+		if (typeof this.boundary === "undefined")
+		{
+			this.informationService
+			.setCharacteristic(Characteristic.Name, this.robot.name)
+		}
+		else
+		{
+			this.informationService
+			.setCharacteristic(Characteristic.Name, this.robot.name + ' - ' + this.boundary.name)
+		}
+
+		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
+		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
+
+		this.services = [this.informationService, this.vacuumRobotBatteryService];
+
+		if (typeof this.boundary === "undefined")
+		{
+			this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('set', (on, serviceCallback) =>
+			{
+				this.setClean(on, serviceCallback, this.boundary)
+			});
+			this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('get', (serviceCallback) =>
+			{
+				this.getClean(serviceCallback, this.boundary);
+			});
+
+			this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('set', this.setGoToDock.bind(this));
+			this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('get', this.getGoToDock.bind(this));
+
+			this.vacuumRobotDockStateService.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getDock.bind(this));
+
+			this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('set', this.setEco.bind(this));
+			this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
+
+			this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('set', this.setNoGoLines.bind(this));
+			this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('get', this.getNoGoLines.bind(this));
+
+			this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('set', this.setExtraCare.bind(this));
+			this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('get', this.getExtraCare.bind(this));
+
+			this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('set', this.setSchedule.bind(this));
+			this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
+
+			this.services.push(this.vacuumRobotCleanService);
+
+			if (this.hiddenServices.indexOf('dock') === -1)
+				this.services.push(this.vacuumRobotGoToDockService);
+			if (this.hiddenServices.indexOf('dockstate') === -1)
+				this.services.push(this.vacuumRobotDockStateService);
+			if (this.hiddenServices.indexOf('eco') === -1)
+				this.services.push(this.vacuumRobotEcoService);
+			if (this.hiddenServices.indexOf('nogolines') === -1)
+				this.services.push(this.vacuumRobotNoGoLinesService);
+			if (this.hiddenServices.indexOf('extracare') === -1)
+				this.services.push(this.vacuumRobotExtraCareService);
+			if (this.hiddenServices.indexOf('schedule') === -1)
+				this.services.push(this.vacuumRobotScheduleService);
+		}
+		else
+		{
+			this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).on('set', (on, serviceCallback) =>
+			{
+				this.setClean(on, serviceCallback, this.boundary)
+			});
+			this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).on('get', (serviceCallback) =>
+			{
+				this.getClean(serviceCallback, this.boundary);
+			});
+			this.services.push(this.vacuumRobotCleanBoundaryService);
+		}
+
+		return this.services;
+	},
+
+
+	getClean: function (callback, boundary)
+	{
+		this.updateRobot((error, result) =>
+		{
+			let cleaning;
+			if (typeof boundary === 'undefined')
+			{
+				cleaning = this.robot.canPause;
+			}
+			else
+			{
+				cleaning = this.robot.canPause && (this.robot.cleaningBoundaryId === boundary.id)
+			}
+
+			debug(this.name + ": Cleaning is " + (cleaning ? 'ON' : 'OFF'));
+			callback(false, cleaning);
+		});
+	},
+
+	setClean: function (on, callback, boundary)
+	{
+		this.updateRobot((error, result) =>
+		{
+			// Start
+			if (on)
+			{
+				debug(typeof boundary);
+				debug(boundary);
+				// No room given or same room
+				if (typeof boundary === 'undefined' || this.robot.cleaningBoundaryId === boundary.id)
+				{
+					// Resume cleaning
+					if (this.robot.canResume)
+					{
+						debug(this.name + ": Resume cleaning");
+						this.robot.resumeCleaning(callback);
+					}
+					// Start cleaning
+					else if (this.robot.canStart)
+					{
+						this.clean(callback, boundary);
+					}
+					// Cannot start
+					else
+					{
+						debug(this.name + ": Cannot start, maybe already cleaning");
+						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 = boundary;
+
+							setTimeout(() =>
+							{
+								this.clean(callback, boundary);
+							}, 1000);
+						});
+					}
+					// Start new cleaning of new room
+					else
+					{
+						this.clean(callback, boundary);
+					}
+				}
+			}
+			// Stop
+			else
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": Pause cleaning");
+					this.robot.pauseCleaning(callback);
+				}
+				else
+				{
+					debug(this.name + ": Already paused");
+					callback();
+				}
+			}
+		});
+	},
+
+	clean: function (callback, boundary)
+	{
+		// Start automatic update while cleaning
+		if (this.refresh === 'auto')
+		{
+			setTimeout(() =>
+			{
+				clearTimeout(this.timer);
+				this.updateRobotTimer();
+			}, 60 * 1000);
+		}
+
+
+		let eco = this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).value;
+		let extraCare = this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).value;
+		let nogoLines = this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).value;
+		let room = (typeof boundary === 'undefined') ? '' : boundary.name;
+		debug(this.name + ": Start cleaning (" + room + " eco: " + eco + ", extraCare: " + extraCare + ", nogoLines: " + nogoLines + ")");
+
+		// Normal cleaning
+		if (typeof boundary === 'undefined')
+		{
+			this.robot.startCleaning(
+				eco,
+				extraCare ? 2 : 1,
+				nogoLines,
+				(error, result) =>
+				{
+					if (error)
+					{
+						this.log.error("Cannot start cleaning. " + error + ": " + JSON.stringify(result));
+						callback(true);
+					}
+					else
+					{
+						callback();
+					}
+				});
+		}
+		// Room cleaning
+		else
+		{
+			this.robot.startCleaningBoundary(eco, extraCare, boundary.id, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start room cleaning. " + error + ": " + JSON.stringify(result));
+					callback(true);
+				}
+				else
+				{
+					callback();
+				}
+			});
+		}
+	},
+
+	getGoToDock: function (callback)
+	{
+		callback(false, false);
+	},
+
+	setGoToDock: function (on, callback)
+	{
+		let that = this;
+		this.updateRobot(function (error, result)
+		{
+			if (on)
+			{
+				if (that.robot.canPause)
+				{
+					debug(that.name + ": Pause cleaning to go to dock");
+					that.robot.pauseCleaning(function (error, result)
+					{
+						setTimeout(function ()
+						{
+							debug(that.name + ": Go to dock");
+							that.robot.sendToBase(callback);
+						}, 1000);
+					});
+				}
+				else if (that.robot.canGoToBase)
+				{
+					debug(that.name + ": Go to dock");
+					that.robot.sendToBase(callback);
+				}
+				else
+				{
+					that.log.warn(that.name + ": Can't go to dock at the moment");
+					callback();
+				}
+			}
+			else
+			{
+				callback();
+			}
+		});
+	},
+
+	getEco: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Eco mode is " + (that.robot.eco ? 'ON' : 'OFF'));
+			callback(false, that.robot.eco);
+		});
+	},
+
+	setEco: function (on, callback)
+	{
+		this.robot.eco = on;
+		debug(this.name + ": " + (on ? "Enabled" : "Disabled") + " Eco mode ");
+		callback();
+	},
+
+	getNoGoLines: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Nogo Lines are " + (that.robot.eco ? 'ON' : 'OFF'));
+			callback(false, that.robot.noGoLines ? 1 : 0);
+		});
+	},
+
+	setNoGoLines: function (on, callback)
+	{
+		this.robot.noGoLines = on;
+		debug(this.name + ": " + (on ? "Enabled" : "Disabled") + " Nogo lines ");
+		callback();
+	},
+
+	getExtraCare: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Extra Care Navigation is " + (that.robot.navigationMode == 2 ? 'ON' : 'OFF'));
+			callback(false, that.robot.navigationMode == 2 ? 1 : 0);
+		});
+	},
+
+	setExtraCare: function (on, callback)
+	{
+		this.robot.navigationMode = on ? 2 : 1;
+		debug(this.name + ": " + (on ? "Enabled" : "Disabled") + " Extra Care Navigation ");
+		callback();
+	},
+
+	getSchedule: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Schedule is " + (that.robot.eco ? 'ON' : 'OFF'));
+			callback(false, that.robot.isScheduleEnabled);
+		});
+	},
+
+	setSchedule: function (on, callback)
+	{
+		let that = this;
+		this.updateRobot(function (error, result)
+		{
+			if (on)
+			{
+				debug(that.name + ": Enabled Schedule");
+				that.robot.enableSchedule(callback);
+			}
+			else
+			{
+				debug(that.name + ": Disabled Schedule");
+				that.robot.disableSchedule(callback);
+			}
+		});
+	},
+
+	getDock: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Is " + (that.robot.isDocked ? '' : 'not ') + "docked");
+			callback(false, that.robot.isDocked ? 1 : 0);
+		});
+	},
+
+	getBatteryLevel: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Battery is at " + that.robot.charge + "%");
+			callback(false, that.robot.charge);
+		});
+	},
+
+	getBatteryChargingState: function (callback)
+	{
+		let that = this;
+		this.updateRobot(function ()
+		{
+			debug(that.name + ": Is " + (that.robot.isCharging ? '' : 'not ') + "charging");
+			callback(false, that.robot.isCharging);
+		});
+	},
+
+	updateRobot: function (callback)
+	{
+		let that = this;
+		if (this.lastUpdate !== null && new Date() - this.lastUpdate < 2000)
+		{
+			callback();
+		}
+		else
+		{
+			debug(this.name + ": Updating robot state");
+			this.robot.getState(function (error, result)
+			{
+				if (error)
+				{
+					that.log.error("Cannot update robot. Check if robot is online. " + error);
+				}
+				that.lastUpdate = new Date();
+				callback();
+			});
+		}
+	},
+
+	updateRobotTimer: function ()
+	{
+		this.updateRobot((error, result) =>
+		{
+
+			if (!this.boundary)
+			{
+				// only update these values if the state is different from the current one, otherwise we might accidentally start an action
+				if (this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).value !== this.robot.canPause)
+				{
+					this.vacuumRobotCleanService.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.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).value == true && this.robot.dockHasBeenSeen)
+				{
+					this.vacuumRobotGoToDockService.setCharacteristic(Characteristic.On, false);
+				}
+
+				if (this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).value !== this.robot.isScheduleEnabled)
+				{
+					this.vacuumRobotScheduleService.setCharacteristic(Characteristic.On, this.robot.isScheduleEnabled);
+				}
+
+				// no commands here, values can be updated without problems
+				this.vacuumRobotDockStateService.setCharacteristic(Characteristic.OccupancyDetected, this.robot.isDocked ? 1 : 0);
+				this.vacuumRobotEcoService.setCharacteristic(Characteristic.On, this.robot.eco);
+				this.vacuumRobotNoGoLinesService.setCharacteristic(Characteristic.On, this.robot.noGoLines);
+				this.vacuumRobotExtraCareService.setCharacteristic(Characteristic.On, this.robot.navigationMode == 2 ? true : false);
+
+			}
+			else
+			{
+				if (this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).value !== this.robot.canPause)
+				{
+					this.vacuumRobotCleanBoundaryService.setCharacteristic(Characteristic.On, this.robot.canPause);
+				}
+			}
+
+			this.vacuumRobotBatteryService.setCharacteristic(Characteristic.BatteryLevel, this.robot.charge);
+			this.vacuumRobotBatteryService.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;
+				}, this.nextRoom);
+			}
+
+			// robot is currently cleaning, refresh is set to auto or specific interval -> continue updating
+			if (this.robot.canPause && this.refresh !== 0)
+			{
+				let refreshTime = this.refresh === 'auto' ? 60 : this.refresh;
+				debug(this.name + ": Updating state in background every " + refreshTime + " seconds while cleaning");
+				this.timer = setTimeout(this.updateRobotTimer.bind(this), refreshTime * 1000);
+			}
+			// robot is not cleaning, but a specific refresh interval is set -> continue updating
+			else if (this.refresh !== 'auto' && this.refresh !== 0)
+			{
+				debug(this.name + ": Updating state in background every " + this.refresh + " seconds (user setting)");
+				this.timer = setTimeout(this.updateRobotTimer.bind(this), this.refresh * 1000);
+			}
+			// robot is not cleaning, no specific refresh interval is set -> stop updating
+			else
+			{
+				debug(this.name + ": Disabled Background Updates");
+			}
+		});
+	},
+};

index.js

@@ -1,523 +1,164 @@
 "use strict";
-var inherits = require('util').inherits,
-    debug = require('debug')('homebridge-neato'),
-    botvac = require('node-botvac'),
+let inherits = require('util').inherits,
+	debug = require('debug')('homebridge-neato'),
+	botvac = require('node-botvac'),
 
-    Service,
-    Characteristic;
+	Service,
+	Characteristic;
 
-module.exports = function (homebridge) {
-    Service = homebridge.hap.Service;
-    Characteristic = homebridge.hap.Characteristic;
-    homebridge.registerPlatform("homebridge-neato", "NeatoVacuumRobot", NeatoVacuumRobotPlatform);
+module.exports = function (homebridge)
+{
+	Service = homebridge.hap.Service;
+	Characteristic = homebridge.hap.Characteristic;
+	homebridge.registerPlatform("homebridge-neato", "NeatoVacuumRobot", NeatoVacuumRobotPlatform);
 };
 
-function NeatoVacuumRobotPlatform(log, config) {
-    this.log = log;
-    this.serial = "1-3-3-7";
-    this.email = config['email'];
-    this.password = config['password'];
-    this.hiddenServices = ('disabled' in config ? config['disabled'] : '');
+function NeatoVacuumRobotPlatform(log, config)
+{
+	this.log = log;
+	this.serial = "1-3-3-7";
+	this.email = config['email'];
+	this.password = config['password'];
+	this.hiddenServices = ('disabled' in config ? config['disabled'] : '');
 
-    if ('refresh' in config && config['refresh'] !== 'auto') {
-        // parse config parameter
-        this.refresh = parseInt(config['refresh']);
-        // must be integer and positive
-        this.refresh = (typeof this.refresh !== 'number' || (this.refresh % 1) !== 0 || this.refresh < 0) ? 60 : this.refresh;
-        // minimum 60s to save some load on the neato servers
-        this.refresh = (this.refresh > 0 && this.refresh < 60) ? 60 : this.refresh;
-    }
-    // default auto
-    else {
-        this.refresh = 'auto';
-    }
-    debug("Refresh is set to: " + this.refresh);
+	if ('refresh' in config && config['refresh'] !== 'auto')
+	{
+		// parse config parameter
+		this.refresh = parseInt(config['refresh']);
+		// must be integer and positive
+		this.refresh = (typeof this.refresh !== 'number' || (this.refresh % 1) !== 0 || this.refresh < 0) ? 60 : this.refresh;
+		// minimum 60s to save some load on the neato servers
+		this.refresh = (this.refresh > 0 && this.refresh < 60) ? 60 : this.refresh;
+	}
+	// default auto
+	else
+	{
+		this.refresh = 'auto';
+	}
+	debug("Refresh is set to: " + this.refresh);
 }
 
 NeatoVacuumRobotPlatform.prototype = {
-    accessories: function (callback) {
-        let accessories = [];
+	accessories: function (callback)
+	{
+		let accessories = [];
+		let platform = this;
+		platform.boundaryNames = [];
+		this.getRobots(function ()
+		{
+			if (platform.robots)
+			{
+				platform.robots.forEach((robot, i) =>
+				{
+					platform.log("Found robot #" + (i + 1) + " named \"" + robot.name + "\" with serial \"" + robot._serial + "\"");
 
-        let that = this;
-        this.getRobots(function () {
-            for (let i = 0; i < that.robots.length; i++) {
-                that.log("Found robot #" + (i + 1) + " named \"" + that.robots[i].name + "\" with serial \"" + that.robots[i]._serial + "\"");
-                let robotAccessory = new NeatoVacuumRobotAccessory(that.robots[i], that);
-                accessories.push(robotAccessory);
-                if (that.robots[i].maps && that.robots[i].maps.length > 0)
-                {
-                    that.robots[i].maps.forEach((map) => {
-                        map.boundaries.forEach((boundary) => {
-                            if (boundary.type === "polygon") {
-                                accessories.push(new NeatoVacuumRobotAccessory(that.robots[i], that, boundary))
-                            }
-                        })
-                    })
-                }
-            }
-            callback(accessories);
-        });
-    },
+					let NeatoVacuumRobotAccessory = require('./accessories/neatVacuumRobot')(Service, Characteristic);
+					let robotAccessory = new NeatoVacuumRobotAccessory(robot, platform);
+					accessories.push(robotAccessory);
 
-    getRobots: function (callback) {
-        debug("Loading your robots");
-        let client = new botvac.Client();
-        let that = this;
-        client.authorize(this.email, this.password, false, (error) => {
-            if (error) {
-                that.log(error);
-                that.log.error("Can't log on to neato cloud. Please check your credentials.");
-                callback();
-            } else {
-                client.getRobots((error, robots) => {
-                    if (error) {
-                        that.log(error);
-                        that.log.error("Successful login but can't connect to your neato robot.");
-                        callback();
-                    } else {
-                        if (robots.length === 0) {
-                            that.log.error("Successful login but no robots associated with your account.");
-                            that.robots = [];
-                            callback();
-                        } else {
-                            debug("Found " + robots.length + " robots");
-                            let updatedRobotCount = 0;
-                            that.robots = robots;
-                            that.robots.forEach((robot) => {
-                                robot.getPersistentMaps((error, result) => {
-                                    if (error) {
-                                        that.log("Error updating persistent maps: " + error + ": " + result);
-                                        callback();
-                                        return;
-                                    }
-                                    robot.maps = result;
-                                    let processedMapCount = 0;
-                                    if (robot.maps.length === 0)
-                                    {
-                                        callback();
-                                    }
-                                    robot.maps.forEach((map) => {
-                                        robot.getMapBoundaries(map.id, (error, result) => {
-                                            if (error) {
-                                                this.log("error getting boundaries: " + error + ": " + result)
-                                            } else {
-                                                map.boundaries = result.boundaries;
-                                            }
-                                            processedMapCount++;
-                                            if (processedMapCount == robot.maps.length) {
-                                                updatedRobotCount++;
-                                                if (updatedRobotCount === that.robots.length) {
-                                                    callback();
-                                                }
-                                            }
-                                        })
-                                    })
-                                })
-                            })
-                        }
-                    }
-                });
-            }
-        });
-    }
-};
+					if (robot.maps)
+					{
+						robot.maps.forEach((map) =>
+						{
+							if (map.boundaries)
+							{
+								map.boundaries.forEach((boundary) =>
+								{
+									if (boundary.type === "polygon")
+									{
+										accessories.push(new NeatoVacuumRobotAccessory(robot, platform, boundary))
+									}
+								})
+							}
+						})
+					}
+				})
+			}
+			callback(accessories);
+		});
+	},
 
-function NeatoVacuumRobotAccessory(robot, platform, boundary) {
-    this.platform = platform;
-    this.boundary = boundary;
-    this.log = platform.log;
-    this.refresh = platform.refresh;
-    this.hiddenServices = platform.hiddenServices;
-    this.robot = robot;
-    if (!this.boundary) {
-        this.name = robot.name;
-    } else {
-        this.name = this.robot.name + ' - ' + this.boundary.name;
-    }
-    this.lastUpdate = null;
-
-    this.vacuumRobotBatteryService = new Service.BatteryService("Battery", "battery");
-
-    if (!this.boundary) {
-        this.vacuumRobotCleanService = new Service.Switch("Clean", "clean");
-        this.vacuumRobotGoToDockService = new Service.Switch(this.name + " Go to Dock", "goToDock");
-        this.vacuumRobotDockStateService = new Service.OccupancySensor(this.name + " Dock", "dockState");
-        this.vacuumRobotEcoService = new Service.Switch(this.name + " Eco Mode", "eco");
-        this.vacuumRobotNoGoLinesService = new Service.Switch(this.name + " NoGo Lines", "noGoLines");
-        this.vacuumRobotExtraCareService = new Service.Switch(this.name + " Extra Care", "extraCare");
-        this.vacuumRobotScheduleService = new Service.Switch(this.name + " Schedule", "schedule");
-    } else {
-        const splitName = boundary.name.split(' ');
-        let serviceName = "Clean the " + boundary.name;
-        if (splitName.length >= 2 && splitName[splitName.length - 2].match(/[']s$/g)) {
-            serviceName = "Clean " + boundary.name;
-        }
-        this.vacuumRobotCleanBoundaryService =
-            new Service.Switch(serviceName, "cleanBoundary:" + boundary.id);
-        this.log("Adding zone cleaning for: " + boundary.name);
-    }
-
-    this.updateRobotTimer();
-}
-
-
-NeatoVacuumRobotAccessory.prototype = {
-    identify: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            // hide serial and secret in log
-            let _serial = that.robot._serial;
-            let _secret = that.robot._secret;
-            that.robot._serial = "*****";
-            that.robot._secret = "*****";
-            that.log(that.robot);
-            that.robot._serial = _serial;
-            that.robot._secret = _secret;
-        });
-    },
-
-    getServices: function () {
-        this.informationService = new Service.AccessoryInformation();
-        this.informationService
-            .setCharacteristic(Characteristic.Manufacturer, "Neato Robotics")
-            .setCharacteristic(Characteristic.Model, "Coming soon")
-            .setCharacteristic(Characteristic.SerialNumber, this.robot._serial);
-        if (!this.boundary) {
-            this.informationService
-                .setCharacteristic(Characteristic.Name, this.robot.name)
-        } else {
-            this.informationService
-                .setCharacteristic(Characteristic.Name, this.robot.name + ' - ' + this.boundary.name)
-        }
-
-        this.vacuumRobotBatteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
-        this.vacuumRobotBatteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
-
-        this.services = [this.informationService, this.vacuumRobotBatteryService];
-
-        if (!this.boundary) {
-            this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('set', this.setClean.bind(this));
-            this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));
-
-            this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('set', this.setGoToDock.bind(this));
-            this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('get', this.getGoToDock.bind(this));
-
-            this.vacuumRobotDockStateService.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getDock.bind(this));
-
-            this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('set', this.setEco.bind(this));
-            this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
-
-            this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('set', this.setNoGoLines.bind(this));
-            this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('get', this.getNoGoLines.bind(this));
-
-            this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('set', this.setExtraCare.bind(this));
-            this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('get', this.getExtraCare.bind(this));
-
-            this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('set', this.setSchedule.bind(this));
-            this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
-
-            this.services.push(this.vacuumRobotCleanService);
-
-            if (this.hiddenServices.indexOf('dock') === -1)
-                this.services.push(this.vacuumRobotGoToDockService);
-            if (this.hiddenServices.indexOf('dockstate') === -1)
-                this.services.push(this.vacuumRobotDockStateService);
-            if (this.hiddenServices.indexOf('eco') === -1)
-                this.services.push(this.vacuumRobotEcoService);
-            if (this.hiddenServices.indexOf('nogolines') === -1)
-                this.services.push(this.vacuumRobotNoGoLinesService);
-            if (this.hiddenServices.indexOf('extracare') === -1)
-                this.services.push(this.vacuumRobotExtraCareService);
-            if (this.hiddenServices.indexOf('schedule') === -1)
-                this.services.push(this.vacuumRobotScheduleService);
-        }
-
-        if (this.boundary) {
-            this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).on('set', (on, serviceCallback) => {
-                this.setCleanBoundary(this.boundary.id, on, serviceCallback)
-            });
-            this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).on('get', (serviceCallback) => {
-                this.getCleanBoundary(this.boundary.id, serviceCallback);
-            });
-            this.services.push(this.vacuumRobotCleanBoundaryService);
-        }
-
-        return this.services;
-    },
-
-    setCleanBoundary: function (boundaryId, on, callback) {
-        this.updateRobot((error, result) => {
-            if (on) {
-                if (this.robot.canStart) {
-                    this.log("Starting to clean: " + boundaryId);
-                    this.robot.startCleaningBoundary(this.eco, this.extraCare, boundaryId, (error, result) => {
-                        if (error) {
-                            this.log(error + ": " + JSON.stringify(result));
-                        }
-                        callback();
-                    });
-                    return
-                } else {
-                    this.log("Error, robot is already cleaning");
-                }
-            } else {
-                if (this.robot.canPause) {
-                    debug(this.name + ": Pause cleaning");
-                    this.robot.pauseCleaning(callback);
-                    return;
-                } else {
-                    debug(this.name + ": Already stopped");
-                }
-            }
-            callback();
-        });
-    },
-
-    getCleanBoundary: function (boundaryId, callback) {
-        this.updateRobot((error, result) => {
-            callback(false, this.robot.canPause && (this.robot.cleaningBoundaryId == boundaryId));
-        });
-    },
-
-    setClean: function (on, callback) {
-        let that = this;
-        this.updateRobot(function (error, result) {
-            if (on) {
-                if (that.robot.canResume || that.robot.canStart) {
-
-                    // start extra update robot timer if refresh is set to "auto"
-                    if (that.refresh === 'auto') {
-                        setTimeout(function () {
-                            clearTimeout(that.timer);
-                            that.updateRobotTimer();
-                        }, 60 * 1000);
-                    }
-
-                    if (that.robot.canResume) {
-                        debug(that.name + ": Resume cleaning");
-                        that.robot.resumeCleaning(callback);
-                    } else {
-                        let eco = that.vacuumRobotEcoService.getCharacteristic(Characteristic.On).value;
-                        let extraCare = that.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).value;
-                        let nogoLines = that.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).value;
-                        debug(that.name + ": Start cleaning (eco: " + eco + ", extraCare: " + extraCare + ", nogoLines: " + nogoLines + ")");
-                        that.robot.startCleaning(
-                            eco,
-                            extraCare ? 2 : 1,
-                            nogoLines,
-                            function (error, result) {
-                                if (error) {
-                                    that.log.error(error + ": " + result);
-                                    callback(true);
-                                } else {
-                                    callback();
-                                }
-                            });
-                    }
-                } else {
-                    debug(that.name + ": Cant start, maybe already cleaning");
-                    callback();
-                }
-            } else {
-                if (that.robot.canPause) {
-                    debug(that.name + ": Pause cleaning");
-                    that.robot.pauseCleaning(callback);
-                } else {
-                    debug(that.name + ": Already stopped");
-                    callback();
-                }
-            }
-        });
-    },
-
-    setGoToDock: function (on, callback) {
-        let that = this;
-        this.updateRobot(function (error, result) {
-            if (on) {
-                if (that.robot.canPause) {
-                    debug(that.name + ": Pause cleaning to go to dock");
-                    that.robot.pauseCleaning(function (error, result) {
-                        setTimeout(function () {
-                            debug("Go to dock");
-                            that.robot.sendToBase(callback);
-                        }, 1000);
-                    });
-                } else if (that.robot.canGoToBase) {
-                    debug(that.name + ": Go to dock");
-                    that.robot.sendToBase(callback);
-                } else {
-                    that.log.warn(that.name + ": Can't go to dock at the moment");
-                    callback();
-                }
-            } else {
-                callback();
-            }
-        });
-    },
-
-    setEco: function (on, callback) {
-        debug(this.name + ": " + (on ? "Enable eco mode" : "Disable eco mode"));
-        this.robot.eco = on;
-        callback();
-    },
-
-    setNoGoLines: function (on, callback) {
-        debug(this.name + ": " + (on ? "Enable nogo lines" : "Disable nogo lines"));
-        this.robot.noGoLines = on;
-        callback();
-    },
-
-    setExtraCare: function (on, callback) {
-        debug(this.name + ": " + (on ? "Enable extra care navigation" : "Disable extra care navigation"));
-        this.robot.navigationMode = on ? 2 : 1;
-        callback();
-    },
-
-    setSchedule: function (on, callback) {
-        let that = this;
-        this.updateRobot(function (error, result) {
-            if (on) {
-                debug(that.name + ": Enable schedule");
-                that.robot.enableSchedule(callback);
-            } else {
-                debug(that.name + ": Disable schedule");
-                that.robot.disableSchedule(callback);
-            }
-        });
-    },
-
-    getClean: function (callback) {
-        let that = this;
-        this.updateRobot(function (error, result) {
-            debug(that.name + ": Is cleaning: " + that.robot.canPause);
-            callback(false, that.robot.canPause);
-        });
-    },
-
-    getGoToDock: function (callback) {
-        callback(false, false);
-    },
-
-    getDock: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Is docked: " + that.robot.isDocked);
-            callback(false, that.robot.isDocked ? 1 : 0);
-        });
-    },
-
-    getEco: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Is eco: " + that.robot.eco);
-            callback(false, that.robot.eco);
-        });
-    },
-
-    getNoGoLines: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Is nogo lines: " + that.robot.noGoLines);
-            callback(false, that.robot.noGoLines ? 1 : 0);
-        });
-    },
-
-    getExtraCare: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Is extra care navigation: " + (that.robot.navigationMode == 2 ? true : false));
-            callback(false, that.robot.navigationMode == 2 ? 1 : 0);
-        });
-    },
-
-    getSchedule: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Is schedule: " + that.robot.isScheduleEnabled);
-            callback(false, that.robot.isScheduleEnabled);
-        });
-    },
-
-
-    getBatteryLevel: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Battery: " + that.robot.charge + "%");
-            callback(false, that.robot.charge);
-        });
-    },
-
-    getBatteryChargingState: function (callback) {
-        let that = this;
-        this.updateRobot(function () {
-            debug(that.name + ": Is charging: " + that.robot.isCharging);
-            callback(false, that.robot.isCharging);
-        });
-    },
-
-    updateRobot: function (callback) {
-        let that = this;
-        if (this.lastUpdate !== null && new Date() - this.lastUpdate < 2000) {
-            callback();
-        } else {
-            debug(this.name + ": Updating robot state");
-            this.robot.getState(function (error, result) {
-                if (error) {
-                    that.log.error(error + ": " + result);
-                }
-                that.lastUpdate = new Date();
-                callback();
-            });
-        }
-    },
-
-    updateRobotTimer: function () {
-        let that = this;
-        this.updateRobot((error, result) => {
-
-            if (!this.boundary) {
-                // only update these values if the state is different from the current one, otherwise we might accidentally start an action
-                if (that.vacuumRobotCleanService.getCharacteristic(Characteristic.On).value !== that.robot.canPause) {
-                    that.vacuumRobotCleanService.setCharacteristic(Characteristic.On, that.robot.canPause);
-                }
-
-                // dock switch is on (dock not seen before) and dock has just been seen -> turn switch off
-                if (that.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).value == true && that.robot.dockHasBeenSeen) {
-                    that.vacuumRobotGoToDockService.setCharacteristic(Characteristic.On, false);
-                }
-
-                if (that.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).value !== that.robot.isScheduleEnabled) {
-                    that.vacuumRobotScheduleService.setCharacteristic(Characteristic.On, that.robot.isScheduleEnabled);
-                }
-
-                // no commands here, values can be updated without problems
-                that.vacuumRobotDockStateService.setCharacteristic(Characteristic.OccupancyDetected, that.robot.isDocked ? 1 : 0);
-                that.vacuumRobotEcoService.setCharacteristic(Characteristic.On, that.robot.eco);
-                that.vacuumRobotNoGoLinesService.setCharacteristic(Characteristic.On, that.robot.noGoLines);
-                that.vacuumRobotExtraCareService.setCharacteristic(Characteristic.On, that.robot.navigationMode == 2 ? true : false);
-
-            } else {
-                if (this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).value !== that.robot.canPause) {
-                    this.vacuumRobotCleanBoundaryService.setCharacteristic(Characteristic.On, that.robot.canPause);
-                }
-            }
-
-            that.vacuumRobotBatteryService.setCharacteristic(Characteristic.BatteryLevel, that.robot.charge);
-            that.vacuumRobotBatteryService.setCharacteristic(Characteristic.ChargingState, that.robot.isCharging);
-
-            // robot is currently cleaning, update if refresh is set to auto or a specific interval
-            if (that.robot.canPause && that.refresh !== 0) {
-                let refreshTime = that.refresh === 'auto' ? 60 : that.refresh;
-                debug("Updating state in background every " + refreshTime + " seconds while cleaning");
-                that.timer = setTimeout(that.updateRobotTimer.bind(that), refreshTime * 1000);
-            }
-            // robot is not cleaning, but a specific refresh interval is set
-            else if (that.refresh !== 'auto' && that.refresh !== 0) {
-                debug("Updating state in background every " + that.refresh + " seconds (user setting)");
-                that.timer = setTimeout(that.updateRobotTimer.bind(that), that.refresh * 1000);
-            } else {
-                debug("Updating state in background disabled");
-            }
-        });
-    },
-};
+	getRobots: function (callback)
+	{
+		debug("Loading your robots");
+		let client = new botvac.Client();
+		let that = this;
+		client.authorize(this.email, this.password, false, (error) =>
+		{
+			if (error)
+			{
+				that.log(error);
+				that.log.error("Can't log on to neato cloud. Please check your internet connection and your credentials. Try again later if the neato servers have issues.");
+				callback();
+			}
+			else
+			{
+				client.getRobots((error, robots) =>
+				{
+					if (error)
+					{
+						that.log(error);
+						that.log.error("Successful login but can't connect to your neato robot.");
+						callback();
+					}
+					else
+					{
+						if (robots.length === 0)
+						{
+							that.log.error("Successful login but no robots associated with your account.");
+							that.robots = [];
+							callback();
+						}
+						else
+						{
+							debug("Found " + robots.length + " robots");
+							let updatedRobotCount = 0;
+							that.robots = robots;
+							that.robots.forEach((robot) =>
+							{
+								robot.getPersistentMaps((error, result) =>
+								{
+									if (error)
+									{
+										that.log("Error updating persistent maps: " + error + ": " + result);
+										callback();
+										return;
+									}
+									robot.maps = result;
+									let processedMapCount = 0;
+									if (robot.maps.length === 0)
+									{
+										callback();
+									}
+									robot.maps.forEach((map) =>
+									{
+										robot.getMapBoundaries(map.id, (error, result) =>
+										{
+											if (error)
+											{
+												this.log("error getting boundaries: " + error + ": " + result)
+											}
+											else
+											{
+												map.boundaries = result.boundaries;
+											}
+											processedMapCount++;
+											if (processedMapCount === robot.maps.length)
+											{
+												updatedRobotCount++;
+												if (updatedRobotCount === that.robots.length)
+												{
+													callback();
+												}
+											}
+										})
+									})
+								})
+							})
+						}
+					}
+				});
+			}
+		});
+	}
+};

package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-neato",
-  "version": "0.6.2",
+  "version": "0.7.0-beta.0",
   "description": "A Neato vacuum robot plugin for homebridge.",
   "license": "MIT",
   "keywords": [
@@ -35,7 +35,7 @@
     "url": "git://github.com/naofireblade/homebridge-neato.git"
   },
   "dependencies": {
-    "debug": "^2.2.0",
+    "debug": "^4.1.1",
     "node-botvac": ">=0.3.0",
     "uuid": "^3.3.2"
   }