homebridge-gree-ac 1.0.1 → 2.0.0

package/app/deviceFactory.js

@@ -1,286 +0,0 @@
-'use strict';
-
-const dgram = require('dgram');
-const socket = dgram.createSocket('udp4');
-const encryptionService = require('./encryptionService')();
-const cmd = require('./commandEnums');
-
-/**
- * Class representing a single connected device
- */
-class Device {
-
-    /**
-     * Create device model and establish UDP connection with remote host
-     * @param {object} [options] Options
-     * @param {string} [options.address] HVAC IP address
-     * @callback [options.onStatus] Callback function run on each status update
-     * @callback [options.onUpdate] Callback function run after command
-     * @callback [options.onConnected] Callback function run once connection is established
-      */
-    constructor(options) {
-
-        //  Set defaults
-        this.options = {
-            host: options.host || '192.168.1.255',
-            onStatus: options.onStatus || function() {},
-            onUpdate: options.onUpdate || function() {},
-            onConnected: options.onConnected || function() {},
-            onError: options.onError || function() {},
-            onDisconnected: options.onDisconnected || function() {},
-            updateInterval: options.updateInterval || 10000
-        }
-
-        /**
-         * Device object
-         * @typedef {object} Device
-         * @property {string} id - ID
-         * @property {string} name - Name
-         * @property {string} address - IP address
-         * @property {number} port - Port number
-         * @property {boolean} bound - If is already bound
-         * @property {object} props - Properties
-         */
-        this.device = {};
-
-        // Initialize connection and bind with device
-        this._connectToDevice(this.options.host);
-        
-        // Handle incoming messages
-        socket.on('message', (msg, rinfo) => this._handleResponse(msg, rinfo));
-    }
-
-    /**
-     * Initialize connection
-     * @param {string} address - IP/host address 
-     */
-    _connectToDevice(address) {
-        try {
-            socket.bind(() => {
-                const message = new Buffer(JSON.stringify({t: 'scan'}));
-
-                socket.setBroadcast(false);
-                socket.send(message, 0, message.length, 7000, address);
-            });
-        } catch (err) {
-            const timeout = 5
-            this.options.onDisconnected(this.device);
-            setTimeout(() => {
-                this._connectToDevice(address);
-            }, timeout * 1000);
-        }
-    }
-
-    /**
-     * Register new device locally
-     * @param {string} id - CID received in handshake message
-     * @param {string} name - Device name received in handshake message
-     * @param {string} address - IP/host address
-     * @param {number} port - Port number
-     */
-    _setDevice (id, name, address, port) {
-        this.device.id = id;
-        this.device.name = name;
-        this.device.address = address;
-        this.device.port = port;
-        this.device.bound = false;
-        this.device.props = {};
-
-        console.log('[GreeAC] New device registered: %s - %s', this.device.name, this.device.address);
-    }
-
-    /**
-     * Send binding request to device
-     * @param {Device} device Device object
-     */
-    _sendBindRequest(device) {
-        const message = {
-            mac: this.device.id,
-            t: 'bind',
-            uid: 0
-        };
-        const encryptedBoundMessage = encryptionService.encrypt(message);
-        const request = {
-            cid: 'app',
-            i: 1,
-            t: 'pack',
-            uid: 0,
-            pack: encryptedBoundMessage
-        };
-        const toSend = new Buffer(JSON.stringify(request));
-        socket.send(toSend, 0, toSend.length, device.port, device.address);
-    }
-
-    /**
-     * Confirm device is bound and update device status on list
-     * @param {String} id - Device ID
-     * @param {String} key - Encryption key
-     */
-    _confirmBinding(id, key) {
-        this.device.bound = true;
-        this.device.key = key;
-    }
-
-    /**
-     * Confirm device is bound and update device status on list
-     * @param {Device} device - Device
-     */
-    _requestDeviceStatus (device) {
-        const message = {
-            cols: Object.keys(cmd).map(key => cmd[key].code),
-            mac: device.id,
-            t: 'status'
-        };
-        this._sendRequest(message, device.address, device.port);
-    }
-
-    /**
-     * Handle UDP response from device
-     * @param {string} msg Serialized JSON string with message
-     * @param {object} rinfo Additional request information
-     * @param {string} rinfo.address IP/host address
-     * @param {number} rinfo.port Port number
-     */
-    _handleResponse(msg, rinfo) {
-
-        const message = JSON.parse(msg + '');
-
-        // Extract encrypted package from message using device key (if available)
-        const pack = encryptionService.decrypt(message, (this.device || {}).key);
-        
-        // If package type is response to handshake
-        if (pack.t === 'dev') {
-            this._setDevice(message.cid, pack.name, rinfo.address, rinfo.port);
-            this._sendBindRequest(this.device);
-            return;
-        }
-
-        // If package type is binding confirmation
-        if (pack.t === 'bindok' && this.device.id) {
-            this._confirmBinding(message.cid, pack.key);
-
-            // Start requesting device status on set interval
-            setInterval(this._requestDeviceStatus.bind(this, this.device), this.options.updateInterval);
-            this.options.onConnected(this.device)
-            return;
-        }
-
-        // If package type is device status
-        if (pack.t === 'dat' && this.device.bound) {
-            pack.cols.forEach((col, i) => {
-                this.device.props[col] = pack.dat[i];
-            });
-            this.options.onStatus(this.device);
-            return;
-        }
-
-        // If package type is response, update device properties
-        if (pack.t === 'res' && this.device.bound) {
-            pack.opt.forEach((opt, i) => {
-                this.device.props[opt] = pack.val[i];
-            });
-            this.options.onUpdate(this.device);
-            return;
-        }
-        
-        this.options.onError(this.device);
-    }
-
-    /**
-     * Send commands to a bound device
-     * @param {string[]} commands List of commands
-     * @param {number[]} values List of values
-     */
-    _sendCommand (commands = [], values = []) {
-        const message = {
-            opt: commands,
-            p: values,
-            t: 'cmd'
-        };
-        this._sendRequest(message);
-    };
-
-    /**
-     * Send request to a bound device
-     * @param {object} message
-     * @param {string[]} message.opt
-     * @param {number[]} message.p
-     * @param {string} message.t
-     * @param {string} [address] IP/host address
-     * @param {number} [port] Port number
-     */
-    _sendRequest (message, address = this.device.address, port = this.device.port) {
-        const encryptedMessage = encryptionService.encrypt(message, this.device.key);
-        const request = {
-          cid: 'app',
-          i: 0,
-          t: 'pack',
-          uid: 0,
-          pack: encryptedMessage
-        };
-        const serializedRequest = new Buffer(JSON.stringify(request));
-        socket.send(serializedRequest, 0, serializedRequest.length, port, address);
-    };
-    
-    /**
-     * Turn on/off
-     * @param {boolean} value State
-     */
-    setPower (value) {
-        this._sendCommand(
-            [cmd.power.code],
-            [value ? 1 : 0]
-        );
-    };
-    
-    /**
-     * Set temperature
-     * @param {number} value Temperature
-     * @param {number} [unit=0] Units (defaults to Celsius)
-     */
-    setTemp (value, unit = cmd.temperatureUnit.value.celsius) {
-        this._sendCommand(
-            [cmd.temperatureUnit.code, cmd.temperature.code],
-            [unit, value]
-        );
-    };
-    
-    /**
-     * Set mode
-     * @param {number} value Mode value (0-4)
-     */
-    setMode (value) {
-        this._sendCommand(
-            [cmd.mode.code],
-            [value]
-        );
-    };
-    
-    /**
-     * Set fan speed
-     * @param {number} value Fan speed value (0-5)
-     */
-    setFanSpeed (value) {
-        this._sendCommand(
-            [cmd.fanSpeed.code],
-            [value]
-        );
-    };
-    
-    /**
-     * Set vertical swing
-     * @param {number} value Vertical swing value (0-11)
-     */
-    setSwingVert (value) {
-        this._sendCommand(
-            [cmd.swingVert.code],
-            [value]
-        );
-    };
-    
-};
-
-module.exports.connect = function(options) {
-    return new Device(options);
-};
-

