homebridge-lockstate 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Tom Rodrigues
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/config.schema.json

@@ -0,0 +1,56 @@
+
+{
+  "pluginAlias": "lockstate",
+  "pluginType": "accessory",
+  "schema": {
+    	"type": "object",
+    	"properties": {
+      		"name": {
+       			"title": "plugin-name",
+        			"type": "string",
+			 
+     			 "required": true,
+      			"placeholder": "lockstate"
+      			
+        			
+      		},
+		"ip": {
+       			"title": "ip-address with server",
+        			"type": "string",
+ 			"required": true,
+			"placeholder": "10.0.0.30"
+        			
+      		},
+		"port": {
+       			"title": "the port",
+        			"type":"integer",
+ 			"required": true,
+			"placeholder": 8898
+        			
+      		},
+		"pollFrequency": {
+       			"title": "the pollFrequency",
+        			"type":"integer",
+			 "required": true,
+			"placeholder":1000
+        			
+      		},		
+		"timeout": {
+       			"title": "the timeout",
+        			"type":"integer",
+			 "required": true,
+			"placeholder":8000
+        			
+      		},
+		"unit": {
+       			"title": "the unit",
+        			"type":"integer",
+			 "required": true,
+			"placeholder":1
+        			
+      		}
+		
+	
+    	}
+ }
+}

package/index.js

