mirror of
https://github.com/mtan93/homebridge.git
synced 2026-03-08 05:31:55 +00:00
553 lines
17 KiB
JavaScript
553 lines
17 KiB
JavaScript
// Indigo Platform Shim for HomeBridge
|
|
// Written by Mike Riccio (https://github.com/webdeck)
|
|
// Based on many of the other HomeBridge plartform modules
|
|
// See http://www.indigodomo.com/ for more info on Indigo
|
|
//
|
|
// Remember to add platform to config.json. Example:
|
|
// "platforms": [
|
|
// {
|
|
// "platform": "Indigo", // required
|
|
// "name": "Indigo", // required
|
|
// "host": "127.0.0.1", // required
|
|
// "port": "8176", // required
|
|
// "username": "username", // optional
|
|
// "password": "password" // optional
|
|
// }
|
|
// ],
|
|
//
|
|
// When you attempt to add a device, it will ask for a "PIN code".
|
|
// The default code for all HomeBridge accessories is 031-45-154.
|
|
//
|
|
|
|
var types = require("hap-nodejs/accessories/types.js");
|
|
var Characteristic = require("hap-nodejs").Characteristic;
|
|
var request = require('request');
|
|
var async = require('async');
|
|
|
|
|
|
function IndigoPlatform(log, config) {
|
|
this.log = log;
|
|
|
|
this.baseURL = "http://" + config["host"] + ":" + config["port"];
|
|
|
|
if (config["username"] && config["password"]) {
|
|
this.auth = {
|
|
'user': config["username"],
|
|
'pass': config["password"],
|
|
'sendImmediately': false
|
|
};
|
|
}
|
|
}
|
|
|
|
IndigoPlatform.prototype = {
|
|
accessories: function(callback) {
|
|
var that = this;
|
|
this.log("Discovering Indigo Devices.");
|
|
|
|
var options = {
|
|
url: this.baseURL + "/devices.json/",
|
|
method: 'GET'
|
|
};
|
|
if (this.auth) {
|
|
options['auth'] = this.auth;
|
|
}
|
|
this.foundAccessories = [];
|
|
this.callback = callback;
|
|
|
|
request(options, function(error, response, body) {
|
|
if (error) {
|
|
console.trace("Requesting Indigo devices.");
|
|
that.log(error);
|
|
return error;
|
|
}
|
|
|
|
// Cheesy hack because response may have an extra comma at the start of the array, which is invalid
|
|
var firstComma = body.indexOf(",");
|
|
if (firstComma < 10) {
|
|
body = "[" + body.substr(firstComma + 1);
|
|
}
|
|
|
|
var json = JSON.parse(body);
|
|
async.eachSeries(json, function(item, asyncCallback) {
|
|
var deviceURL = that.baseURL + item.restURL;
|
|
var deviceOptions = {
|
|
url: deviceURL,
|
|
method: 'GET'
|
|
};
|
|
if (that.auth) {
|
|
deviceOptions['auth'] = that.auth;
|
|
}
|
|
|
|
request(deviceOptions, function(deviceError, deviceResponse, deviceBody) {
|
|
if (deviceError) {
|
|
console.trace("Requesting Indigo device info: " + deviceURL + "\nError: " + deviceError + "\nResponse: " + deviceBody);
|
|
}
|
|
else {
|
|
try {
|
|
var deviceJson = JSON.parse(deviceBody);
|
|
that.log("Discovered " + deviceJson.type + ": " + deviceJson.name);
|
|
that.foundAccessories.push(
|
|
new IndigoAccessory(that.log, that.auth, deviceURL, deviceJson));
|
|
}
|
|
catch (e) {
|
|
that.log("Error parsing Indigo device info: " + deviceURL + "\nException: " + e + "\nResponse: " + deviceBody);
|
|
}
|
|
}
|
|
asyncCallback();
|
|
});
|
|
}, function(asyncError) {
|
|
// This will be called after all the requests complete
|
|
if (asyncError) {
|
|
console.trace("Requesting Indigo device info.");
|
|
that.log(asyncError);
|
|
}
|
|
|
|
that.callback(that.foundAccessories.sort(function (a,b) {
|
|
return (a.name > b.name) - (a.name < b.name);
|
|
}));
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
function IndigoAccessory(log, auth, deviceURL, json) {
|
|
this.log = log;
|
|
this.auth = auth;
|
|
this.deviceURL = deviceURL;
|
|
|
|
for (var prop in json) {
|
|
if (json.hasOwnProperty(prop)) {
|
|
this[prop] = json[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
IndigoAccessory.prototype = {
|
|
getStatus: function(callback) {
|
|
var that = this;
|
|
|
|
var options = {
|
|
url: this.deviceURL,
|
|
method: 'GET'
|
|
};
|
|
if (this.auth) {
|
|
options['auth'] = this.auth;
|
|
}
|
|
|
|
request(options, function(error, response, body) {
|
|
if (error) {
|
|
console.trace("Requesting Device Status.");
|
|
that.log(error);
|
|
}
|
|
else {
|
|
that.log("getStatus of " + that.name + ": " + body);
|
|
try {
|
|
var json = JSON.parse(body);
|
|
callback(json);
|
|
}
|
|
catch (e) {
|
|
console.trace("Requesting Device Status.");
|
|
that.log("Exception: " + e + "\nResponse: " + body);
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
updateStatus: function(params) {
|
|
var that = this;
|
|
var options = {
|
|
url: this.deviceURL + "?" + params,
|
|
method: 'PUT'
|
|
};
|
|
if (this.auth) {
|
|
options['auth'] = this.auth;
|
|
}
|
|
|
|
this.log("updateStatus of " + that.name + ": " + params);
|
|
request(options, function(error, response, body) {
|
|
if (error) {
|
|
console.trace("Updating Device Status.");
|
|
that.log(error);
|
|
return error;
|
|
}
|
|
});
|
|
},
|
|
|
|
query: function(prop, callback) {
|
|
this.getStatus(function(json) {
|
|
callback(json[prop]);
|
|
});
|
|
},
|
|
|
|
turnOn: function() {
|
|
if (this.typeSupportsOnOff) {
|
|
this.updateStatus("isOn=1");
|
|
}
|
|
},
|
|
|
|
turnOff: function() {
|
|
if (this.typeSupportsOnOff) {
|
|
this.updateStatus("isOn=0");
|
|
}
|
|
},
|
|
|
|
setBrightness: function(brightness) {
|
|
if (this.typeSupportsDim && brightness >= 0 && brightness <= 100) {
|
|
this.updateStatus("brightness=" + brightness);
|
|
}
|
|
},
|
|
|
|
setSpeedIndex: function(speedIndex) {
|
|
if (this.typeSupportsSpeedControl && speedIndex >= 0 && speedIndex <= 3) {
|
|
this.updateStatus("speedIndex=" + speedIndex);
|
|
}
|
|
},
|
|
|
|
getCurrentHeatingCooling: function(callback) {
|
|
this.getStatus(function(json) {
|
|
var mode = 0;
|
|
if (json["hvacOperatonModeIsHeat"]) {
|
|
mode = 1;
|
|
}
|
|
else if (json["hvacOperationModeIsCool"]) {
|
|
mode = 2;
|
|
}
|
|
else if (json["hvacOperationModeIsAuto"]) {
|
|
mode = 3;
|
|
}
|
|
callback(mode);
|
|
});
|
|
},
|
|
|
|
setTargetHeatingCooling: function(mode) {
|
|
if (mode == 0) {
|
|
param = "Off";
|
|
}
|
|
else if (mode == 1) {
|
|
param = "Heat";
|
|
}
|
|
else if (mode == 2) {
|
|
param = "Cool";
|
|
}
|
|
else if (mode == 3) {
|
|
param = "Auto";
|
|
}
|
|
|
|
if (param) {
|
|
this.updateStatus("hvacOperationModeIs" + param + "=true");
|
|
}
|
|
},
|
|
|
|
// Note: HomeKit wants all temperature values to be in celsius
|
|
getCurrentTemperature: function(callback) {
|
|
this.query("displayRawState", function(temperature) {
|
|
callback((temperature - 32.0) * 5.0 / 9.0);
|
|
});
|
|
},
|
|
|
|
getTargetTemperature: function(callback) {
|
|
this.getStatus(function(json) {
|
|
var temperature;
|
|
if (json["hvacOperatonModeIsHeat"]) {
|
|
temperature = json["setpointHeat"];
|
|
}
|
|
else if (json["hvacOperationModeIsCool"]) {
|
|
temperature = json["setpointCool"];
|
|
}
|
|
else {
|
|
temperature = (json["setpointHeat"] + json["setpointCool"]) / 2.0;
|
|
}
|
|
callback((temperature - 32.0) * 5.0 / 9.0);
|
|
});
|
|
},
|
|
|
|
setTargetTemperature: function(temperature) {
|
|
var that = this;
|
|
var t = (temperature * 9.0 / 5.0) + 32.0;
|
|
this.getStatus(function(json) {
|
|
if (json["hvacOperatonModeIsHeat"]) {
|
|
that.updateStatus("setpointHeat=" + t);
|
|
}
|
|
else if (json["hvacOperationModeIsCool"]) {
|
|
that.updateStatus("setpointCool=" + t);
|
|
}
|
|
else {
|
|
var cool = t + 5;
|
|
var heat = t - 5;
|
|
that.updateStatus("setpointCool=" + cool + "&setpointHeat=" + heat);
|
|
}
|
|
});
|
|
},
|
|
|
|
informationCharacteristics: function() {
|
|
return [
|
|
{
|
|
cType: types.NAME_CTYPE,
|
|
onUpdate: null,
|
|
perms: [Characteristic.Perms.READ],
|
|
format: Characteristic.Formats.STRING,
|
|
initialValue: this.name,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Name of the accessory",
|
|
designedMaxLength: 255
|
|
},{
|
|
cType: types.MANUFACTURER_CTYPE,
|
|
onUpdate: null,
|
|
perms: [Characteristic.Perms.READ],
|
|
format: Characteristic.Formats.STRING,
|
|
initialValue: "Indigo",
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Manufacturer",
|
|
designedMaxLength: 255
|
|
},{
|
|
cType: types.MODEL_CTYPE,
|
|
onUpdate: null,
|
|
perms: [Characteristic.Perms.READ],
|
|
format: Characteristic.Formats.STRING,
|
|
initialValue: this.type,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Model",
|
|
designedMaxLength: 255
|
|
},{
|
|
cType: types.SERIAL_NUMBER_CTYPE,
|
|
onUpdate: null,
|
|
perms: [Characteristic.Perms.READ],
|
|
format: Characteristic.Formats.STRING,
|
|
initialValue: this.addressStr,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "SN",
|
|
designedMaxLength: 255
|
|
},{
|
|
cType: types.IDENTIFY_CTYPE,
|
|
onUpdate: null,
|
|
perms: [Characteristic.Perms.WRITE],
|
|
format: Characteristic.Formats.BOOL,
|
|
initialValue: false,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Identify Accessory",
|
|
designedMaxLength: 1
|
|
}
|
|
]
|
|
},
|
|
|
|
controlCharacteristics: function(that) {
|
|
var hasAType = false;
|
|
|
|
var cTypes = [{
|
|
cType: types.NAME_CTYPE,
|
|
onUpdate: null,
|
|
perms: [Characteristic.Perms.READ],
|
|
format: Characteristic.Formats.STRING,
|
|
initialValue: that.name,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Name of the accessory",
|
|
designedMaxLength: 255
|
|
}];
|
|
|
|
if (that.typeSupportsDim) {
|
|
hasAType = true;
|
|
cTypes.push({
|
|
cType: types.BRIGHTNESS_CTYPE,
|
|
perms: [Characteristic.Perms.WRITE,Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
initialValue: that.brightness,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Adjust Brightness of Light",
|
|
designedMinValue: 0,
|
|
designedMaxValue: 100,
|
|
designedMinStep: 1,
|
|
unit: Characteristic.Units.PERCENTAGE,
|
|
onUpdate: function(value) {
|
|
that.setBrightness(value);
|
|
},
|
|
onRead: function(callback) {
|
|
that.query("brightness", callback);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (that.typeSupportsSpeedControl) {
|
|
hasAType = true;
|
|
cTypes.push({
|
|
cType: types.ROTATION_SPEED_CTYPE,
|
|
perms: [Characteristic.Perms.WRITE,Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
initialValue: 0,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Change the speed of the fan",
|
|
designedMaxLength: 1,
|
|
designedMinValue: 0,
|
|
designedMaxValue: 3,
|
|
designedMinStep: 1,
|
|
onUpdate: function(value) {
|
|
that.setSpeedIndex(value);
|
|
},
|
|
onRead: function(callback) {
|
|
that.query("speedIndex", callback);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (that.typeSupportsHVAC) {
|
|
hasAType = true;
|
|
cTypes.push({
|
|
cType: types.CURRENTHEATINGCOOLING_CTYPE,
|
|
perms: [Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
initialValue: 0,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Current Mode",
|
|
designedMaxLength: 1,
|
|
designedMinValue: 0,
|
|
designedMaxValue: 3,
|
|
designedMinStep: 1,
|
|
onUpdate: null,
|
|
onRead: function(callback) {
|
|
that.getCurrentHeatingCooling(callback);
|
|
}
|
|
});
|
|
|
|
cTypes.push({
|
|
cType: types.TARGETHEATINGCOOLING_CTYPE,
|
|
perms: [Characteristic.Perms.WRITE,Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
initialValue: 0,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Target Mode",
|
|
designedMaxLength: 1,
|
|
designedMinValue: 0,
|
|
designedMaxValue: 3,
|
|
designedMinStep: 1,
|
|
onUpdate: function(value) {
|
|
that.setTargetHeatingCooling(value);
|
|
},
|
|
onRead: function(callback) {
|
|
that.getCurrentHeatingCooling(callback);
|
|
}
|
|
});
|
|
|
|
cTypes.push({
|
|
cType: types.CURRENT_TEMPERATURE_CTYPE,
|
|
perms: [Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
designedMinValue: 16,
|
|
designedMaxValue: 38,
|
|
designedMinStep: 1,
|
|
initialValue: 20,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Current Temperature",
|
|
unit: Characteristic.Units.FAHRENHEIT,
|
|
onUpdate: null,
|
|
onRead: function(callback) {
|
|
that.getCurrentTemperature(callback);
|
|
}
|
|
});
|
|
|
|
cTypes.push({
|
|
cType: types.TARGET_TEMPERATURE_CTYPE,
|
|
perms: [Characteristic.Perms.WRITE,Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
designedMinValue: 16,
|
|
designedMaxValue: 38,
|
|
designedMinStep: 1,
|
|
initialValue: 20,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Target Temperature",
|
|
unit: Characteristic.Units.FAHRENHEIT,
|
|
onUpdate: function(value) {
|
|
that.setTargetTemperature(value);
|
|
},
|
|
onRead: function(callback) {
|
|
that.getTargetTemperature(callback);
|
|
}
|
|
});
|
|
|
|
cTypes.push({
|
|
cType: types.TEMPERATURE_UNITS_CTYPE,
|
|
perms: [Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.INT,
|
|
initialValue: 1,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Unit",
|
|
onUpdate: null,
|
|
onRead: function(callback) {
|
|
callback(1);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (that.typeSupportsOnOff || !hasAType) {
|
|
cTypes.push({
|
|
cType: types.POWER_STATE_CTYPE,
|
|
perms: [Characteristic.Perms.WRITE,Characteristic.Perms.READ,Characteristic.Perms.NOTIFY],
|
|
format: Characteristic.Formats.BOOL,
|
|
initialValue: (that.isOn) ? 1 : 0,
|
|
supportEvents: false,
|
|
supportBonjour: false,
|
|
manfDescription: "Change the power state",
|
|
designedMaxLength: 1,
|
|
onUpdate: function(value) {
|
|
if (value == 0) {
|
|
that.turnOff();
|
|
} else {
|
|
that.turnOn();
|
|
}
|
|
},
|
|
onRead: function(callback) {
|
|
that.query("isOn", function(isOn) {
|
|
callback((isOn) ? 1 : 0);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
return cTypes;
|
|
},
|
|
|
|
sType: function() {
|
|
if (this.typeSupportsHVAC) {
|
|
return types.THERMOSTAT_STYPE;
|
|
} else if (this.typeSupportsDim) {
|
|
return types.LIGHTBULB_STYPE;
|
|
} else if (this.typeSupportsSpeedControl) {
|
|
return types.FAN_STYPE;
|
|
} else if (this.typeSupportsOnOff) {
|
|
return types.SWITCH_STYPE;
|
|
}
|
|
|
|
return types.SWITCH_STYPE;
|
|
},
|
|
|
|
getServices: function() {
|
|
var that = this;
|
|
var services = [{
|
|
sType: types.ACCESSORY_INFORMATION_STYPE,
|
|
characteristics: that.informationCharacteristics(),
|
|
},
|
|
{
|
|
sType: that.sType(),
|
|
characteristics: that.controlCharacteristics(that)
|
|
}];
|
|
|
|
that.log("Loaded services for " + that.name);
|
|
return services;
|
|
}
|
|
};
|
|
|
|
module.exports.accessory = IndigoAccessory;
|
|
module.exports.platform = IndigoPlatform;
|