package/app/encryptionService.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-
-/**
- * Module containing encryption services
- * @param {String} key AES general key
- */
-module.exports = function(defaultKey = 'a3K8Bx%2r8Y7#xDh') {
-    const EncryptionService = {
-
-        /**
-         * Decrypt UDP message
-         * @param {object} input Response object
-         * @param {string} input.pack Encrypted JSON string
-         * @param {string} [key] AES key
-         */
-        decrypt: (input, key = defaultKey) => {
-            const decipher = crypto.createDecipheriv('aes-128-ecb', key, '');
-            const str = decipher.update(input.pack, 'base64', 'utf8');
-            const response = JSON.parse(str + decipher.final('utf8'));
-            return response;
-        },
-
-        /**
-         * Encrypt UDP message
-         * @param {object} output Request object
-         * @param {string} [key] AES key
-         */
-        encrypt: (output, key = defaultKey) => {
-            const cipher = crypto.createCipheriv('aes-128-ecb', key, '');
-            const str = cipher.update(JSON.stringify(output), 'utf8', 'base64');
-            const request = str + cipher.final('base64');
-            return request;
-        }
-    };
-  
-    return EncryptionService; 
-};

package/example.config.json

@@ -1,20 +0,0 @@
-{
-    "bridge": {
-        "name": "Homebridge",
-        "username": "CC:22:3D:E3:CE:30",
-        "port": 51826,
-        "pin": "123-45-568"
-    },
-    "accessories": [
-        {
-            "accessory": "GreeAC",
-            "host": "192.168.1.X",
-            "name": "Office AC"
-        },
-        {
-            "accessory": "GreeAC",
-            "host": "192.168.1.Y",
-            "name": "Bedroom AC"
-        }
-    ]
-}

