672 lines
19 KiB
TypeScript
672 lines
19 KiB
TypeScript
import {CharacteristicValue, Logger, PlatformAccessory, PlatformAccessoryEvent, PlatformConfig, Service} from 'homebridge';
|
|
import {HomebridgeNeatoPlatform} from '../homebridgeNeatoPlatform';
|
|
import spotRepeat from '../characteristics/spotRepeat';
|
|
import spotWidth from '../characteristics/spotWidth';
|
|
import spotHeight from '../characteristics/spotHeight';
|
|
import {Options} from '../models/options';
|
|
import {CharacteristicGetHandler, CharacteristicSetHandler} from "hap-nodejs/dist/lib/Characteristic";
|
|
|
|
/**
|
|
* 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 NeatoVacuumRobotAccessory
|
|
{
|
|
// Homebridge
|
|
private log: Logger;
|
|
private batteryService: Service;
|
|
private readonly cleanService: Service | null;
|
|
private readonly findMeService: Service | null;
|
|
private readonly goToDockService: Service | null;
|
|
private readonly dockStateService: Service | null;
|
|
private readonly binFullService: Service | null;
|
|
private readonly ecoService: Service | null;
|
|
private readonly noGoLinesService: Service | null;
|
|
private readonly extraCareService: Service | null;
|
|
private readonly scheduleService: Service | null;
|
|
private readonly spotCleanService: Service | null;
|
|
private spotPlusFeatures: boolean;
|
|
|
|
// Context
|
|
private robot: any;
|
|
private readonly options: Options;
|
|
|
|
// Config
|
|
private readonly backgroundUpdateInterval: number;
|
|
private readonly prefix: boolean;
|
|
private readonly availableServices: string[];
|
|
|
|
// 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: HomebridgeNeatoPlatform,
|
|
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 = NeatoVacuumRobotAccessory.parseBackgroundUpdateInterval(this.config['backgroundUpdate']);
|
|
this.prefix = this.config['prefix'] || PREFIX;
|
|
this.availableServices = this.config['services'] || SERVICES;
|
|
|
|
this.isSpotCleaning = false;
|
|
|
|
// Information
|
|
this.accessory.getService(this.platform.Service.AccessoryInformation)!
|
|
.setCharacteristic(this.platform.Characteristic.Manufacturer, "Neato Robotics")
|
|
.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));
|
|
});
|
|
});
|
|
|
|
// Services
|
|
this.cleanService = this.getSwitchService(RobotService.CLEAN_HOUSE, this.getCleanHouse.bind(this), this.setCleanHouse.bind(this));
|
|
this.spotCleanService = this.getSwitchService(RobotService.CLEAN_SPOT, this.getSpotClean.bind(this), this.setSpotClean.bind(this));
|
|
this.goToDockService = this.getSwitchService(RobotService.GO_TO_DOCK, this.getGoToDock.bind(this), this.setGoToDock.bind(this));
|
|
this.dockStateService = this.getOccupancyService(RobotService.DOCKED, this.getDocked.bind(this))
|
|
this.binFullService = this.getOccupancyService(RobotService.BIN_FULL, this.getBinFull.bind(this))
|
|
this.findMeService = this.getSwitchService(RobotService.FIND_ME, this.getFindMe.bind(this), this.setFindMe.bind(this));
|
|
this.scheduleService = this.getSwitchService(RobotService.SCHEDULE, this.getSchedule.bind(this), this.setSchedule.bind(this));
|
|
this.ecoService = this.getSwitchService(RobotService.ECO, this.getEco.bind(this), this.setEco.bind(this));
|
|
this.noGoLinesService = this.getSwitchService(RobotService.NOGO_LINES, this.getNoGoLines.bind(this), this.setNoGoLines.bind(this));
|
|
this.extraCareService = this.getSwitchService(RobotService.EXTRA_CARE, this.getExtraCare.bind(this), this.setExtraCare.bind(this));
|
|
this.batteryService = this.accessory.getService(this.platform.Service.Battery) || this.accessory.addService(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 != null && !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 getSwitchService(serviceName: string, getHandler: CharacteristicGetHandler, setHandler: CharacteristicSetHandler)
|
|
{
|
|
let displayName = this.prefix ? this.robot.name + serviceName : serviceName;
|
|
if (this.availableServices.includes(serviceName))
|
|
{
|
|
let service = this.accessory.getService(displayName) || this.accessory.addService(this.platform.Service.Switch, displayName, serviceName);
|
|
service.getCharacteristic(this.platform.Characteristic.On)
|
|
.onGet(getHandler)
|
|
.onSet(setHandler);
|
|
return service;
|
|
}
|
|
else
|
|
{
|
|
if (this.accessory.getService(displayName))
|
|
{
|
|
this.accessory.removeService(<Service>this.accessory.getService(displayName));
|
|
}
|
|
return null
|
|
}
|
|
}
|
|
|
|
private getOccupancyService(serviceName: string, getHandler: CharacteristicGetHandler)
|
|
{
|
|
let displayName = this.prefix ? this.robot.name + serviceName : serviceName;
|
|
|
|
if (this.availableServices.includes(serviceName))
|
|
{
|
|
let service = this.accessory.getService(displayName) || this.accessory.addService(this.platform.Service.OccupancySensor, displayName, serviceName);
|
|
service.getCharacteristic(this.platform.Characteristic.OccupancyDetected.OccupancyDetected)
|
|
.onGet(getHandler);
|
|
return service;
|
|
}
|
|
else
|
|
{
|
|
if (this.accessory.getService(displayName))
|
|
{
|
|
this.accessory.removeService(<Service>this.accessory.getService(displayName));
|
|
}
|
|
return null
|
|
}
|
|
}
|
|
|
|
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 getCleanHouse(): 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 setCleanHouse(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.getCleanHouse());
|
|
}
|
|
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 CleanType
|
|
{
|
|
ALL,
|
|
SPOT
|
|
}
|
|
|
|
enum DebugType
|
|
{
|
|
ACTION,
|
|
STATUS,
|
|
INFO
|
|
}
|
|
|
|
enum RobotService
|
|
{
|
|
CLEAN_HOUSE = "Clean house",
|
|
CLEAN_SPOT = "Clean spot",
|
|
GO_TO_DOCK = "Go to dock",
|
|
DOCKED = "Docked sensor",
|
|
BIN_FULL = "Bin full sensor",
|
|
FIND_ME = "Find me",
|
|
SCHEDULE = "Schedule",
|
|
ECO = "Eco",
|
|
NOGO_LINES = "Nogo lines",
|
|
EXTRA_CARE = "Extra care"
|
|
}
|
|
|
|
const BACKGROUND_INTERVAL = 30;
|
|
const PREFIX = false;
|
|
const SERVICES = Object.values(RobotService); |