@jotiotech/node-red-sia-premise-device 0.2.2 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jotiotech/node-red-sia-premise-device",
-    "version": "0.2.2",
+    "version": "1.0.0",
     "engines": {
         "node": ">=12.0.0"
     },

package/src/SIA_device.html

@@ -9,7 +9,7 @@
 		align: 'left',
 		icon: "icon.png",
 		inputs: 1,
-		outputs: 0,
+		outputs: 2,
 		label: function () {
 			return this.name || "SIA Device";
 		},

package/src/SIA_device.js

@@ -1,98 +1,147 @@
-// const { Iconv } = require('iconv');
-
+// Const { Iconv } = require('iconv');
 
 module.exports = function (RED) {
-	const tableCRC = [
-	0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
-	0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
-	0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
-	0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
-	0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
-	0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
-	0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
-	0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
-	0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
-	0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
-	0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
-	0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
-	0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
-	0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
-	0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
-	0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
-	0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
-	0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
-	0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
-	0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
-	0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
-	0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
-	0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
-	0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
-	0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
-	0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
-	0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
-	0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
-	0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
-	0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
-	0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
-	0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040
-	];
-
-	const deviceMap = new Map();
-	const crypto = require('crypto');
-
-
+	const deviceSeqNumbers = new Map();
+	const crypto = require('node:crypto');
+	const tableCRC = require('./table_crc.js');
 
 	function SIADeviceNode(config) {
 		RED.nodes.createNode(this, config);
 
 		// TODO: eventually we should disconnect from the server after each message as there shouldn't be a high volume of messages
 		const server = RED.nodes.getNode(config.server);
-
+		const pendingMessages = new Map();
 		const siaConfig = server.getSIAConfig();
+		const node = this;
 		console.log('SIA Config:', siaConfig);
 
+		// Cleanup on close
 
-		server.connect();
+		// --- LISTENER FUNCTION ---
+		const dataListener = data => {
+			const response = data.toString();
+			let seq; let type;
+
+			// Format: <LF><CRC><OLLL><"ID"><seq>...
+			const match = response.match(/"(\*?ACK|\*?DUH|NAK)"(\d{4})/);
+			console.log('-----------------------------------------\n'
+				+ '            SERVER RESPONSE                \n'
+				+ '-----------------------------------------');
 
+			console.log('Received message:', response);
 
+			if (!match) {
+				return;
+			}
 
-		function utf8toWin1252(str) {
-			tmpBuf = Buffer.from(str, 'utf8');
+			type = match[1].replace('*', ''); // "ACK", "DUH", or "NAK"
+			seq = match[2]; // The 4-digit sequence number as a string
+
+			// Handle uncorrectable NAK (seq 0000), likely for a timestamp error
+			if (type === 'NAK' && seq === '0000') {
+				node.warn('Received uncorrelatable NAK (seq 0000). Erroring all pending requests for this node.');
+				for (const [key, pending] of pendingMessages.entries()) {
+					if (pending.node === node) {
+						clearTimeout(pending.timeoutTimer);
+						pending.node.error('Received uncorrelatable NAK (seq 0000) from server', pending.originalMsg);
+						pendingMessages.delete(key);
+					}
+				}
+				return;
+			}
+
+			if (pendingMessages.has(seq)) {
+				const pending = pendingMessages.get(seq);
+				if (pending.node !== node) {
+					return;
+				} // Just in case we ever run multiple nodes
+
+				clearTimeout(pending.timeoutTimer);
+				switch (type) {
+					case 'ACK': { // Success!
+						pending.node.log(`ACK received for seq ${seq}`);
+						pending.node.send([null, {payload:{
+							error : false,
+							status : "received ACK",
+							response: response
+						}
+						}]); // Send to second output
+						break;
+					}
+
+					case 'NAK': { // NAK response
+						pending.node.error(`Received NAK from server for seq ${seq}`, pending.originalMsg);
+						break;
+					}
+
+					case 'DUH': { // DUH response
+						pending.node.error(`Received DUH from server for seq ${seq}`, pending.originalMsg);
+						break;
+					}
+				}
+
+				pendingMessages.delete(seq);
+			} else {
+				node.log(`Received unknown or stale response for seq ${seq}`);
+			}
+		};
+
+		node.on('close', done => {
+			if (server) {
+				server.removeListener('data', dataListener);
+			}
+
+			for (const [key, pending] of pendingMessages.entries()) {
+				if (pending.node === node) {
+					clearTimeout(pending.timeoutTimer);
+					pendingMessages.delete(key);
+				}
+			}
+
+			done();
+		});
+
+		server.connect();
+		server.on('data', dataListener);
+
+		// --- HELPER FUNCTIONS ---
+		function utf8toWin1252(string_) {
+			tmpBuf = Buffer.from(string_, 'utf8');
 			return tmpBuf.toString('latin1');
 		}
 
-		function calculateCRCIBM16(str){
-			data = new Buffer.from(str);
-			let len = data.length;
+		function calculateCRCIBM16(string_) {
+			data = new Buffer.from(string_);
+			let {length} = data;
 			let buffer = 0;
 			let crc;
-			while (len--) {
-					crc = ((crc >>> 8) ^ (tableCRC[(crc ^ (data[buffer++])) & 0xff]));
+			while (length--) {
+				crc = ((crc >>> 8) ^ (tableCRC[(crc ^ (data[buffer++])) & 0xFF]));
 			}
+
 			return crc.toString(16).padStart(4, '0').toUpperCase();
 		}
 
-		function encrypt(encryptionType, encryptionKey, str) {
-				try {
-						const encryptionKeyBuf = new Buffer.from(encryptionKey, 'hex');
-						let iv = new Buffer.alloc(16);
-						iv.fill(0);
-						let cipher = crypto.createCipheriv(encryptionType, encryptionKeyBuf, iv);
-						cipher.setAutoPadding(false);
-						let encoded = cipher.update(str, 'utf8', 'hex');
-						encoded += cipher.final('hex');
-						return (encoded ? encoded : undefined);
-				} catch (e) {
-						return undefined;
-				}
+		function encrypt(encryptionType, encryptionKey, string_) {
+			try {
+				const encryptionKeyBuf = new Buffer.from(encryptionKey, 'hex');
+				const iv = new Buffer.alloc(16);
+				iv.fill(0);
+				const cipher = crypto.createCipheriv(encryptionType, encryptionKeyBuf, iv);
+				cipher.setAutoPadding(false);
+				let encoded = cipher.update(string_, 'utf8', 'hex');
+				encoded += cipher.final('hex');
+				return (encoded ? encoded : undefined);
+			} catch {
+				return undefined;
+			}
 		}
 
-
-		function generateTimestamp(){
+		function generateTimestamp() {
 			const now = new Date();
 
 			// Pad single-digit numbers with a leading zero
-			const pad = (num) => num.toString().padStart(2, '0');
+			const pad = number_ => number_.toString().padStart(2, '0');
 
 			const hours = pad(now.getHours());
 			const minutes = pad(now.getMinutes());
@@ -102,115 +151,121 @@ module.exports = function (RED) {
 			const year = now.getFullYear();
 
 			return `_${hours}:${minutes}:${seconds},${month}-${day}-${year}`;
-
 		}
 
-		function generatePadding(data){
-			buffer = new Buffer.from(data); // we need to get byte length of the message body, not string length
-			let msgLength = buffer.length;
+		function generatePadding(data) {
+			buffer = new Buffer.from(data); // We need to get byte length of the message body, not string length
+			const messageLength = buffer.length;
 
 			let padding = '';
-			if(msgLength % 16 !== 0){
-				const paddingNeeded = 15 - (msgLength % 16);
-				// generate random uppercase letters (only letters) for paddingNeeded
-				for(let i=0; i<paddingNeeded; i++){
+			if (messageLength % 16 !== 0) {
+				const paddingNeeded = 15 - (messageLength % 16);
+				// Generate random uppercase letters (only letters) for paddingNeeded
+				for (let i = 0; i < paddingNeeded; i++) {
 					const randomChar = String.fromCharCode(65 + Math.floor(Math.random() * 26));
 					padding += randomChar;
 				}
-				// generate byte array
+
+				// Generate byte array
 				console.log('Padding needed:', paddingNeeded, 'Generated padding:', padding);
-				return padding+'|';
-			}else
-				return '';
-		}
+				return padding + '|';
+			}
 
+			return '';
+		}
 
-		function validateHexString(str, strName, minLength, maxLength){ // NOTE LGTM
-			if(str.length < minLength || str.length > maxLength){
-				console.error(`${strName} must be between ${minLength} and ${maxLength} characters long`);
+		function validateHexString(string_, stringName, minLength, maxLength) {
+			if (string_.length < minLength || string_.length > maxLength) {
+				console.error(`${stringName} must be between ${minLength} and ${maxLength} characters long`);
 				return false;
-
 			}
 
-			if(str.length !=0 &&  !/^[0-9A-Fa-f]+$/.test(str)){
-				console.error(`${strName} must be hexadecimal characters only (0-9, A-F)`);
+			if (string_.length > 0 && !/^[\dA-Fa-f]+$/.test(string_)) {
+				console.error(`${stringName} must be hexadecimal characters only (0-9, A-F)`);
 				return false;
 			}
+
 			return true;
 		}
 
-		function iterateMsgCount(id){ // NOTE LGTM
-			if(!deviceMap.has(id)){
-				deviceMap.set(id, 1);
-			}else{
-				let count = deviceMap.get(id);
-				count = (count % 9999) + 1; // wrap around at 999
-				deviceMap.set(id, count);
+		function iterateMessageCount(id) {
+			if (deviceSeqNumbers.has(id)) {
+				let count = deviceSeqNumbers.get(id);
+				count = (count % 9999) + 1; // Wrap around at 999
+				deviceSeqNumbers.set(id, count);
+			} else {
+				deviceSeqNumbers.set(id, 1);
 			}
 		}
 
-		// utf8toWin1252("a test ñ");
-
-
-		this.on('input', message => {
-			// const payload = message.payload;
-
-			let payload = {
-				"account" : "AABBCC",
-				"accountPrefix" : "5678"
-			}
-			siaConfig.receiverNumber = "1234";
+		// --- PROCESS NEW MESSAGE ---
+		node.on('input', message => {
+			console.log('-----------------------------------------\n'
+				+ '            MESSAGE START                \n'
+				+ '-----------------------------------------');
+			const payload = message.payload;
 
 			const deviceAccount = payload.account;
 			const deviceAccountPrefix = payload.accountPrefix || '0';
 
 			// INPUT VALIDATION
+			if (!validateHexString(deviceAccount, 'Device account', 3, 16)) {
+				return;
+			}
 
-			if(!validateHexString(deviceAccount, 'Device account', 3, 16)) return;
-			if(!validateHexString(deviceAccountPrefix, 'Device account prefix', 1, 6)) return;
-			if(!validateHexString(siaConfig.receiverNumber, 'Receiver number', 0, 6)) return;
+			if (!validateHexString(deviceAccountPrefix, 'Device account prefix', 1, 6)) {
+				return;
+			}
 
-			const	deviceIdentifier = 'L'+ deviceAccountPrefix + '#' + deviceAccount;
+			if (!validateHexString(siaConfig.receiverNumber, 'Receiver number', 0, 6)) {
+				return;
+			}
 
-			iterateMsgCount(deviceIdentifier);
+			const	deviceIdentifier = 'L' + deviceAccountPrefix + '#' + deviceAccount;
 
+			iterateMessageCount(deviceIdentifier);
 
-      // PART: <"id"><seq><Rrcvr><Lpref><#acct>[
+			// PART: <"id"><seq><Rrcvr><Lpref><#acct>[
 			let messageBodyStart = '"'; // <"id"><seq><Rrcvr><Lpref><#acct>[
-			if(siaConfig.encryptionEnabled)
+			if (siaConfig.encryptionEnabled) {
 				messageBodyStart += '*';
+			}
+
+			messageBodyStart += 'SIA-DCS"'; // ID placeholder
+			const seqNumber = deviceSeqNumbers.get(deviceIdentifier).toString().padStart(4, '0');
+
+			messageBodyStart += seqNumber; // Message sequence number
+			if (siaConfig.receiverNumber.length > 0) {
+				messageBodyStart += 'R' + siaConfig.receiverNumber;
+			}
 
-			messageBodyStart += 'SIA-DCS"' // ID placeholder
-			messageBodyStart += deviceMap.get(deviceIdentifier).toString().padStart(4, '0'); // message sequence number
-			if(siaConfig.receiverNumber.length >0)
-				messageBodyStart += 'R'+siaConfig.receiverNumber;
 			messageBodyStart += deviceIdentifier;
 			messageBodyStart += '[';
 
-
 			// PART: #<acct>|<data>][<extende data>]
-			let messageBodyData = '#'+deviceAccount + '|';  // <pad>|...data...][x…data…]
+			let messageBodyData = '#' + deviceAccount + '|'; // <pad>|...data...][x…data…]
 
 			// data format
 			// (N)(id-number)(DCS)(zone)
 			// there's also a format of group-zone
 
-			// messageBodyData += "NFA"; //
-			messageBodyData += "Nri129/FA1234"; //
+			// messageBodyData += "Nri129^FA"; //
+			messageBodyData += payload.body;
+			// messageBodyData += 'Nri129/FA1234'; //
 			// optional extended data can be added here, for example
 
 			// PART: ]<timestamp>, finalization of body
 			let messageBody = ''; // <"id"><seq><Rrcvr><Lpref><#acct>[<pad>|...data...][x…data…]<timestamp>
-			let timestamp = generateTimestamp(); // TODO: this should be optional
+			const timestamp = generateTimestamp(); // TODO: this should be optional
 
-			if(siaConfig.encryptionEnabled){ // everything past [ till <CR> is to be encrypted
-				let toEncrypt = messageBodyData+']'+timestamp;
+			if (siaConfig.encryptionEnabled) { // Everything past [ till <CR> is to be encrypted
+				let toEncrypt = messageBodyData + ']' + timestamp;
 				toEncrypt = generatePadding(toEncrypt) + toEncrypt;
 				messageBody = messageBodyStart + encrypt(siaConfig.encryptionType, siaConfig.encryptionKey, toEncrypt);
-			}else{
+			} else {
 				messageBody += messageBodyStart;
 				messageBody += messageBodyData;
-				messageBody += ']'; // end of data fields
+				messageBody += ']'; // End of data fields
 				// optional extended data
 				messageBody += timestamp;
 			}
@@ -218,21 +273,51 @@ module.exports = function (RED) {
 			// Append <LF><crc><>
 			msgCount = (new Buffer.from(messageBody)).length;
 
-			let msg = '\n'; // <LF><crc><0LLL><"id"><seq><Rrcvr><Lpref><#acct>[<pad>|...data...][x…data…]<timestamp><CR>
-			msg += calculateCRCIBM16(messageBody); // CRC is 4 ASCII characters
-			msg += '0'+msgCount.toString(16).toUpperCase().padStart(3, '0'); // Carriage return
-			msg += messageBody;
-			msg += '\r';
-
-			// let hexMsg = '';
-			// for(let i=0; i<msg.length; i++){
-			// 	hexMsg += msg.charCodeAt(i).toString(16).padStart(2, '0').toUpperCase() + ' ';
-			// }
-			// console.log('Final message in hex: ', hexMsg);
-
-		server.connect();
-			server.write(msg);
-			server.close();
+			let message_ = '\n'; // <LF><crc><0LLL><"id"><seq><Rrcvr><Lpref><#acct>[<pad>|...data...][x…data…]<timestamp><CR>
+			const crc = calculateCRCIBM16(messageBody);
+			console.log("Final message CRC: ", crc);
+
+			message_ += crc; // CRC is 4 ASCII characters
+			message_ += '0' + msgCount.toString(16).toUpperCase().padStart(3, '0'); // Carriage return
+			message_ += messageBody;
+			message_ += '\r';
+
+			console.log('Final message:', message_);
+			console.log('Sending message to server');
+
+			pendingMessages.set(seqNumber, {
+				node,
+				originalMsg: message,
+				timestamp: Date.now(),
+				timeoutTimer: setTimeout(() => {
+					if (pendingMessages.has(seqNumber)) {
+						node.error(`Timeout waiting for ACK on seq ${seqNumber}`, message);
+						node.status({fill: 'red', shape: 'dot', text: 'Timeout ' + seqNumber});
+						node.send([null, {
+							payload: {
+								error: true,
+								status: 'timeout on message',
+								message: message
+							},
+						}]);
+						pendingMessages.delete(seqNumber);
+					}
+				}, 5000), // 5 Second timeout
+			});
+
+			node.log(`Sending SIA message seq: ${seqNumber}`);
+			node.status({fill: 'blue', shape: 'dot', text: 'Sent ' + seqNumber});
+
+
+			server.write(message_);
+
+			node.send([{
+				payload: {
+					error: false,
+					status: 'sent message',
+					message: message_
+				},
+			}, null]); // Send to first output
 		});
 	}
 

package/src/SIA_server.html

@@ -56,7 +56,7 @@
 				<input type="text" id="node-config-input-name" placeholder="Name">
 		</div>
 		<div class="form-row">
-				<label for="node-config-input-receiverHost">Receiver IP</label>
+				<label for="node-config-input-receiverHost">Receiver</label>
 				<input type="text" id="node-config-input-receiverHost" placeholder="Receiver Host">
 		</div>
 		<div class="form-row">
@@ -65,7 +65,7 @@
 		</div>
 		<div class="form-row">
 				<label for="node-config-input-receiverNumber">Receiver Number</label>
-				<input type="number" id="node-config-input-receiverNumber" placeholder="Receiver Number">
+				<input type="text" id="node-config-input-receiverNumber" placeholder="Receiver Number">
 		</div>
 		<div class="form-row">
 				<label for="node-config-input-encryptionKey">Encryption Key</label>

package/src/SIA_server.js

@@ -8,29 +8,36 @@ module.exports = function (RED) {
 	function SIAServer(config) {
 		RED.nodes.createNode(this, config);
 
-		this.receiverHost = config.receiverHost;
-		this.receiverPort = Number.parseInt(config.receiverPort);
-		this.receiverNumber = config.receiverNumber || '';
+		const node = this;
+
+		node.receiverHost = config.receiverHost;
+		node.receiverPort = Number.parseInt(config.receiverPort);
+		node.receiverNumber = config.receiverNumber || '';
 		// This.siaAccount = config.siaAccount;
-		// this.siaAccountPrefix = config.siaAccountPrefix || 'L0';
-		this.encryptionKey = config.encryptionKey || '';
-		this.encryptionEnabled = this.encryptionKey.length > 0;
-
-		switch (this.encryptionKey.length) {
-				case 32:
-						this.encryptionType = 'aes-128-cbc';
-						break;
-				case 48:
-						this.encryptionType = 'aes-192-cbc';
-						break;
-				case 64:
-						this.encryptionType = 'aes-256-cbc';
-						break;
-				default:
-						return undefined;
-		}
+		// node.siaAccountPrefix = config.siaAccountPrefix || 'L0';
+		node.encryptionKey = config.encryptionKey || '';
+		node.encryptionEnabled = node.encryptionKey.length > 0;
+
+		switch (node.encryptionKey.length) {
+			case 32: {
+				node.encryptionType = 'aes-128-cbc';
+				break;
+			}
+
+			case 48: {
+				node.encryptionType = 'aes-192-cbc';
+				break;
+			}
 
+			case 64: {
+				node.encryptionType = 'aes-256-cbc';
+				break;
+			}
 
+			default: {
+				node.encryptionType = '';
+			}
+		}
 
 		const client = new Net.Socket();
 
@@ -39,18 +46,39 @@ module.exports = function (RED) {
 			client.destroy();
 		});
 
-		this.connect = function () {
+		client.on('data', data => {
+			// Emits to any SIA-device listening via server.on('data', ...)
+			console.log("Received some message", data);
+			node.emit('data', data);
+		});
+
+		client.on('error', error => {
+			console.error('SIA Socket Error:', error.message);
+			node.emit('socketError', error); // Notify devices if needed
+		});
+
+		client.on('connect', () => {
+			node.emit('connected');
+		});
+
+		client.on('close', () => {
+			node.emit('closed');
+		});
+
+		// -------------
+
+		node.connect = function () {
 			// If(!client.destroyed && client.readyState == 'open') {
-			// 	console.log('Already connected to SIA server at ' + this.receiverHost + ':' + this.receiverPort);
+			// 	console.log('Already connected to SIA server at ' + node.receiverHost + ':' + node.receiverPort);
 			// 	return;
 			// }
 
-			if (!this.receiverHost || !this.receiverPort) {
+			if (!node.receiverHost || !node.receiverPort) {
 				console.error('Receiver host or port not set');
 				return;
 			}
 
-			console.log('Connecting to SIA server at', this.receiverHost, this.receiverPort);
+			console.log('Connecting to SIA server at', node.receiverHost, node.receiverPort);
 
 			const operation = Retry.operation({
 				retries: 5,
@@ -60,18 +88,16 @@ module.exports = function (RED) {
 				randomize: true,
 			});
 
-			const tmpRef = this;
+			const temporaryRef = node;
 
 			let errorListener = null;
 
-
 			const connectCallback = () => {
-				console.log('Connected to SIA server at', tmpRef.receiverHost, tmpRef.receiverPort);
+				console.log('Connected to SIA server at', temporaryRef.receiverHost, temporaryRef.receiverPort);
 			};
 
 			operation.attempt(currentAttempt => {
-
-				if (errorListener) { // will not be active on first attempt
+				if (errorListener) { // Will not be active on first attempt
 					client.off('error', errorListener);
 					client.off('connect', connectCallback);
 				}
@@ -88,27 +114,27 @@ module.exports = function (RED) {
 
 				client.once('error', errorListener);
 
-				client.connect(tmpRef.receiverPort, tmpRef.receiverHost, connectCallback);
+				client.connect(temporaryRef.receiverPort, temporaryRef.receiverHost, connectCallback);
 			});
 		};
 
-		this.getSIAConfig = function () {
+		node.getSIAConfig = function () {
 			return {
-				receiverNumber: this.receiverNumber,
-				encryptionKey: this.encryptionKey,
-				encryptionEnabled: this.encryptionEnabled,
-				encryptionType: this.encryptionType,
+				receiverNumber: node.receiverNumber,
+				encryptionKey: node.encryptionKey,
+				encryptionEnabled: node.encryptionEnabled,
+				encryptionType: node.encryptionType,
 			};
 		};
 
-		this.write = function (data) {
+		node.write = function (data) {
 			if (!client.destroyed && client.readyState == 'open') {
 				console.log('Sending data to SIA server:', data);
 				client.write(data);
 			}
 		};
 
-		this.close = function () {
+		node.close = function () {
 			if (!client.destroyed) {
 				client.end();
 			}

package/src/table_crc.js

@@ -0,0 +1,36 @@
+	const tableCRC = [
+	0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
+	0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
+	0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
+	0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
+	0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
+	0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
+	0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
+	0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
+	0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
+	0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
+	0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
+	0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
+	0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
+	0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
+	0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
+	0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
+	0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
+	0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
+	0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
+	0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
+	0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
+	0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
+	0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
+	0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
+	0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
+	0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
+	0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
+	0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
+	0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
+	0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
+	0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
+	0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040
+	];
+
+module.exports = tableCRC;