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

package/README.md

@@ -1,6 +1,17 @@
 # SIA Device
 
-TODO
+Simple node-red library that manages connection to SIA server and helps with creation of packets to send to if from connected devices.
+It just acts as a middle man that for now takes the SIA body and creates rest of the packet to send to the server and handles the ACK or lack of ACK from it.
+
+For now just basic body is supported (not extended one with things like position and what not) and the user needs to create the body in correct SIA format that will get interpreted by the server.
+However in future releases it's planned to have a much more streamline approach where user just sends code, name, id, zone area and what not and node will create the body by itself.
+
+Server is configured in it's special node, on the input to SIA Device node user must input following parameters. Account setting will be provided by your SIA server administrator.
+
+```
+payload.account - hex string with account number
+payload.accountPrefix - hex string with account prefix
+payload.body - SIA payload body, e.g. Nri129^^pi4^FA
+```
 
-Warning: ONLY ASCII characters are supported, if you ever try to use UTF8 it will not be converted to Windows-1252 and on the receiving end you will end up with gibberish.
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jotiotech/node-red-sia-premise-device",
-    "version": "0.2.2",
+    "version": "1.0.1",
     "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,145 @@
-// 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;
+			}
+
+			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;
+					}
+				}
 
-		function utf8toWin1252(str) {
-			tmpBuf = Buffer.from(str, 'utf8');
+				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 +149,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 +271,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

@@ -1,12 +1,3 @@
-<!--
-	Copyright (c) since the year 2016 Klaus Landsdorf (http://plus4nodered.com/)
-	Copyright 2016 - Jason D. Harper, Argonne National Laboratory
-	Copyright 2015,2016 - Mika Karaila, Valmet Automation Inc.
-	All rights reserved.
-	node-red-contrib-modbus
-
-	@author <a href="mailto:klaus.landsdorf@bianco-royal.de">Klaus Landsdorf</a> (Bianco Royal)
--->
 <script type="text/javascript">
 	RED.nodes.registerType('SIA-server', {
 		category: 'config',
@@ -56,7 +47,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 +56,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;