package/index.js

@@ -1,339 +0,0 @@
-'use strict';
-const commands = require('./app/commandEnums');
-var Accessory, Service, Characteristic;
-var mqtt = require('mqtt');
-
-module.exports = function(homebridge) {
-    Accessory = homebridge.platformAccessory;
-    Service = homebridge.hap.Service;
-    Characteristic = homebridge.hap.Characteristic;
-
-    homebridge.registerAccessory('homebridge-gree-ac', 'GreeAC', GreeAC);
-}
-
-function GreeAC(log, config) {
-    this.log = log;
-    this.name = config.name || 'Gree AC';
-    this.host = config.host || '192.168.1.255';
-    this.debug = ((config.debug || "false" ) === "true");
-    this.updateInterval = config.updateInterval || 10000;
-    this.currentTempTopic = config['currentTempTopic'] || "hvac/temperature";
-    this.mqttUrl = config['mqttUrl'] || "mqtt://127.0.0.1";
-    this.client_Id      = 'mqttjs_' + Math.random().toString(16).substr(2, 8);
-
-    this.mqttOptions = {
-    keepalive: 10,
-    clientId: this.client_Id,
-        protocolId: 'MQTT',
-    protocolVersion: 4,
-        clean: true,
-        reconnectPeriod: 1000,
-        connectTimeout: 30 * 1000,
-    serialnumber: config["serial"] || this.client_Id,
-    max_temperature: config["maxTemperature"] || 100,
-    min_temperature: config["minTemperature"] || -50,
-        username: config["username"],
-        password: config["password"],
-        will: {
-            topic: 'WillMsg',
-            payload: 'Connection Closed abnormally..!',
-            qos: 0,
-            retain: false
-        },
-        rejectUnauthorized: false
-    };
-
-    this.client  = mqtt.connect(this.mqttUrl, this.mqttOptions);
-
-    this.TargetHeatingCoolingState = Characteristic.TargetHeatingCoolingState.OFF;
-    this.TargetTemperature = 22;
-    this.CurrentTemperature = 0;
-    this.services = [];
-
-    this.GreeACService = new Service.Thermostat(this.name);
-    this.temperatureDisplayUnits = Characteristic.TemperatureDisplayUnits.CELSIUS;
-
-    this.GreeACService
-        .getCharacteristic(Characteristic.TemperatureDisplayUnits)
-        .on('get', this.getTemperatureDisplayUnits.bind(this))
-        .on('set', this.setTemperatureDisplayUnits.bind(this));
-
-    this.GreeACService
-        .getCharacteristic(Characteristic.TargetHeatingCoolingState)
-            .on('set', this.setTargetHeatingCoolingState.bind(this))
-            .on('get', this.getTargetHeatingCoolingState.bind(this));
-
-    this.GreeACService
-        .getCharacteristic(Characteristic.CurrentHeatingCoolingState)
-            .on('get', this.getTargetHeatingCoolingState.bind(this));
-
-    this.GreeACService
-        .getCharacteristic(Characteristic.TargetTemperature)
-            .setProps({
-                maxValue: 30,
-                minValue: 16,
-                minStep: 1
-            })
-            .on('set', this.setTargetTemperature.bind(this))
-            .on('get', this.getTargetTemperature.bind(this));
-
-    this.GreeACService
-        .getCharacteristic(Characteristic.CurrentTemperature)
-            .setProps({
-                maxValue: 30,
-                minValue: 16,
-                minStep: 1
-            })
-            .on('get', this.getCurrentTemperature.bind(this));
-
-    // this.GreeACService
-    //     .getCharacteristic(Characteristic.SwingMode)
-    //         .setProps({
-    //                     minValue: 0,
-    //                     maxValue: 11,
-    //                     minStep: 1
-    //                 })
-    //         .on('get', this.getSwing.bind(this))
-    //         .on('set', this.setSwing.bind(this));
-
-    // this.GreeACService
-    //     .getCharacteristic(Characteristic.RotationSpeed)
-    //             .setProps({
-    //                 minValue: 0,
-    //                 maxValue: 5,
-    //                 minStep: 1
-    //             })
-    //             .on('get', this.getRotationSpeed.bind(this))
-    //             .on('set', this.setRotationSpeed.bind(this));
-
-    this.services.push(this.GreeACService);
-
-    this.serviceInfo = new Service.AccessoryInformation();
-
-    this.serviceInfo
-        .setCharacteristic(Characteristic.Manufacturer, 'Gree')
-        .setCharacteristic(Characteristic.Model, 'Bora A5')
-        .setCharacteristic(Characteristic.SerialNumber, 'GREEBORAA5');
-
-    this.services.push(this.serviceInfo);
-
-    this.discover();
-}
-
-GreeAC.prototype = {
-
-    discover: function(){
-        var accessory = this;
-        var log = this.log;
-        var host = this.host;
-        var debug = this.debug;
-
-        const deviceOptions = {
-          host: host,
-          updateInterval: this.updateInterval,
-          onStatus: (deviceModel) => {
-            var device_power_status = deviceModel.props[commands.power.code];
-            var device_mode_status = deviceModel.props[commands.mode.code];
-            var device_temperature = deviceModel.props[commands.temperature.code];
-            var device_swingvert = deviceModel.props[commands.swingVert.code] === 0 ? 0:1;
-            accessory.TargetTemperature = parseFloat(device_temperature);
-
-            if (device_power_status === commands.power.value.off) {
-                  accessory.TargetHeatingCoolingState = Characteristic.TargetHeatingCoolingState.OFF;
-            } else if (device_mode_status === commands.mode.value.auto) {
-                  accessory.TargetHeatingCoolingState = Characteristic.TargetHeatingCoolingState.AUTO;
-            } else if  (device_mode_status === commands.mode.value.cool) {
-                  accessory.TargetHeatingCoolingState = Characteristic.TargetHeatingCoolingState.COOL;
-            } else if  (device_mode_status === commands.mode.value.heat) {
-                  accessory.TargetHeatingCoolingState = Characteristic.TargetHeatingCoolingState.HEAT;
-            } else {
-                  accessory.TargetHeatingCoolingState = Characteristic.TargetHeatingCoolingState.AUTO;
-            }
-
-            this.GreeACService
-                .getCharacteristic(Characteristic.TargetHeatingCoolingState)
-                .updateValue(accessory.TargetHeatingCoolingState);
-
-            this.GreeACService
-                .getCharacteristic(Characteristic.TargetTemperature)
-                .updateValue(accessory.TargetTemperature);
-
-            if (accessory.debug === true) {
-                this.log.info('Get mode: %s', device_mode_status.toString());
-                this.log.info('Get temperature %s', device_temperature.toString());
-                this.log.info('Get fanspeed %s', deviceModel.props[commands.fanSpeed.code].toString());
-                this.log.info('Get swingvert %s', device_swingvert.toString());
-                this.log.info('Get powerstatus %s', device_power_status.toString());
-            }
-          },
-          onUpdate: (deviceModel) => {
-            this.log.info('Status updated on %s', deviceModel.name)
-          },
-          onConnected: (deviceModel) => {
-            var accesorry = this;
-            accesorry.log.info('Connecting on %s with ip address %s[%d] debug=%s: %s', deviceModel.name, deviceModel.address, deviceModel.port, accesorry.debug, deviceModel.bound ? "SUCCESS": "FAIL");
-            accesorry.client.subscribe(this.currentTempTopic);
-            accesorry.client.on('message', function (topic, message) {
-                try {
-                  data = JSON.parse(message);
-                } catch (e) {
-                  return null;
-                }
-
-                if (data === null) {return null}
-                var that = this;
-                that.temperature = parseFloat(data);
-                if (!isNaN(that.temperature)) {
-                    if (accesorry.debug === true) {
-                        accesorry.log.info('Current temperature is ' + that.temperature);
-                    }
-                    accesorry.CurrentTemperature = parseFloat(that.temperature);
-                    accesorry.GreeACService
-                        .getCharacteristic(Characteristic.CurrentTemperature)
-                        .updateValue(accesorry.CurrentTemperature);
-                }
-            });
-          },
-          onError: (deviceModel) => {
-            if (this.debug === true) {
-                this.log.info('Connecting on %s with ip address %s[%d]: %s', deviceModel.name, deviceModel.address, deviceModel.port, deviceModel.bound ? "SUCCESS": "FAIL");
-            }
-          },
-          onDisconnected: (deviceModel) => {
-            if (this.debug === true ) {
-                this.log.info('Connecting on %s with ip address %s[%d]: %s', deviceModel.name, deviceModel.address, deviceModel.port, deviceModel.bound ? "SUCCESS": "FAIL");
-            }
-          }
-        };
-        accessory.hvac = require('./app/deviceFactory').connect(deviceOptions);
-    },
-
-    setTemperatureDisplayUnits: function(value, callback) {
-        if (this.debug === true) {
-            this.log.info("setTemperatureDisplayUnits from %s to %s", this.temperatureDisplayUnits, value);
-        }
-        this.temperatureDisplayUnits = value;
-        callback(null);
-    },
-    
-    getTemperatureDisplayUnits: function(callback) {
-        try {
-        this.temperatureDisplayUnits = this.hvac.device.props[commands.temperatureUnit.code];
-        if (this.debug === true) {
-            this.log.info("getTemperatureDisplayUnits: ", this.temperatureDisplayUnits);
-        }
-        callback(null, this.temperatureDisplayUnits);
-       } catch (err) {callback();}
-    },
-
-    getTargetHeatingCoolingState: function(callback) {
-      try
-      {
-        var state = Characteristic.TargetHeatingCoolingState.AUTO;
-        var accessory = this;
-        if (this.hvac.device.props[commands.power.code] === commands.power.value.off) {
-                  state = Characteristic.TargetHeatingCoolingState.OFF;
-        } else if (this.hvac.device.props[commands.mode.code] === commands.mode.value.auto) {
-                  state = Characteristic.TargetHeatingCoolingState.AUTO;
-        } else if  (this.hvac.device.props[commands.mode.code] === commands.mode.value.cool) {
-                  state = Characteristic.TargetHeatingCoolingState.COOL;
-        } else if  (this.hvac.device.props[commands.mode.code] === commands.mode.value.heat) {
-                  state = Characteristic.TargetHeatingCoolingState.HEAT;
-        }
-
-        accessory.TargetHeatingCoolingState = state;
-        callback(null, this.TargetHeatingCoolingState);
-      } catch (err) {
-         if (this.debug === true) {
-            this.log.info("getTemperatureDisplayUnits: error communicating with device");
-         }
-         callback();
-	}
-    },
-
-    setTargetHeatingCoolingState: function(TargetHeatingCoolingState, callback, context) {
-        try {
-        if(context !== 'fromSetValue') {
-            this.TargetHeatingCoolingState = TargetHeatingCoolingState;
-            if (this.TargetHeatingCoolingState === Characteristic.TargetHeatingCoolingState.OFF) {
-                this.hvac.setPower(commands.power.value.off);
-                if (this.debug === true){
-                    this.log.info('setTargetHeatingCoolingState: Set mode power off');
-                }
-            } else {
-                if (this.hvac.device.props[commands.power.code] === commands.power.value.off) {
-                  this.hvac.setPower(commands.power.value.on);
-                  if (this.debug === true){
-                        this.log.info('setTargetHeatingCoolingState: Set mode power on');
-                    }
-                }
-
-                if (this.TargetHeatingCoolingState === Characteristic.TargetHeatingCoolingState.HEAT) {
-                    this.hvac.setMode(commands.mode.value['heat']);
-                    if (this.debug === true) {
-                        this.log.info('setTargetHeatingCoolingState: Set mode to HEAT');
-                    }
-                }
-
-                if (this.TargetHeatingCoolingState === Characteristic.TargetHeatingCoolingState.COOL) {
-                    this.hvac.setMode(commands.mode.value['cool']);
-                    if (this.debug === true) {
-                        this.log.info('setTargetHeatingCoolingState: Set mode to COOL');
-                    }
-                }
-
-                if (this.TargetHeatingCoolingState === Characteristic.TargetHeatingCoolingState.AUTO) {
-                    this.hvac.setMode(commands.mode.value['auto']);
-                    if (this.debug === true) {
-                        this.log.info('setTargetHeatingCoolingState: Set mode to AUTO');
-                    }
-                }
-            }
-        }
-        callback();
-        } catch (err) {callback();}
-    },
-
-    getTargetTemperature: function(callback) {
-        try {
-        this.TargetTemperature = parseInt(this.hvac.device.props[commands.temperature.code]);
-        callback(null, this.TargetTemperature);
-        } catch (err) {callback();}
-    },
-
-    setTargetTemperature: function(TargetTemperature, callback, context) {
-        if(context !== 'fromSetValue') {
-            this.TargetTemperature = TargetTemperature;
-            // if ac is off, then turn it on by setting to auto mode 
-            if (this.TargetHeatingCoolingState == Characteristic.TargetHeatingCoolingState.OFF) {
-                this.hvac.setPower(commands.power.value.on);
-            }
-
-            // Update current temperature
-            // this.GreeACService
-            //     .getCharacteristic(Characteristic.CurrentTemperature)
-            //     .updateValue(parseFloat(TargetTemperature));
-            this.hvac.setTemp(parseInt(TargetTemperature));
-            if (this.debug === true) {
-                this.log.info('setTargetTemperature: Set temperature: ' + TargetTemperature);
-            }
-        }
-        callback();
-    },
-
-    getCurrentTemperature: function(callback) {
-        if (this.debug === true) {
-            this.log.info("getCurrentTemperature: current temperature is %s", this.CurrentTemperature);
-        }
-        callback(null, parseFloat(this.CurrentTemperature));
-    },
-
-    identify: function(callback) {
-        callback();
-    },
-
-    getServices: function() {
-        return this.services;
-    }
-};
-