node-red-contrib-homekit-abc
Version:
HAP-Nodejs based Node-RED nodes to create HomeKit Accessories
226 lines (186 loc) • 9.57 kB
JavaScript
const miio = require('miio');
const path = require('path');
const net = require('net');
const hap = require('hap-nodejs');
const storage = require('node-persist');
const {uuid, Accessory, Service, Characteristic} = hap;
const pkg = require('../package.json');
const fs = require('fs');
const accessories = {};
module.exports = function (RED) {
//hap.init(path.join(RED.settings.userDir, 'homekit'));
RED.httpAdmin.get('/hassbian-abc-homekit-miheater', (req, res) => {
if (req.query.config) {
const acc = accessories[req.query.config];
if (acc) {
res.status(200).send(JSON.stringify({setupURI: acc.setupURI()}));
} else {
res.status(500).send(JSON.stringify({}));
}
} else {
res.status(404).send(JSON.stringify({}));
}
});
class hassbianHomeKitmiheater {
constructor(config) {
RED.nodes.createNode(this, config);
const that = this;
this.device = new miio.Device({
address: config.ip,
token: config.token
});
function logger(...args) {
let str = args.join(' ');
if (str.match(/^(error: )/i)) {
str = str.replace(/^error: (.*)/i, '$1');
that.error(str);
} else if (config.debug) {
that.debug(str);
}
}
if (accessories[this.id]) {
this.debug('miheater already configured ' + this.name + ' ' + this.id + ' ' + this.username);
return;
}
const [firstLogger] = Object.keys(RED.settings.logging);
config.debug = config.debug && (RED.settings.logging[firstLogger].level === 'debug' || RED.settings.logging[firstLogger].level === 'trace');
this.name = config.name || ('miheater ' + this.id);
storage.initSync();
const acc = new Accessory(this.name, uuid.generate(config.id), Accessory.Categories.THERMOSTAT);
accessories[this.id] = acc;
this.debug('miheater created' + this.name + ' ' + this.id + ' ' + config.username);
acc.getService(Service.AccessoryInformation)
.setCharacteristic(Characteristic.Manufacturer, 'hassbian-abc')
.setCharacteristic(Characteristic.Model, 'miheater')
.setCharacteristic(Characteristic.SerialNumber, config.username)
.setCharacteristic(Characteristic.FirmwareRevision, pkg.version);
acc.on('identify', (paired, callback) => {
this.log('identify ' + this.id + ' ' + this.username + ' ' + paired);
callback();
});
var heaterService = acc.addService(Service.HeaterCooler, this.name, this.name);
var currentTemperatureCharacteristic = heaterService.getCharacteristic(Characteristic.CurrentTemperature);
var currentHeaterCoolerStateCharacteristic = heaterService.getCharacteristic(Characteristic.CurrentHeaterCoolerState);
currentHeaterCoolerStateCharacteristic.setProps({
validValues: [0,2]
});
var targetHeaterCoolerStateCharacteristic = heaterService.getCharacteristic(Characteristic.TargetHeaterCoolerState);
targetHeaterCoolerStateCharacteristic.setProps({
validValues: [1]
});
var activeCharacteristic = heaterService.getCharacteristic(Characteristic.Active);
var lockPhysicalControlsCharacteristic = heaterService.addCharacteristic(Characteristic.LockPhysicalControls);
var currentHumidityCharacteristic = heaterService.addCharacteristic(Characteristic.CurrentRelativeHumidity);
var temperatureDisplayUnitsCharacteristic = heaterService.addCharacteristic(Characteristic.TemperatureDisplayUnits);
temperatureDisplayUnitsCharacteristic.setValue(Characteristic.TemperatureDisplayUnits.CELSIUS)
temperatureDisplayUnitsCharacteristic.setProps({
validValues: [0]
});
heaterService
.getCharacteristic(Characteristic.HeatingThresholdTemperature)
.setProps({
minValue: config.mintemp,
maxValue: config.maxtemp,
minStep: 1,
})
.on('get', function(callback) {
that.device.call("get_prop", ["power", "relative_humidity", "child_lock", "target_temperature", "temperature"]).then(result => {
that.debug("[MiHeater][DEBUG]activeCharacteristic - get: " + result);
if (result[0] === "on") {
activeCharacteristic.updateValue(Characteristic.Active.ACTIVE);
currentHeaterCoolerStateCharacteristic.updateValue(Characteristic.CurrentHeaterCoolerState.HEATING);
} else if (result[0] === "off") {
activeCharacteristic.updateValue(Characteristic.Active.INACTIVE);
currentHeaterCoolerStateCharacteristic.updateValue(Characteristic.CurrentHeaterCoolerState.INACTIVE);
}
currentHumidityCharacteristic.updateValue(result[1]);
currentTemperatureCharacteristic.updateValue(result[4]);
if (result[2] === "on") {
lockPhysicalControlsCharacteristic.updateValue(Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED);
} else if (result[2] === "off") {
lockPhysicalControlsCharacteristic.updateValue(Characteristic.LockPhysicalControls.CONTROL_LOCK_DISABLED);
}
callback(null, result[3])
}).catch(function(err) {
that.debug("[MiHeater][DEBUG]activeCharacteristic - getActive Error: " + err);
callback(err);
});
}.bind(this))
.on('set', function(value, callback) {
that.debug("[MiHeater][DEBUG]heatingThresholdTemperatureCharacteristic - set_target_temperature: " + value);
that.device.call("set_target_temperature", [value]).then(result => {
if(result[0] === "ok") {
callback(null);
} else {
callback(new Error(result[0]));
}
}).catch(function(err) {
that.debug("[MiHeater][DEBUG]heatingThresholdTemperatureCharacteristic - set_target_temperature: " + err);
callback(err);
});
}.bind(this));
activeCharacteristic
.on('set', function(value, callback) {
that.device.call("set_power", [value ? "on" : "off"]).then(result => {
that.debug("[MiHeater][DEBUG]activeCharacteristic - setActive Result: " + result);
if(result[0] === "ok") {
callback(null);
} else {
callback(new Error(result[0]));
}
}).catch(function(err) {
that.debug("[MiHeater][DEBUG]activeCharacteristic - setActive Error: " + err);
callback(err);
});
}.bind(this));
targetHeaterCoolerStateCharacteristic.setValue(Characteristic.TargetHeaterCoolerState.HEAT);
lockPhysicalControlsCharacteristic
.on('set', function(value, callback) {
that.debug("[MiHeater][DEBUG]lockPhysicalControlsCharacteristic - setchildlock: " + value);
that.device.call("set_child_lock", [value ? "on" : "off"]).then(result => {
if(result[0] === "ok") {
callback(null);
} else {
callback(new Error(result[0]));
}
}).catch(function(err) {
that.debug("[MiHeater][DEBUG]lockPhysicalControlsCharacteristic - setchildlock: " + err);
callback(err);
});
}.bind(this));
this.log('publishing miheater ' + this.name + ' ' + config.username);
const testPort = net.createServer()
.once('error', err => {
this.error(err);
this.status({fill: 'red', shape: 'dot', text: err.message});
})
.once('listening', () => {
testPort.once('close', () => {
acc.publish({
username: config.username,
port: config.port,
pincode: config.pincode,
category: Accessory.Categories.THERMOSTAT
});
acc._server.on('listening', () => {
this.log('miheater ' + this.name + ' listening on port ' + config.port);
this.status({fill: 'green', shape: 'ring', text: ' '});
});
acc._server.on('pair', username => {
this.log('miheater ' + this.name + ' paired', username);
});
acc._server.on('unpair', username => {
this.log('miheater ' + this.name + ' unpaired', username);
});
acc._server.on('verify', () => {
this.log('miheater ' + this.name + ' verify');
});
}).close();
})
.listen(config.port);
this.on('close', () => {
});
}
}
RED.nodes.registerType('hassbian-abc-homekit-miheater', hassbianHomeKitmiheater);
};