diff --git a/accessories/MiLight.js b/accessories/MiLight.js index 85b09d6..c5ce67c 100644 --- a/accessories/MiLight.js +++ b/accessories/MiLight.js @@ -1,3 +1,53 @@ +/* + +MiLight accessory shim for Homebridge +Written by Sam Edwards (https://samedwards.ca/) + +Uses the node-milight-promise library (https://github.com/mwittig/node-milight-promise) which features some code from +applamp.nl (http://www.applamp.nl/service/applamp-api/) and uses other details from (http://www.limitlessled.com/dev/) + +Configure in config.json as follows: + +"accessories": [ + { + "accessory":"MiLight", + "name": "Lamp", + "ip_address": "255.255.255.255", + "port": 8899, + "zone": 1, + "type": "rgbw", + "delay": 30, + "repeat": 3 + } +] + +Where the parameters are: + *accessory (required): This must be "MiLight", and refers to the name of the accessory as exported from this file + *name (required): The name for this light/zone, as passed on to Homebridge and HomeKit + *ip_address (optional): The IP address of the WiFi Bridge. Default to the broadcast address of 255.255.255.255 if not specified + *port (optional): Port of the WiFi bridge. Defaults to 8899 if not specified + *zone (required): The zone to target with this accessory. "0" for all zones on the bridge, otherwise 1-4 for a specific zone + *type (required): One of either "rgbw", "rgb", or "white", depending on the type of bulb being controlled + *delay (optional): Delay between commands sent over UDP. Default 30ms + *repeat (optional): Number of times to repeat the UDP command for better reliability. Default 3 + +Tips and Tricks: + *Setting the brightness of an rgbw or a white bulb will set it to "night mode", which is dimmer than the lowest brightness setting + *White and rgb bulbs don't support absolute brightness setting, so we just send a brightness up/brightness down command depending + if we got a percentage above/below 50% respectively + *The only exception to the above is that white bulbs support a "maximum brightness" command, so we send that when we get 100% + *Implemented warmer/cooler for white lamps in a similar way to brightnes, except this time above/below 180 degrees on the colour wheel + *I welcome feedback on a better way to work the brightness/hue for white and rgb bulbs + +Troubleshooting: +The node-milight-promise library provides additional debugging output when the MILIGHT_DEBUG environmental variable is set + +TODO: + *Probably convert this module to a platform that can configure an entire bridge at once, just passing a name for each zone + *Possibly build in some sort of state logging and persistance so that we can answswer HomeKit status queries to the best of our ability + +*/ + var Service = require("HAP-NodeJS").Service; var Characteristic = require("HAP-NodeJS").Characteristic; var Milight = require('node-milight-promise').MilightController; @@ -18,57 +68,63 @@ function MiLight(log, config) { this.type = config["type"]; this.delay = config["delay"]; this.repeat = config["repeat"]; + + this.light = new Milight({ + ip: this.ip_address, + port: this.port, + delayBetweenCommands: this.delay, + commandRepeat: this.repeat + }); + } - -var light = new Milight({ - ip: this.ip_address, - port: this.port, - delayBetweenCommands: this.delay, - commandRepeat: this.repeat -}); - MiLight.prototype = { setPowerState: function(powerOn, callback) { if (powerOn) { - light.sendCommands(commands[this.type].on(this.zone)); this.log("Setting power state to on"); + this.light.sendCommands(commands[this.type].on(this.zone)); } else { - light.sendCommands(commands[this.type].off(this.zone)); this.log("Setting power state to off"); + this.light.sendCommands(commands[this.type].off(this.zone)); } callback(); }, setBrightness: function(level, callback) { - if (level <= 2 && (this.type == "rgbw" || this.type == "white")) { + if (level == 0) { + // If brightness is set to 0, turn off the lamp + this.log("Setting brightness to 0 (off)"); + this.light.sendCommands(commands[this.type].off(this.zone)); + } else if (level <= 2 && (this.type == "rgbw" || this.type == "white")) { // If setting brightness to 2 or lower, instead set night mode for lamps that support it this.log("Setting night mode", level); - light.sendCommands(commands[this.type].off(this.zone)); - // Not sure if this timing is going to work or not? It's supposed to be 100ms after the off command - light.sendCommands(commands[this.type].nightMode(this.zone)); + this.light.sendCommands(commands[this.type].off(this.zone)); + // Ensure we're pausing for 100ms between these commands as per the spec + this.light.pause(100); + this.light.sendCommands(commands[this.type].nightMode(this.zone)); + } else { this.log("Setting brightness to %s", level); // Send on command to ensure we're addressing the right bulb - light.sendCommands(commands[this.type].on(this.zone)); + this.light.sendCommands(commands[this.type].on(this.zone)); // If this is an rgbw lamp, set the absolute brightness specified if (this.type == "rgbw") { - light.sendCommands(commands.rgbw.brightness(level)); + this.light.sendCommands(commands.rgbw.brightness(level)); } else { // If this is an rgb or a white lamp, they only support brightness up and down. // Set brightness up when value is >50 and down otherwise. Not sure how well this works real-world. if (level >= 50) { if (this.type == "white" && level == 100) { // But the white lamps do have a "maximum brightness" command - light.sendCommands(commands.white.maxBright(this.zone)); + this.light.sendCommands(commands.white.maxBright(this.zone)); } else { - light.sendCommands(commands[this.type].brightUp()); + this.light.sendCommands(commands[this.type].brightUp()); } } else { - light.sendCommands(commands[this.type].brightDown()); + this.light.sendCommands(commands[this.type].brightDown()); } } } @@ -78,23 +134,25 @@ MiLight.prototype = { setHue: function(value, callback) { this.log("Setting hue to %s", value); + var hue = Array(value, 0, 0); + // Send on command to ensure we're addressing the right bulb - light.sendCommands(commands[this.type].on(this.zone)); + this.light.sendCommands(commands[this.type].on(this.zone)); if (this.type == "rgbw") { if (value == 0) { - light.sendCommands(commands.rgbw.whiteMode(this.zone)); + this.light.sendCommands(commands.rgbw.whiteMode(this.zone)); } else { - light.sendCommands(commands.rgbw.hue(commands.rgbw.hsvToMilightColor(Array(value, 0, 0)))); + this.light.sendCommands(commands.rgbw.hue(commands.rgbw.hsvToMilightColor(hue))); } } else if (this.type == "rgb") { - light.sendCommands(commands.rgb.hue(commands.rgbw.hsvToMilightColor(Array(value, 0, 0)))); + this.light.sendCommands(commands.rgb.hue(commands.rgbw.hsvToMilightColor(hue))); } else if (this.type == "white") { // Again, white lamps don't support setting an absolue colour temp, so trying to do warmer/cooler step at a time based on colour if (value >= 180) { - light.sendCommands(commands.white.warmer()); + this.light.sendCommands(commands.white.warmer()); } else { - light.sendCommands(commands.white.cooler()); + this.light.sendCommands(commands.white.cooler()); } } diff --git a/accessories/knxdevice.js b/accessories/knxdevice.js new file mode 100644 index 0000000..efdbd4e --- /dev/null +++ b/accessories/knxdevice.js @@ -0,0 +1,650 @@ +/* + * This is a KNX universal accessory shim. + * + * + */ +var Service = require("HAP-NodeJS").Service; +var Characteristic = require("HAP-NodeJS").Characteristic; +var knxd = require("eibd"); +var knxd_registerGA = require('../platforms/KNX.js').registerGA; +var knxd_startMonitor = require('../platforms/KNX.js').startMonitor; + +var milliTimeout = 300; // used to block responses while swiping + + +function KNXDevice(log, config) { + this.log = log; + // everything in one object, do not copy individually + this.config = config; + log("Accessory constructor called"); + if (config.name) { + this.name = config.name; + } + if (config.knxd_ip){ + this.knxd_ip = config.knxd_ip; + } else { + throw new Error("MISSING KNXD IP"); + } + if (config.knxd_port){ + this.knxd_port = config.knxd_port; + } else { + throw new Error("MISSING KNXD PORT"); + } + +} + + +//debugging helper only +//inspects an object and prints its properties (also inherited properties) +var iterate = function nextIteration(myObject, path){ + // this function iterates over all properties of an object and print them to the console + // when finding objects it goes one level deeper + var name; + if (!path){ + console.log("---iterating--------------------") + } + for (name in myObject) { + if (typeof myObject[name] !== 'function') { + if (typeof myObject[name] !== 'object' ) { + console.log((path || "") + name + ': ' + myObject[name]); + } else { + nextIteration(myObject[name], path ? path + name + "." : name + "."); + } + } else { + console.log((path || "") + name + ': (function)' ); + } + } + if (!path) { + console.log("================================"); + } +}; + + +module.exports = { + accessory: KNXDevice +}; + + +KNXDevice.prototype = { + + // all purpose / all types write function + knxwrite: function(callback, groupAddress, dpt, value) { + // this.log("DEBUG in knxwrite"); + var knxdConnection = new knxd.Connection(); + // this.log("DEBUG in knxwrite: created empty connection, trying to connect socket to "+this.knxd_ip+":"+this.knxd_port); + knxdConnection.socketRemote({ host: this.knxd_ip, port: this.knxd_port }, function() { + var dest = knxd.str2addr(groupAddress); + // this.log("DEBUG got dest="+dest); + knxdConnection.openTGroup(dest, 1, function(err) { + if (err) { + this.log("[ERROR] knxwrite:openTGroup: " + err); + callback(err); + } else { + // this.log("DEBUG opened TGroup "); + var msg = knxd.createMessage('write', dpt, parseFloat(value)); + knxdConnection.sendAPDU(msg, function(err) { + if (err) { + this.log("[ERROR] knxwrite:sendAPDU: " + err); + callback(err); + } else { + // this.log("knx data sent"); + callback(); + } + }.bind(this)); + } + }.bind(this)); + }.bind(this)); + }, + + // issues an all purpose read request on the knx bus + // DOES NOT WAIT for an answer. Please register the address with a callback using registerGA() function + knxread: function(groupAddress){ + // this.log("DEBUG in knxread"); + if (!groupAddress) { + return null; + } + var knxdConnection = new knxd.Connection(); + // this.log("DEBUG in knxread: created empty connection, trying to connect socket to "+this.knxd_ip+":"+this.knxd_port); + knxdConnection.socketRemote({ host: this.knxd_ip, port: this.knxd_port }, function() { + var dest = knxd.str2addr(groupAddress); + // this.log("DEBUG got dest="+dest); + knxdConnection.openTGroup(dest, 1, function(err) { + if (err) { + this.log("[ERROR] knxread:openTGroup: " + err); + } else { + // this.log("DEBUG knxread: opened TGroup "); + var msg = knxd.createMessage('read', 'DPT1', 0); + knxdConnection.sendAPDU(msg, function(err) { + if (err) { + this.log("[ERROR] knxread:sendAPDU: " + err); + } else { + this.log("knx request sent for "+groupAddress); + } + }.bind(this)); + } + }.bind(this)); + }.bind(this)); + }, + + // issuing multiple read requests at once + knxreadarray: function (groupAddresses) { + if (groupAddresses.constructor.toString().indexOf("Array") > -1) { + // handle multiple addresses + for (var i = 0; i < groupAddresses.length; i++) { + if (groupAddresses[i]) { // do not bind empty addresses + this.knxread (groupAddresses[i]); + } + } + } else { + // it's only one + this.knxread (groupAddresses); + } + }, + + // special types + knxwrite_percent: function(callback, groupAddress, value) { + var numericValue = 0; + if (value && value>=0 && value <= 100) { + numericValue = 255*value/100; // convert 1..100 to 1..255 for KNX bus + } else { + this.log("[ERROR] Percentage value ot of bounds "); + numericValue = 0; + } + this.knxwrite(callback, groupAddress,'DPT5',numericValue); + }, + + + // need to spit registers into types + + // boolean: get 0 or 1 from the bus, write boolean + knxregister_bool: function(addresses, characteristic) { + this.log("knx registering BOOLEAN " + addresses); + knxd_registerGA(addresses, function(val, src, dest, type){ + this.log("Received value from bus:"+val+ " for " +dest+ " from "+src+" of type"+type + " for " + characteristic.displayName); +// iterate(characteristic); + characteristic.setValue(val ? 1 : 0, undefined, 'fromKNXBus'); + }.bind(this)); + }, + knxregister_boolReverse: function(addresses, characteristic) { + this.log("knx registering BOOLEAN " + addresses); + knxd_registerGA(addresses, function(val, src, dest, type){ + this.log("Received value from bus:"+val+ " for " +dest+ " from "+src+" of type"+type + " for " + characteristic.displayName); +// iterate(characteristic); + characteristic.setValue(val ? 0 : 1, undefined, 'fromKNXBus'); + }.bind(this)); + }, + // percentage: get 0..255 from the bus, write 0..100 to characteristic + knxregister_percent: function(addresses, characteristic) { + this.log("knx registering PERCENT " + addresses); + knxd_registerGA(addresses, function(val, src, dest, type){ + this.log("Received value from bus:"+val+ " for " +dest+ " from "+src+" of type"+type+ " for " + characteristic.displayName); + if (type !== "DPT5") { + this.log("[ERROR] Received value cannot be a percentage value"); + } else { + if (!characteristic.timeout) { + if (characteristic.timeout < Date.now()) { + characteristic.setValue(Math.round(val/255*100), undefined, 'fromKNXBus'); + } else { + this.log("Blackout time"); + } + } else { + characteristic.setValue(Math.round(val/255*100), undefined, 'fromKNXBus'); + } // todo get the boolean logic right into one OR expresssion + + } + }.bind(this)); + }, + + // float + knxregister_float: function(addresses, characteristic) { + this.log("knx registering FLOAT " + addresses); + knxd_registerGA(addresses, function(val, src, dest, type){ + this.log("Received value from bus:"+val+ " for " +dest+ " from "+src+" of type"+type+ " for " + characteristic.displayName); + var hk_value = Math.round(val*10)/10; + if (hk_value>=characteristic.minimumValue && hk_value<=characteristic.maximumValue) { + characteristic.setValue(hk_value, undefined, 'fromKNXBus'); // 1 decoimal for HomeKit + } else { + this.log("Value %s out of bounds %s...%s ",hk_value, characteristic.minimumValue, characteristic.maximumValue); + } + + }.bind(this)); + }, + + // what about HVAC heating cooling types? + knxregister_HVAC: function(addresses, characteristic) { + this.log("knx registering HVAC " + addresses); + knxd_registerGA(addresses, function(val, src, dest, type){ + this.log("Received value from bus:"+val+ " for " +dest+ " from "+src+" of type"+type+ " for " + characteristic.displayName); + var HAPvalue = 0; + switch (val){ + case 0: + HAPvalue = 1; + break; + case 1: + HAPvalue = 1; + break; + case 2: + HAPvalue = 1; + break; + case 3: + HAPvalue = 1; + break; + case 4: + HAPvalue = 0; + break; + default: + HAPvalue = 0; + } + characteristic.setValue(HAPvalue, undefined, 'fromKNXBus'); + }.bind(this)); + }, + // to do! KNX: DPT 20.102 = One Byte like DPT5 +// 0 = Auto +// 1 = Comfort +// 2 = Standby +// 3 = Night +// 4 = Freezing/Heat Protection +// 5 – 255 = not allowed” + // The value property of TargetHeatingCoolingState must be one of the following: +// Characteristic.TargetHeatingCoolingState.OFF = 0; +// Characteristic.TargetHeatingCoolingState.HEAT = 1; +// Characteristic.TargetHeatingCoolingState.COOL = 2; +// Characteristic.TargetHeatingCoolingState.AUTO = 3; + + + // undefined, has to match! + knxregister: function(addresses, characteristic) { + this.log("knx registering " + addresses); + knxd_registerGA(addresses, function(val, src, dest, type){ + this.log("Received value from bus:"+val+ " for " +dest+ " from "+src+" of type"+type+ " for " + characteristic.displayName); + characteristic.setValue(val, undefined, 'fromKNXBus'); + }.bind(this)); + }, + + /* + * set methods used for creating callbacks, such as + * var Characteristic = myService.addCharacteristic(new Characteristic.Brightness()) + * .on('set', function(value, callback, context) { + * this.setPercentage(value, callback, context, this.config[index].Set) + * }.bind(this)); + * + */ + setBooleanState: function(value, callback, context, gaddress) { + if (context === 'fromKNXBus') { + this.log(gaddress + " event ping pong, exit!"); + if (callback) { + callback(); + } + } else { + var numericValue = 0; + if (value) { + numericValue = 1; // need 0 or 1, not true or something + } + this.log("Setting "+gaddress+" Boolean to %s", numericValue); + this.knxwrite(callback, gaddress,'DPT1',numericValue); + } + + }, + setBooleanReverseState: function(value, callback, context, gaddress) { + if (context === 'fromKNXBus') { + this.log(gaddress + " event ping pong, exit!"); + if (callback) { + callback(); + } + } else { + var numericValue = 0; + if (!value) { + numericValue = 1; // need 0 or 1, not true or something + } + this.log("Setting "+gaddress+" Boolean to %s", numericValue); + this.knxwrite(callback, gaddress,'DPT1',numericValue); + } + + }, + + setPercentage: function(value, callback, context, gaddress) { + if (context === 'fromKNXBus') { + this.log("event ping pong, exit!"); + if (callback) { + callback(); + } + } else { + var numericValue = 0; + if (value) { + numericValue = Math.round(255*value/100); // convert 1..100 to 1..255 for KNX bus + } + this.log("Setting "+gaddress+" percentage to %s (%s)", value, numericValue); + this.knxwrite(callback, gaddress,'DPT5',numericValue); + } + }, + + setFloat: function(value, callback, context, gaddress) { + if (context === 'fromKNXBus') { + this.log(gaddress + " event ping pong, exit!"); + if (callback) { + callback(); + } + } else { + var numericValue = 0; + if (value) { + numericValue = value; // homekit expects precision of 1 decimal + } + this.log("Setting "+gaddress+" Float to %s", numericValue); + this.knxwrite(callback, gaddress,'DPT9',numericValue); + } + }, + + setHVACState: function(value, callback, context, gaddress) { + if (context === 'fromKNXBus') { + this.log(gaddress + " event ping pong, exit!"); + if (callback) { + callback(); + } + } else { + var numericValue = 0; + switch (value){ + case 0: + KNXvalue = 4; + break; + case 1: + KNXvalue = 1; + break; + case 2: + KNXvalue = 1; + break; + case 3: + KNXvalue = 1; + break; + default: + KNXvalue = 1; + } + + this.log("Setting "+gaddress+" HVAC to %s", KNXvalue); + this.knxwrite(callback, gaddress,'DPT5',KNXvalue); + } + + }, + + + identify: function(callback) { + this.log("Identify requested!"); + callback(); // success + }, + + + /* + * function getXXXXXXXService(config) + * + * returns a configured service object to the caller (accessory/device) + * + */ + + bindCharacteristic: function(myService, characteristicType, valueType, config) { + var myCharacteristic = myService.getCharacteristic(characteristicType); + if (myCharacteristic === undefined) { + throw new Error("unknown characteristics cannot be bound"); + } + if (config.Set) { + // can write + switch (valueType) { + case "Bool": + myCharacteristic.on('set', function(value, callback, context) { + this.setBooleanState(value, callback, context, config.Set); + }.bind(this)); + break; + case "BoolReverse": + myCharacteristic.on('set', function(value, callback, context) { + this.setBooleanReverseState(value, callback, context, config.Set); + }.bind(this)); + break; + case "Percent": + myCharacteristic.on('set', function(value, callback, context) { + this.setPercentage(value, callback, context, config.Set); + myCharacteristic.timeout = Date.now()+milliTimeout; + }.bind(this)); + break; + case "Float": + myCharacteristic.on('set', function(value, callback, context) { + this.setFloat(value, callback, context, config.Set); + }.bind(this)); + break; + case "HVAC": + myCharacteristic.on('set', function(value, callback, context) { + this.setHVACState(value, callback, context, config.Set); + }.bind(this)); + break; + default: + this.log("[ERROR] unknown type passed"); + throw new Error("[ERROR] unknown type passed"); + } + } + if ([config.Set].concat(config.Listen || []).length>0) { + //this.log("Binding LISTEN"); + // can read + switch (valueType) { + case "Bool": + this.knxregister_bool([config.Set].concat(config.Listen || []), myCharacteristic); + break; + case "BoolReverse": + this.knxregister_boolReverse([config.Set].concat(config.Listen || []), myCharacteristic); + break; + case "Percent": + this.knxregister_percent([config.Set].concat(config.Listen || []), myCharacteristic); + break; + case "Float": + this.knxregister_float([config.Set].concat(config.Listen || []), myCharacteristic); + break; + case "HVAC": + this.knxregister_HVAC([config.Set].concat(config.Listen || []), myCharacteristic); + break; + default: + this.log("[ERROR] unknown type passed"); + throw new Error("[ERROR] unknown type passed"); + } + this.log("Issuing read requests on the KNX bus..."); + this.knxreadarray([config.Set].concat(config.Listen || [])); + } + return myCharacteristic; // for chaining or whatsoever + }, + + getLightbulbService: function(config) { + // some sanity checks + //this.config = config; + + if (config.type !== "Lightbulb") { + this.log("[ERROR] Lightbulb Service for non 'Lightbulb' service called"); + return undefined; + } + if (!config.name) { + this.log("[ERROR] Lightbulb Service without 'name' property called"); + return undefined; + } + var myService = new Service.Lightbulb(config.name,config.name); + // On (and Off) + if (config.On) { + this.log("Lightbulb on/off characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.On, "Bool", config.On); + } // On characteristic + // Brightness if available + if (config.Brightness) { + this.log("Lightbulb Brightness characteristic enabled"); + myService.addCharacteristic(Characteristic.Brightness); // it's an optional + this.bindCharacteristic(myService, Characteristic.Brightness, "Percent", config.Brightness); + } + // Hue and Saturation could be added here if available in KNX lamps + //iterate(myService); + return myService; + }, + + getLockMechanismService: function(config) { + // some sanity checks + //this.config = config; +// Characteristic.LockCurrentState.UNSECURED = 0; +// Characteristic.LockCurrentState.SECURED = 1; + + if (config.type !== "LockMechanism") { + this.log("[ERROR] LockMechanism Service for non 'LockMechanism' service called"); + return undefined; + } + if (!config.name) { + this.log("[ERROR] LockMechanism Service without 'name' property called"); + return undefined; + } + var myService = new Service.LockMechanism(config.name,config.name); + // LockCurrentState + if (config.LockCurrentState) { + // for normal contacts: Secured = 1 + this.log("LockMechanism LockCurrentState characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.LockCurrentState, "Bool", config.LockCurrentState); + } else if (config.LockCurrentStateSecured0) { + // for reverse contacts Secured = 0 + this.log("LockMechanism LockCurrentState characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.LockCurrentState, "BoolReverse", config.LockCurrentStateSecured0); + } + // LockTargetState + if (config.LockTargetState) { + this.log("LockMechanism LockTargetState characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.LockTargetState, "Bool", config.LockTargetState); + } else if (config.LockTargetStateSecured0) { + this.log("LockMechanism LockTargetState characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.LockTargetState, "BoolReverse", config.LockTargetStateSecured0); + } + + //iterate(myService); + return myService; + }, + + + getThermostatService: function(config) { + + +// // Required Characteristics +// this.addCharacteristic(Characteristic.CurrentHeatingCoolingState); +// this.addCharacteristic(Characteristic.TargetHeatingCoolingState); +// this.addCharacteristic(Characteristic.CurrentTemperature); //check +// this.addCharacteristic(Characteristic.TargetTemperature); // +// this.addCharacteristic(Characteristic.TemperatureDisplayUnits); + // +// // Optional Characteristics +// this.addOptionalCharacteristic(Characteristic.CurrentRelativeHumidity); +// this.addOptionalCharacteristic(Characteristic.TargetRelativeHumidity); +// this.addOptionalCharacteristic(Characteristic.CoolingThresholdTemperature); +// this.addOptionalCharacteristic(Characteristic.HeatingThresholdTemperature); + + + // some sanity checks + + + if (config.type !== "Thermostat") { + this.log("[ERROR] Thermostat Service for non 'Thermostat' service called"); + return undefined; + } + if (!config.name) { + this.log("[ERROR] Thermostat Service without 'name' property called"); + return undefined; + } + var myService = new Service.Thermostat(config.name,config.name); + // CurrentTemperature) + if (config.CurrentTemperature) { + this.log("Thermostat CurrentTemperature characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.CurrentTemperature, "Float", config.CurrentTemperature); + } + // TargetTemperature if available + if (config.TargetTemperature) { + this.log("Thermostat TargetTemperature characteristic enabled"); + // default boundary too narrow for thermostats + myService.getCharacteristic(Characteristic.TargetTemperature).minimumValue=0; // °C + myService.getCharacteristic(Characteristic.TargetTemperature).maximumValue=40; // °C + this.bindCharacteristic(myService, Characteristic.TargetTemperature, "Float", config.TargetTemperature); + } + // HVAC missing yet + if (config.CurrentHeatingCoolingState) { + this.log("Thermostat CurrentHeatingCoolingState characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.CurrentHeatingCoolingState, "HVAC", config.CurrentHeatingCoolingState); + } + return myService; + }, + + // temperature sensor type (iOS9 assumed) + getTemperatureSensorService: function(config) { + + + + // some sanity checks + + + if (config.type !== "TemperatureSensor") { + this.log("[ERROR] TemperatureSensor Service for non 'TemperatureSensor' service called"); + return undefined; + } + if (!config.name) { + this.log("[ERROR] TemperatureSensor Service without 'name' property called"); + return undefined; + } + var myService = new Service.TemperatureSensor(config.name,config.name); + // CurrentTemperature) + if (config.CurrentTemperature) { + this.log("Thermostat CurrentTemperature characteristic enabled"); + this.bindCharacteristic(myService, Characteristic.CurrentTemperature, "Float", config.CurrentTemperature); + } + return myService; + }, + + + /* assemble the device ***************************************************************************************************/ + + + getServices: function() { + + // you can OPTIONALLY create an information service if you wish to override + // the default values for things like serial number, model, etc. + + var accessoryServices = []; + + var informationService = new Service.AccessoryInformation(); + + informationService + .setCharacteristic(Characteristic.Manufacturer, "Opensource Community") + .setCharacteristic(Characteristic.Model, "KNX Universal Device") + .setCharacteristic(Characteristic.SerialNumber, "Version 1.1"); + + accessoryServices.push(informationService); + + iterate(this.config); +// throw new Error("STOP"); + if (!this.config.services){ + this.log("No services found in accessory?!") + } + var currServices = this.config.services; + this.log("Preparing Services: " + currServices.length) + // go through the config thing and look for services + for (var int = 0; int < currServices.length; int++) { + var configService = currServices[int]; + // services need to have type and name properties + if (!configService.type && !configService.name) { + this.log("[ERROR] must specify 'type' and 'name' properties for each service in config.json. KNX platform section fault "); + throw new Error("Must specify 'type' and 'name' properties for each service in config.json"); + } + switch (configService.type) { + case "Lightbulb": + accessoryServices.push(this.getLightbulbService(configService)); + break; + case "LockMechanism": + accessoryServices.push(this.getLockMechanismService(configService)); + break; + case "TemperatureSensor": + accessoryServices.push(this.getTemperatureSensorService(configService)); + break; + case "Thermostat": + accessoryServices.push(this.getThermostatService(configService)); + break; + default: + this.log("[ERROR] unknown 'type' property for service "+ configService.name + " in config.json. KNX platform section fault "); + //throw new Error("[ERROR] unknown 'type' property for service "+ configService.name + " in config.json. KNX platform section fault "); + } + } + // start listening for events on the bus (if not started yet - will prevent itself) + knxd_startMonitor({ host: this.knxd_ip, port: this.knxd_port }); + return accessoryServices; + } +}; diff --git a/config-sample-knx.json b/config-sample-knx.json new file mode 100644 index 0000000..a8e52b1 --- /dev/null +++ b/config-sample-knx.json @@ -0,0 +1,121 @@ +{ + "bridge": { + "name": "Homebridge", + "username": "CC:22:3D:E3:CE:30", + "port": 51826, + "pin": "031-45-154" + }, + "description": "This is an example configuration file for KNX platform shim", + "hint": "Always paste into jsonlint.com validation page before starting your homebridge, saves a lot of frustration", + "platforms": [ + { + "platform": "KNX", + "name": "KNX", + "knxd_ip": "192.168.178.205", + "knxd_port": 6720, + "accessories": [ + { + "accessory_type": "knxdevice", + "description": "Only generic type knxdevice is supported, all previous knx type have been merged into that.", + "name": "Living Room North Lamp", + "services": [ + { + "type": "Lightbulb", + "description": "iOS8 Lightbulb type, supports On (Switch) and Brightness", + "name": "Living Room North Lamp", + "On": { + "Set": "1/1/6", + "Listen": [ + "1/1/63" + ] + }, + "Brightness": { + "Set": "1/1/62", + "Listen": [ + "1/1/64" + ] + } + } + ], + "services-description": "Services is an array, you CAN have multiple service types in one accessory, though it is not fully supported in many iOS HK apps, such as EVE and myTouchHome" + }, + { + "accessory_type": "knxdevice", + "name": "Office Temperature", + "description": "iOS8.4.1 TemperatureSensor type, supports CurrentTemperature", + "services": [ + { + "type": "TemperatureSensor", + "name": "Raumtemperatur", + "CurrentTemperature": { + "Listen": "3/3/44" + } + } + ] + }, + { + "accessory_type": "knxdevice", + "name": "Office Window Lock", + "services": [ + { + "type": "LockMechanism", + "description": "iOS8 Lock mechanism, Supports LockCurrentStateSecured0 OR LockCurrentState, LockTargetStateSecured0 OR LockTargetState, use depending if LOCKED is 0 or 1", + "name": "Office Window Lock", + "LockCurrentStateSecured0": { + "Listen": "5/3/15" + }, + "LockTargetStateSecured0": { + "Listen": "5/3/15" + } + } + ] + }, + { + "accessory_type": "knxdevice", + "description":"sample device with multiple services. Multiple services of different types are widely supported", + "name": "Office", + "services": [ + { + "type": "Lightbulb", + "name": "Office Lamp", + "On": { + "Set": "1/3/5" + } + }, + { + "type": "Thermostat", + "description": "iOS8 Thermostat type, supports CurrentTemperature, TargetTemperature, CurrentHeatingCoolingState ", + "name": "Raumtemperatur", + "CurrentTemperature": { + "Listen": "3/3/44" + }, + "TargetTemperature": { + "Set": "3/3/94" + }, + "CurrentHeatingCoolingState": { + "Listen": "3/3/64" + } + }, + { + "type": "WindowCovering", + "description": "iOS9 Window covering (blinds etc) type, still WIP", + "name": "Blinds", + "Target": { + "Set": "address", + "Listen": "adresses" + }, + "Current": { + "Set": "address", + "Listen": "adresses" + }, + "PositionState": { + "Listen": "adresses" + } + } + ] + } + ] + } + ], + "accessories": [] +} diff --git a/package.json b/package.json index 0db1926..546aa22 100644 --- a/package.json +++ b/package.json @@ -15,6 +15,7 @@ "carwingsjs": "0.0.x", "color": "0.10.x", "elkington": "kevinohara80/elkington", + "eibd": "^0.3.1", "hap-nodejs": "git+https://github.com/KhaosT/HAP-NodeJS#6bf0f9eaaa2d87db8d1768114c61f4acbb095c41", "harmonyhubjs-client": "^1.1.4", "harmonyhubjs-discover": "git+https://github.com/swissmanu/harmonyhubjs-discover.git", diff --git a/platforms/KNX.js b/platforms/KNX.js new file mode 100644 index 0000000..573b3b9 --- /dev/null +++ b/platforms/KNX.js @@ -0,0 +1,203 @@ +/** Sample platform outline + * based on Sonos platform + */ +'use strict'; +var types = require("HAP-NodeJS/accessories/types.js"); +//var hardware = require('myHardwareSupport'); //require any additional hardware packages +var knxd = require('eibd'); + +function KNXPlatform(log, config){ + this.log = log; + this.config = config; +// this.property1 = config.property1; +// this.property2 = config.property2; + + + // initiate connection to bus for listening ==> done with first shim + +}; + +KNXPlatform.prototype = { + accessories: function(callback) { + this.log("Fetching KNX devices."); + var that = this; + + + // iterate through all devices the platform my offer + // for each device, create an accessory + + // read accessories from file !!!!! + var foundAccessories = this.config.accessories; + + + //create array of accessories + var myAccessories = []; + + for (var int = 0; int < foundAccessories.length; int++) { + this.log("parsing acc " + int + " of " + foundAccessories.length); + // instantiate and push to array + switch (foundAccessories[int].accessory_type) { + case "knxdevice": + this.log("push new universal device "+foundAccessories[int].name); + // push knxd connection setting to each device from platform + foundAccessories[int].knxd_ip = this.config.knxd_ip; + foundAccessories[int].knxd_port = this.config.knxd_port; + var accConstructor = require('./../accessories/knxdevice.js'); + var acc = new accConstructor.accessory(this.log,foundAccessories[int]); + this.log("created "+acc.name+" universal accessory"); + myAccessories.push(acc); + break; + default: + // do something else + this.log("unkown accessory type found") + } + + }; + // if done, return the array to callback function + this.log("returning "+myAccessories.length+" accessories"); + callback(myAccessories); + } +}; + + +/** + * The buscallbacks module is to expose a simple function to listen on the bus and register callbacks for value changes + * of registered addresses. + * + * Usage: + * You can start the monitoring process at any time + startMonitor({host: name-ip, port: port-num }); + + * You can add addresses to the subscriptions using + +registerGA(groupAddress, callback) + + * groupAddress has to be an groupAddress in common knx notation string '1/2/3' + * the callback has to be a + * var f = function(value) { handle value update;} + * so you can do a + * registerGA('1/2/3', function(value){ + * console.log('1/2/3 got a hit with '+value); + * }); + * but of course it is meant to be used programmatically, not literally, otherwise it has no advantage + * + * You can also use arrays of addresses if your callback is supposed to listen to many addresses: + +registerGA(groupAddresses[], callback) + + * as in + * registerGA(['1/2/3','1/0/0'], function(value){ + * console.log('1/2/3 or 1/0/0 got a hit with '+value); + * }); + * if you are having central addresses like "all lights off" or additional response objects + * + * + * callbacks can have a signature of + * function(value, src, dest, type) but do not have to support these parameters (order matters) + * src = physical address such as '1.1.20' + * dest = groupAddress hit (you subscribed to that address, remember?), as '1/2/3' + * type = Data point type, as 'DPT1' + * + * + */ + + + +//array of registered addresses and their callbacks +var subscriptions = []; +//check variable to avoid running two listeners +var running; + +function groupsocketlisten(opts, callback) { + var conn = knxd.Connection(); + conn.socketRemote(opts, function() { + conn.openGroupSocket(0, callback); + }); +} + + +var registerSingleGA = function registerSingleGA (groupAddress, callback) { + subscriptions.push({address: groupAddress, callback: callback }); +} + +/* + * public busMonitor.startMonitor() + * starts listening for telegrams on KNX bus + * + */ +var startMonitor = function startMonitor(opts) { // using { host: name-ip, port: port-num } options object + if (!running) { + running = true; + } else { + console.log("<< knxd socket listener already running >>"); + return null; + } + console.log(">>> knxd groupsocketlisten starting <<<"); + groupsocketlisten(opts, function(parser) { + //console.log("knxfunctions.read: in callback parser"); + parser.on('write', function(src, dest, type, val){ + // search the registered group addresses + //console.log('recv: Write from '+src+' to '+dest+': '+val+' ['+type+'], listeners:' + subscriptions.length); + for (var i = 0; i < subscriptions.length; i++) { + // iterate through all registered addresses + if (subscriptions[i].address === dest) { + // found one, notify + console.log('HIT: Write from '+src+' to '+dest+': '+val+' ['+type+']'); + subscriptions[i].callback(val, src, dest, type); + } + } + }); + + parser.on('response', function(src, dest, type, val) { + // search the registered group addresses +// console.log('recv: resp from '+src+' to '+dest+': '+val+' ['+type+']'); + for (var i = 0; i < subscriptions.length; i++) { + // iterate through all registered addresses + if (subscriptions[i].address === dest) { + // found one, notify +// console.log('HIT: Response from '+src+' to '+dest+': '+val+' ['+type+']'); + subscriptions[i].callback(val, src, dest, type); + } + } + + }); + + //dont care about reads here +// parser.on('read', function(src, dest) { +// console.log('Read from '+src+' to '+dest); +// }); + //console.log("knxfunctions.read: in callback parser at end"); + }); // groupsocketlisten parser +}; //startMonitor + + +/* + * public registerGA(groupAdresses[], callback(value)) + * parameters + * callback: function(value, src, dest, type) called when a value is sent on the bus + * groupAddresses: (Array of) string(s) for group addresses + * + * + * + */ +var registerGA = function (groupAddresses, callback) { + // check if the groupAddresses is an array + if (groupAddresses.constructor.toString().indexOf("Array") > -1) { + // handle multiple addresses + for (var i = 0; i < groupAddresses.length; i++) { + if (groupAddresses[i]) { // do not bind empty addresses + registerSingleGA (groupAddresses[i], callback); + } + } + } else { + // it's only one + registerSingleGA (groupAddresses, callback); + } +// console.log("listeners now: " + subscriptions.length); +}; + + + +module.exports.platform = KNXPlatform; +module.exports.registerGA = registerGA; +module.exports.startMonitor = startMonitor; \ No newline at end of file diff --git a/platforms/Sonos.js b/platforms/Sonos.js index 67d086e..1d19c2f 100644 --- a/platforms/Sonos.js +++ b/platforms/Sonos.js @@ -6,6 +6,8 @@ function SonosPlatform(log, config){ this.config = config; this.name = config["name"]; this.playVolume = config["play_volume"]; + // timeout for device discovery + this.discoveryTimeout = (config.deviceDiscoveryTimeout || 10)*1000; // assume 10sec as a default } SonosPlatform.prototype = { @@ -16,6 +18,18 @@ SonosPlatform.prototype = { // track found devices so we don't add duplicates var roomNamesFound = {}; + // collector array for the devices from callbacks + var devicesFound = []; + // tell the sonos callbacks if timeout already occured + var timeout = false; + + // the timeout event will push the accessories back + setTimeout(function(){ + timeout=true; + callback(devicesFound); + }, this.discoveryTimeout); + + sonos.search(function (device) { that.log("Found device at " + device.host); @@ -26,9 +40,13 @@ SonosPlatform.prototype = { if (!roomNamesFound[roomName]) { roomNamesFound[roomName] = true; that.log("Found playable device - " + roomName); + if (timeout) { + that.log("Ignored: Discovered after timeout (Set deviceDiscoveryTimeout parameter in Sonos section of config.json)"); + } // device is an instance of sonos.Sonos var accessory = new SonosAccessory(that.log, that.config, device, description); - callback([accessory]); + // add it to the collector array + devicesFound.push(accessory); } else { that.log("Ignoring playable device with duplicate room name - " + roomName); diff --git a/platforms/YamahaAVR.js b/platforms/YamahaAVR.js index f0d10c1..f554fa0 100644 --- a/platforms/YamahaAVR.js +++ b/platforms/YamahaAVR.js @@ -1,13 +1,19 @@ var types = require("HAP-NodeJS/accessories/types.js"); var Yamaha = require('yamaha-nodejs'); var mdns = require('mdns'); +//workaround for raspberry pi +var sequence = [ + mdns.rst.DNSServiceResolve(), + 'DNSServiceGetAddrInfo' in mdns.dns_sd ? mdns.rst.DNSServiceGetAddrInfo() : mdns.rst.getaddrinfo({families:[4]}), + mdns.rst.makeAddressesUnique() +]; function YamahaAVRPlatform(log, config){ this.log = log; this.config = config; this.playVolume = config["play_volume"]; this.setMainInputTo = config["setMainInputTo"]; - this.browser = mdns.createBrowser(mdns.tcp('http')); + this.browser = mdns.createBrowser(mdns.tcp('http'), {resolverSequence: sequence}); } YamahaAVRPlatform.prototype = {