@@ -0,0 +1,334 @@
+var Service, Characteristic, Homebridge
+const request = require('request')
+const packageJson = require('./package.json')
+const Net = require('net')
+const Modbus = require('jsmodbus')
+const STATE_UNSECURED = 0;
+const STATE_SECURED = 1;
+const STATE_JAMMED = 2;
+const STATE_UNKNOWN = 3;
+
+module.exports = function (homebridge) {
+  Homebridge = homebridge
+  Service = homebridge.hap.Service
+  Characteristic = homebridge.hap.Characteristic
+  homebridge.registerAccessory('homebridge-lockstate', 'lockstate',lockstate)
+}
+
+function lockstate(log, config) {
+    this.status = []
+    this.status_update = []
+  this.config = config
+  this.log = log
+  this.name = config.name
+  this.manufacturer = config.manufacturer || packageJson.author.name
+  this.serial = config.serial || packageJson.version
+  this.model = config.model || packageJson.name
+  this.firmware = config.firmware || packageJson.version
+
+  this.username = config.username || null
+  this.password = config.password || null
+  this.timeout = (config.httptimeout * 1000) || 5000
+  this.http_method = config.http_method || 'GET'
+
+  this.openURL = config.openURL
+  this.openBody = config.openBody || ''
+  this.openHeader = config.openHeader || null
+  this.closeURL = config.closeURL
+  this.closeBody = config.closeBody || ''
+  this.closeHeader = config.closeHeader || null
+
+  this.autoLock = config.autoLock || false
+  this.autoLockDelay = config.autoLockDelay || 5
+  
+  this.resetLock = config.resetLock || false
+    this.resetLockTime = config.resetLockTime || 5
+//   this.interval = setInterval(this.update.bind(this), this.config.pollFrequency || 1000);
+    this.currentState = STATE_SECURED;
+  this.targetState = this.currentState;
+  if (this.username != null && this.password != null) {
+    this.auth = {
+      user: this.username,
+      pass: this.password
+    }
+  }
+
+  this.log(this.name)
+  this.service = new Service.LockMechanism(this.name)
+
+
+
+    this.ip = {
+        'host': config.ip || '127.0.0.1',
+        'port': config.port || 502
+    }
+    this.socket = new Net.Socket();
+    this.modbus = new Modbus.client.TCP(this.socket, this.config.unit, this.config.timeout);
+    this.log("electromagnetic", config.unit, config.timeout)
+    this.flagscontect = false;
+    Homebridge.on("didFinishLaunching", () => {
+        this.socket.connect(this.ip);
+        this.log("Connecting to", this.ip.host);
+
+    });
+
+    this.socket.on('connect', () => {
+        this.log("Socket connected");
+        this.flagscontect = true;
+        flags_connect = true;
+        if (this.interval) {
+            clearInterval(this.interval);
+           
+        }
+    //    else {
+    //        this.update();
+    //    }
+         this.interval = setInterval(this.update.bind(this), this.config.pollFrequency || 1000);
+    });
+
+    this.socket.on('error', (error) => {
+        if (error) {
+            this.log(error);
+        }
+        this.log("error-Connection error");
+       // this.flagscontect = false;
+      
+        setTimeout(() => {
+            //this.socket.connect(this.ip);
+            this.log("error-Reconnecting to", this.ip.host);
+        }, 10000);
+    });
+
+    this.socket.on('close', (error) => {
+        if (error) {
+            this.log(error);
+        }
+        this.log("Connection lost");
+        this.flagscontect = false;
+       
+        setTimeout(() => {
+            this.socket.connect(this.ip);
+            this.log("Reconnecting to", this.ip.host);
+        }, 9000);
+    });
+}
+
+lockstate.prototype = {
+
+  identify: function (callback) {
+    this.log('Identify requested!')
+    callback()
+  },
+  _httpRequest: function (url, headers, body, method, callback) {
+    request({
+      url: url,
+      headers: headers,
+      body: body,
+      method: this.http_method,
+      timeout: this.timeout,
+      rejectUnauthorized: false,
+     auth: this.auth
+    },
+    function (error, response, body) {
+      callback(error, response, body)
+    })
+  },
+   update: function () {
+       
+      if (this.interval) {
+          this.modbus.readCoils(9, 1).then((resp) => {          //����״̬������Ϊ�������
+              this.status_update[0] = resp.response._body.valuesAsArray;
+
+              let val_update = parseInt(this.status_update[0]);
+           // if (parseInt(resp.response._body.valuesAsArray)) {
+           //   if (val_update != this.targetState) {
+
+                  if (val_update == 0) {
+                     
+                      //this.log('update-target-securd', val);
+                      this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(STATE_SECURED);
+                      this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(STATE_SECURED);
+
+                      this.targetState = STATE_SECURED
+                      this.currentState = STATE_SECURED
+                      //     this.service.setCharacteristic(Characteristic.LockCurrentState, Characteristic.LockCurrentState.SECURED)
+                      //    this.service.setCharacteristic(Characteristic.LockkTargetState, Characteristic.LockTargetState.SECURED)
+                  }
+                  else {
+                     
+                      //         this.log('update-target-unsecurd', val);
+                      this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(STATE_UNSECURED);
+                      this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(STATE_UNSECURED);
+                      this.targetState = STATE_UNSECURED
+                      this.currentState = STATE_UNSECURED
+
+                      //    this.service.setCharacteristic(Characteristic.LockCurrentState, Characteristic.LockCurrentState.UNSECURED)
+                      //    this.service.setCharacteristic(Characteristic.LockkTargetState, Characteristic.LockTargetState.UNSECURED)
+                  }
+           //   }
+          }).catch((error) => {
+              this.log("error-update");
+              this.reset();
+          });
+      //  this.log("writeing-every-time");
+      }  
+       
+  },
+   reset: function () {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+
+        this.flagscontect = false;
+        this.commands = [];
+        this.command = null;
+        if (flags_connect) {
+            this.log("error-rest-rest-rest");
+            flags_connect = false;
+            this.socket.end();
+        }
+        else {
+            this.log("error-norest-norest-norest");
+            //flags_connect = true;
+            //this.socket.end();
+        }
+  },
+   getLockTargetState: function (callback) {
+        this.log("Lock target state: %s", this.targetState);
+ 
+       // this.modbus.readCoils(9, 1).then((resp) => {          //����״̬������Ϊ�������
+       //       this.status_get_Target[0] = resp.response._body.valuesAsArray;
+       //       let val_get_Target = parseInt(this.status[0]);
+       //       if (val_get_Target == 0) {
+       //   //    if (parseInt(resp.response._body.valuesAsArray)) {
+      //            this.targetState = STATE_SECURED
+      //            this.currentState = STATE_SECURED
+      //         //   this.log('target-securd', val_get);
+      //        }
+      //        else {
+      //            this.targetState = STATE_UNSECURED
+      //            this.currentState = STATE_UNSECURED
+       //       //   this.log('target-unsecurd', val_get);
+        //      }
+        //      //   this.log('target-state', val_get);
+
+              callback(null, this.currentState);
+       //   }).catch((error) => {
+        //      this.log("error-getLockTargetStates-readCoils9-1");
+       //       this.reset();
+       //   });
+  },
+  getLockCurrentState: function (callback) {                    //�򿪼�ͥ������һ��
+    this.log("Lock Current state: %s", this.currentState);
+  
+  //  this.modbus.readCoils(9, 1).then((resp) => {              //����״̬������Ϊ�������
+  //      this.status[0] = resp.response._body.valuesAsArray;
+
+   //     let val = parseInt(this.status[0]);
+   //     if (val == 0){
+       // if (parseInt(resp.response._body.valuesAsArray)) { 
+   //          this.targetState = STATE_SECURED
+   //          this.currentState = STATE_SECURED
+   //            //   this.log('current-securd', val);
+   //     }
+    //
+  //      else {
+   //          this.targetState = STATE_UNSECURED
+   //          this.currentState = STATE_UNSECURED
+   //             //  this.log('current-unsecurd',val);
+   //     }
+     //        // this.log('current-state', val);
+        callback(null, this.currentState);
+  //  }).catch((error) => {
+  //      this.log("error-getLockCurrentStates-readCoils-9-1");
+  //      this.reset();
+  //  });
+  },
+
+  setLockTargetState: function (value, callback) {
+
+    var url
+    var body
+    var headers
+    this.log('[+] Setting LockTargetState to %s', value)
+    if (value == 1) {
+      url = this.closeURL
+      body = this.closeBody
+      headers = this.closeHeader
+    }else {
+      url = this.openURL
+      body = this.openBody
+      headers = this.openHeader
+      }
+  
+
+    this._httpRequest(url, headers, body, this.http_method, function (error, response, responseBody) {
+    	  }.bind(this))
+   	this.modbus.readCoils(9, 1).then((resp) => {          //����״̬������Ϊ�������
+              	this.status_update[0] = resp.response._body.valuesAsArray;
+	
+     	 });
+              	let val_update = parseInt(this.status_update[0]);
+        
+               value =  val_update;
+
+        if (value == 1) {
+           
+                this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(STATE_SECURED);
+                this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(STATE_SECURED);
+                this.targetState = STATE_SECURED
+                this.currentState = STATE_SECURED
+        } else {
+            
+                this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(STATE_UNSECURED);
+                this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(STATE_UNSECURED);
+                this.targetState = STATE_UNSECURED
+                this.currentState = STATE_UNSECURED
+        }
+        callback()
+  
+  },
+
+  autoLockFunction: function () {
+    this.log('[+] Waiting %s seconds for autolock', this.autoLockDelay)
+    setTimeout(() => {
+      this.service.setCharacteristic(Characteristic.LockTargetState, Characteristic.LockTargetState.SECURED)
+      this.log('[*] Autolocking')
+    }, this.autoLockDelay * 1000)
+  },
+  
+  resetLockFunction: function () {
+    this.log('[+] Waiting %s seconds for resetting lock state to locked', this.resetLockTime)
+    setTimeout(() => {
+	  this.service.getCharacteristic(Characteristic.LockCurrentState).updateValue(1)
+	  this.service.getCharacteristic(Characteristic.LockTargetState).updateValue(1)
+      this.log('[*] Lock State resetted')
+    }, this.resetLockTime * 1000)
+  },
+
+  getServices: function () {
+    this.service.setCharacteristic(Characteristic.LockCurrentState, Characteristic.LockCurrentState.SECURED)
+    this.service.setCharacteristic(Characteristic.LockTargetState, Characteristic.LockTargetState.SECURED)
+
+    this.informationService = new Service.AccessoryInformation()
+    this.informationService
+      .setCharacteristic(Characteristic.Manufacturer, this.manufacturer)
+      .setCharacteristic(Characteristic.Model, this.model)
+      .setCharacteristic(Characteristic.SerialNumber, this.serial)
+      .setCharacteristic(Characteristic.FirmwareRevision, this.firmware)
+      this.service
+          .getCharacteristic(Characteristic.LockCurrentState)
+          .on("get", this.getLockCurrentState.bind(this))
+
+      this.service
+          .getCharacteristic(Characteristic.LockTargetState)
+          .on('get', this.getLockTargetState.bind(this))
+	//.on('set', this.getLockTargetState.bind(this))
+          .on('set', this.setLockTargetState.bind(this))
+
+    return [this.informationService, this.service]
+  }
+}
+
+
+

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "homebridge-lockstate",
+  "version": "1.0.1",
+  "description": "lock",
+  "main": "index.js",
+  "keywords": [
+    "homebridge-plugin",
+    "lock"
+  ],
+  "author": "masm32",
+  "license": "MIT",
+  "engines": {
+    "homebridge": ">=0.2.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "ajv": "^6.12.6",
+    "asn1": "^0.2.6",
+    "assert-plus": "^1.0.0",
+    "asynckit": "^0.4.0",
+    "aws-sign2": "^0.7.0",
+    "aws4": "^1.13.2",
+    "bcrypt-pbkdf": "^1.0.2",
+    "caseless": "^0.12.0",
+    "combined-stream": "^1.0.8",
+    "core-util-is": "^1.0.2",
+    "crc": "^3.4.0",
+    "dashdash": "^1.14.1",
+    "debug": "^3.2.7",
+    "delayed-stream": "^1.0.0",
+    "ecc-jsbn": "^0.1.2",
+    "extend": "^3.0.2",
+    "extsprintf": "^1.3.0",
+    "fast-deep-equal": "^3.1.3",
+    "fast-json-stable-stringify": "^2.1.0",
+    "forever-agent": "^0.6.1",
+    "form-data": "^2.3.3",
+    "getpass": "^0.1.7",
+    "har-schema": "^2.0.0",
+    "har-validator": "^5.1.5",
+    "http-signature": "^1.2.0",
+    "is-typedarray": "^1.0.0",
+    "isstream": "^0.1.2",
+    "jsbn": "^0.1.1",
+    "jsmodbus": "^4.0.10",
+    "json-schema": "^0.4.0",
+    "json-schema-traverse": "^0.4.1",
+    "json-stringify-safe": "^5.0.1",
+    "jsprim": "^1.4.2",
+    "mime-db": "^1.52.0",
+    "mime-types": "^2.1.35",
+    "ms": "^2.1.3",
+    "oauth-sign": "^0.9.0",
+    "performance-now": "^2.1.0",
+    "psl": "^1.15.0",
+    "punycode": "^2.3.1",
+    "qs": "^6.5.3",
+    "request": "^2.88.2",
+    "safe-buffer": "^5.2.1",
+    "safer-buffer": "^2.1.2",
+    "sshpk": "^1.18.0",
+    "tough-cookie": "^2.5.0",
+    "tunnel-agent": "^0.6.0",
+    "tweetnacl": "^0.14.5",
+    "uri-js": "^4.4.1",
+    "uuid": "^3.4.0",
+    "verror": "^1.10.0"
+  },
+  "devDependencies": {}
+}