@ncd-io/node-red-enterprise-sensors 1.0.4 → 1.0.6

package/lib/WirelessGateway.js

@@ -142,7 +142,7 @@ module.exports = class WirelessSensor{
 				}
 			}
 			// #OTF
-			var otf_devices = [23,26,39,45,48,52,76,78,79,80,81,82,84,88,89,90,91,101,102,105,106,107,108,110,111,112,114,180,181,519,520,521,531,535,537,538,539,540,1010,1011];
+			var otf_devices = [23,26,39,45,48,52,58,76,78,79,80,81,82,84,88,89,90,91,101,102,105,106,107,108,110,111,112,114,180,181,519,520,521,531,535,537,538,539,540,1010,1011];
 			var device_type = msbLsb(frame.data[6], frame.data[7]);
 			// var device_type = frame.data[7];
 
@@ -294,7 +294,7 @@ module.exports = class WirelessSensor{
 		};
 
 		// #OTF
-		var otf_devices = [23,26,39,45,48,52,76,78,79,80,81,82,84,88,89,90,91,101,102,105,106,107,108,110,111,112,114,180,181,519,520,521,531,535,537,538,539,540,1010,1011];
+		var otf_devices = [23,26,39,45,48,52,58,76,78,79,80,81,82,84,88,89,90,91,101,102,105,106,107,108,110,111,112,114,180,181,519,520,521,531,535,537,538,539,540,1010,1011];
 		if(otf_devices.includes(parsed.sensor_type)){
 			// If the message says FLY and there is not FLY timer in progress.
 			if(payload[8] == 70 && payload[9] == 76 && payload[10] == 89) {
@@ -712,7 +712,7 @@ module.exports = class WirelessSensor{
 					data: payload.slice(8)
 				};
 				// #OTF
-			}else if(parsed.sensor_type == 80 ||  parsed.sensor_type == 81 || parsed.sensor_type == 82 || parsed.sensor_type == 84 || parsed.sensor_type == 180 || parsed.sensor_type == 181 || parsed.sensor_type == 515 || parsed.sensor_type == 519 || parsed.sensor_type == 537 || parsed.sensor_type == 538){
+			}else if(parsed.sensor_type == 80 ||  parsed.sensor_type == 81 || parsed.sensor_type == 82 || parsed.sensor_type == 84 || parsed.sensor_type == 180 || parsed.sensor_type == 181 || parsed.sensor_type == 515 || parsed.sensor_type == 519 || parsed.sensor_type == 531 || parsed.sensor_type == 537 || parsed.sensor_type == 538){
 				parsed.sensor_data = this.sensor_types[parsed.sensor_type].parse(payload, parsed, frame.mac);
 				if(!parsed.sensor_data){
 					return;
@@ -1307,8 +1307,8 @@ module.exports = class WirelessSensor{
 		console.log(packet);
 		return this.config_send(sensor_mac, packet);
 	}
-	config_enable_stay_on_mode_539(sensor_mac, value){
-		console.log('config_enable_stay_on_mode_539');
+	config_set_stay_on_mode_539(sensor_mac, value){
+		console.log('config_set_stay_on_mode_539');
 		var packet = [247, 50, 0, 0, 0, value];
 		console.log(packet);
 		return this.config_send(sensor_mac, packet);
@@ -1371,6 +1371,18 @@ module.exports = class WirelessSensor{
 		console.log(packet);
 		return this.config_send(sensor_mac, packet);
 	}
+	config_set_number_of_read_retries_539(sensor_mac, value){
+		console.log('config_set_number_of_read_retries_539');
+		var packet = [244, 55, 0, 0, 23, value];
+		console.log(packet);
+		return this.config_send(sensor_mac, packet);
+	}
+	config_set_read_parameter_539(sensor_mac, value){
+		console.log('config_set_read_parameter_539');
+		var packet = [244, 57, 0, 0, 23, value];
+		console.log(packet);
+		return this.config_send(sensor_mac, packet);
+	}
 	config_set_auto_raw_interval_110(sensor_mac, value){
 		console.log('config_set_raw_interval_110');
 		var packet = [244, 79, 0, 0, 80, 76, value];
@@ -1407,28 +1419,58 @@ module.exports = class WirelessSensor{
 	}
 	config_set_current_calibration_13(sensor_mac, calib){
 		console.log('config_set_current_calibration_13');
+		calib = calib * 100;
 		var packet = [244, 1, 0, 0, 0];
-		var cal_val = int2Bytes(calib, 2);
+		var cal_val = int2Bytes(calib, 4);
 		packet.push(...cal_val);
 		console.log(packet);
 		return this.config_send(sensor_mac, packet);
 	}
 	config_set_current_calibration_ch2_19(sensor_mac, calib){
 		console.log('config_set_current_calibration_ch2_19');
+		calib = calib * 100;
 		var packet = [244, 3, 0, 0, 0];
-		var cal_val = int2Bytes(calib, 2);
+		var cal_val = int2Bytes(calib, 4);
 		packet.push(...cal_val);
 		console.log(packet);
 		return this.config_send(sensor_mac, packet);
 	}
 	config_set_current_calibration_ch3_28(sensor_mac, calib){
 		console.log('cconfig_set_current_calibration_ch3_28');
+		calib = calib * 100;
 		var packet = [244, 5, 0, 0, 0];
-		var cal_val = int2Bytes(calib, 2);
+		var cal_val = int2Bytes(calib, 4);
 		packet.push(...cal_val);
 		console.log(packet);
 		return this.config_send(sensor_mac, packet);
 	}
+	config_set_rx485_timeout_1011(sensor_mac, value){
+		console.log('config_set_Rx485_timeout_1011');
+		var packet = [244, 48, 0, 0, 23, value];
+		console.log(packet);
+		return this.config_send(sensor_mac, packet);
+	}
+	config_set_mode_1011(sensor_mac, value){
+		console.log('config_set_mode_1011');
+		var packet = [244, 38, 0, 0, 23, value];
+		console.log(packet);
+		return this.config_send(sensor_mac, packet);
+	}
+	config_set_auto_address_timeout_1011(sensor_mac, value){
+		console.log('config_set_auto_address_timeout_1011');
+		var packet = [244, 40, 0, 0, 23];
+		var time_val = int2Bytes(value, 2);
+		packet.push(...time_val);
+		console.log(packet);
+		return this.config_send(sensor_mac, packet);
+	}
+	config_set_operation_mode_531(sensor_mac, mode){
+		console.log('config_set_operation_mode_531');
+		console.log(mode);
+		var packet = [244, 32, 0, 0, 0, mode];
+		console.log(packet);
+		return this.config_send(sensor_mac, packet);
+	}
 	config_get_delay(sensor_mac){
 		return new Promise((fulfill, reject) => {
 			this.config_send(sensor_mac, [247, 21, 0, 0, 0]).then((res) => {
@@ -2536,6 +2578,44 @@ function sensor_types(parent){
 					byteThree: d[2],
 					byteFour: d[3]
 				};
+			},
+			'parse_fly': (frame) => {
+				let frame_data = {};
+				switch(frame[16]){
+					case 0:
+						frame_data.fsr = "+-0.256 V";
+					break;
+					case 1:
+						frame_data.fsr = "+-0.512 V";
+					break;
+					case 2:
+						frame_data.fsr = "+-1.024 V";
+					break;
+					case 3:
+						frame_data.fsr = "+-2.048 V";
+					break;
+					case 4:
+						frame_data.fsr = "+-4.096 V";
+					break;
+					case 5:
+						frame_data.fsr = "+-6.144 V";
+					break;
+				}
+				return {
+					'firmware': frame[2],
+					'report_rate': frame.slice(12, 16).reduce(msbLsb),
+					'fsr':frame_data.fsr,
+					'boot_up_time': frame[17],
+					'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
+					'machine_values': {
+						'firmware': frame[2],
+						'report_rate': frame.slice(12, 16),
+						'fsr':frame[16],
+						'boot_up_time': frame[17],
+						'adc_pin_reading': frame.slice(18, 20),
+						'frame': frame
+					}
+				}
 			}
 		},
 		'53': {
@@ -2586,6 +2666,22 @@ function sensor_types(parent){
 				};
 			}
 		},
+		'58': {
+			name: 'Tank Level v3',
+			parse: (d) => {
+				return {
+					filtered_range: d.slice(0, 2).reduce(msbLsb),
+					long_range_algorithm: d.slice(2, 4).reduce(msbLsb),
+					second_chance:  d.slice(4, 6).reduce(msbLsb),
+					copare_reading:  d.slice(6, 8).reduce(msbLsb),
+					short_range_algorithm: d.slice(8, 10).reduce(msbLsb),
+					trusted_reading:  d.slice(10, 12).reduce(msbLsb),
+					final_filter:  d.slice(12, 14).reduce(msbLsb),
+					raw_final:  d.slice(14, 16).reduce(msbLsb),
+					final_index:  d.slice(16, 18).reduce(msbLsb),
+				};
+			}
+		},
 		'60': {
 			name: 'Air Velocity and Precision Pressure & Temperature Sensor',
 			parse: (d) => {
@@ -5599,12 +5695,12 @@ function sensor_types(parent){
 					return error;
 				}
 				return {
-					digital_input_1_counter: d.slice(0, 4).reduce(msbLsb),
-					digital_input_1_uptime: d.slice(4, 8).reduce(msbLsb),
-					digital_input_2_counter: d.slice(8, 12).reduce(msbLsb),
-					digital_input_2_uptime: d.slice(12, 16).reduce(msbLsb),
-					digital_input_3_counter: d.slice(16, 20).reduce(msbLsb),
-					digital_input_3_uptime: d.slice(20, 24).reduce(msbLsb),
+					digital_input_counter: d.slice(0, 4).reduce(msbLsb),
+					digital_input_uptime: d.slice(4, 8).reduce(msbLsb),
+					ct_input_counter: d.slice(8, 12).reduce(msbLsb),
+					ct_input_uptime: d.slice(12, 16).reduce(msbLsb),
+					opto_input_counter: d.slice(16, 20).reduce(msbLsb),
+					opto_input_uptime: d.slice(20, 24).reduce(msbLsb),
 					accelerometer_counter: d.slice(24, 28).reduce(msbLsb),
 					accelerometer_uptime: d.slice(28, 32).reduce(msbLsb),
 					magnetometer_counter: d.slice(32, 36).reduce(msbLsb),
@@ -9220,27 +9316,199 @@ function sensor_types(parent){
 		},
 		'531': {
 			name: 'Custom Noise Sensor',
-			parse: (d, p) => {
-				let firmware = p[1];
-				if(firmware > 1){
-					return {
-						rms_dba: d[0],
-						c1_dba: d[1],
-						c1_freq: d.slice(2, 4).reduce(msbLsb),
-						c2_dba: d[4],
-						c2_freq: d.slice(5, 7).reduce(msbLsb),
-						c3_dba: d[7],
-						c3_freq: d.slice(8, 10).reduce(msbLsb),
-					};
+			parse: (payload, parsed, mac) => {
+				// TODO error byte is not supported at this time and the below code is utilizing a not yet implemented emitter.
+				// if(payload[7] >> 1 != 0){
+				// 	parsed.error = {
+				// 		code: 2000080,
+				// 		text: 'Sensor Probe may be unattached',
+				// 		probe: 1
+				// 	};
+				// 	parsed.addr = mac;
+				// 	parsed.data = {error: 'Error found, Sensor Probe may be unattached'};
+				// 	parent._emitter.emit('ncd_error', parsed);
+				// 	parent._emitter.emit('ncd_error-'+parsed.sensor_type, parsed);
+				// 	parent._emitter.emit('ncd_error-'+mac, parsed);
+				// 	// Delete the error so it matches older messages.
+				// 	delete parsed.error;
+				// 	return parsed;
+				// }
+
+				// If time series data
+				if(payload[8] === 1){
+					var deviceAddr = mac;
+					var firmware = payload[1];
+					var expected_packets = payload[10];
+					var current_packet = payload[11];
+					var sdata_start = 12;
+					var sample_rate = payload[9];
+					// console.log('current_packet');
+					// console.log(current_packet);
+
+					// Make sure its instantiated to simplify following if checks
+					if(!Object.hasOwn(globalDevices, deviceAddr)){
+						globalDevices[deviceAddr] = {};
+					}
+					// Check if new stream is from new message
+					if(Object.hasOwn(globalDevices[deviceAddr], 'err_msg_counter_val') && globalDevices[deviceAddr].err_msg_counter_val != parsed.counter){
+						delete globalDevices[deviceAddr].err_msg_counter_val;
+					}
+
+					// USE THESE TO TEST ERRORS
+					// if(current_packet == 1){
+					// 	// Test missing first packet or not having a globalDevices[deviceAddr].data
+					// 	return;
+					// }
+					// if(current_packet == 2){
+					// 	// Test missing packet mid-stream
+					// 	return;
+					// }
+					// if(current_packet == expected_packets){
+					// 	// Test missing last section of stream
+					// 	return;
+					// }
+					// data object exists and current packet already exists in that object or if data object exists and previous packet not in data
+					// This section checks if for duplicate packets already in data
+					// Object.hasOwn(globalDevices, deviceAddr) && Object.hasOwn(globalDevices[deviceAddr], 'data') && current_packet in globalDevices[deviceAddr].data
+					// This section checks if the previous expected packet is in the data or note
+					// Object.hasOwn(globalDevices, deviceAddr) && Object.hasOwn(globalDevices[deviceAddr], 'data') && !(((current_packet&127)-1) in globalDevices[deviceAddr].data
+					// This section check if data does and if current_packet is not 1. This indicates the data started mid stream
+					// !Object.hasOwn(globalDevices[deviceAddr], 'data') && current_packet != 1
+					if(Object.hasOwn(globalDevices[deviceAddr], 'data') && current_packet in globalDevices[deviceAddr].data || Object.hasOwn(globalDevices[deviceAddr], 'data') && !(((current_packet&127)-1) in globalDevices[deviceAddr].data) || !Object.hasOwn(globalDevices[deviceAddr], 'data') && current_packet != 1){
+						// if(!Object.hasOwn(globalDevices[deviceAddr], 'err_msg_counter_val')){
+						//	 globalDevices[deviceAddr].err_msg_counter_val = parsed.counter;
+						// }
+						// If Data exists that means we're mid packet and an error occured.
+						if(Object.hasOwn(globalDevices[deviceAddr], 'data')){
+							// console.log('-----');
+							// console.log(deviceAddr+': bad packet breakdown deleting stream');
+							// console.log(current_packet);
+							// console.log(expected_packets);
+							// console.log(current_packet in globalDevices[deviceAddr].data);
+							// console.log(current_packet == 1);
+							// console.log(!((current_packet-1) in globalDevices[deviceAddr].data));
+							delete globalDevices[deviceAddr].data;
+						}
+						// If we have not already reported an error
+						if(!Object.hasOwn(globalDevices[deviceAddr], 'err_msg_counter_val')){
+							globalDevices[deviceAddr].err_msg_counter_val = parsed.counter;
+							if(Object.hasOwn(globalDevices[deviceAddr], 'stream_timeout')){
+								clearTimeout(globalDevices[deviceAddr].stream_timeout);
+								delete globalDevices[deviceAddr].stream_timeout;
+							}
+							parsed.error = {
+								code: 1000080,
+								text: 'Faulty multi-packet stream detected',
+								probe: 1
+							}
+							parsed.addr = mac;
+							// TODO remove console with emitter
+							console.log(parsed);
+							// parent._emitter.emit('ncd_error', parsed);
+							// parent._emitter.emit('ncd_error-'+parsed.sensor_type, parsed);
+							// parent._emitter.emit('ncd_error-'+mac, parsed);
+						}
+					}
+					// If first packet
+					if(current_packet == 1){
+						var mode = payload[8];
+
+						// First packet so errors should be invalidated commented out as may not be necessary because we're redefining globalDevices
+						// if(!Object.hasOwn(globalDevices[deviceAddr], 'err_msg_counter_val')){
+						//	 delete globalDevices[deviceAddr].err_msg_counter_val;
+						// }
+						if(Object.hasOwn(globalDevices[deviceAddr], 'stream_timeout')){
+							clearTimeout(globalDevices[deviceAddr].stream_timeout);
+							delete globalDevices[deviceAddr].stream_timeout;
+						}
+						globalDevices[deviceAddr] = {
+							// stream_size: expected_packets,
+							data: {},
+							sample_rate: sample_rate,
+							mo: mode,
+						}
+						// This timeout is useful for the reception of the first packet, but comms cut afterward
+						if(expected_packets != 1){
+							globalDevices[deviceAddr].stream_timeout = setTimeout(() => {
+								if(Object.hasOwn(globalDevices[deviceAddr], 'data')){
+									delete globalDevices[deviceAddr].data;
+								}
+								parsed.error = {
+									code: 1100080,
+									text: 'Multi-Packet Stream started, but timed out',
+									probe: 1
+								}
+								parsed.addr = mac;
+								// TODO remove console with emitter
+								console.log(parsed);
+								// parent._emitter.emit('ncd_error', parsed);
+								// parent._emitter.emit('ncd_error-'+parsed.sensor_type, parsed);
+								// parent._emitter.emit('ncd_error-'+mac, parsed);
+							}, 30000);
+						};
+						globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
+					}else if(Object.hasOwn(globalDevices[deviceAddr], 'data')){
+						// Not first packet and no error detected, append to data array
+						globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
+					}
+
+					if(Object.hasOwn(globalDevices[deviceAddr], 'data') && Object.keys(globalDevices[deviceAddr].data).length == expected_packets && !Object.hasOwn(globalDevices[deviceAddr], 'err_msg_counter_val')){
+						var raw_data = new Array();
+						for(const packet in globalDevices[deviceAddr].data){
+							raw_data = raw_data.concat(globalDevices[deviceAddr].data[packet]);
+						}
+						var label = 0;
+
+						var data_concat = {};
+
+						for(var i = 0; i < raw_data.length; i+=2){
+							label++;
+
+							data_concat[label] = (raw_data[i]<<8)+(raw_data[i+1]);
+							// data_concat[label] = parseFloat((signInt(((raw_data[i]<<8)+(raw_data[i+1])), 16)).toFixed(3));
+						}
+						var data_concat_obj = {
+							// mac_address: deviceAddr,
+							sample_rate: globalDevices[deviceAddr].sample_rate,
+							data: data_concat
+						};
+						sensor_data = data_concat_obj;
+
+						// Clear stream timeout to prevent timeout error message from triggering
+						if(Object.hasOwn(globalDevices[deviceAddr], 'stream_timeout')){
+							clearTimeout(globalDevices[deviceAddr].stream_timeout);
+						}
+						delete globalDevices[deviceAddr];
+						return sensor_data;
+					}
+					else{
+						return;
+					}
+
 				}else{
-					return {
-						noise_db: d[0],
-						peak_freq_1: d.slice(1, 3).reduce(msbLsb),
-						peak_freq_2: d.slice(3, 5).reduce(msbLsb),
-						peak_freq_3: d.slice(5, 7).reduce(msbLsb)
+					let firmware = payload[1];
+					if(firmware > 1){
+						return {
+							mode: payload[8],
+							sample_rate: payload[9],
+							rms_dba: payload[10],
+							c1_dba: payload[11],
+							c1_freq: payload.slice(12, 14).reduce(msbLsb),
+							c2_dba: payload[14],
+							c2_freq: payload.slice(15, 17).reduce(msbLsb),
+							c3_dba: payload[17],
+							c3_freq: payload.slice(18, 20).reduce(msbLsb),
+						};
+					}else{
+						return {
+							noise_db: payload[8],
+							peak_freq_1: payload.slice(9, 11).reduce(msbLsb),
+							peak_freq_2: payload.slice(11, 13).reduce(msbLsb),
+							peak_freq_3: payload.slice(13, 15).reduce(msbLsb)
+						};
 					};
-				}
-			}
+				};
+			},
 		},
 		'535': {
 			name: 'Custom Wireless CO2 Gas Sensor',
@@ -10479,12 +10747,16 @@ function sensor_types(parent){
 				return {
 					subdevice_type: d[0],
 					number_of_registers: d[1],
+					status_24_31: d[2],
+					status_16_23: d[3],
+					status_8_15:  d[4],
+					status_0_7:   d[5],
 					// TODO we can automatically determine how many registers are here based on the number_of_registers and create data objects appropriately
 					// r1: d.slice(2,4),
 					// r2: d.slice(4,6),
 					// r3: d.slice(6,8),
 					// r4: d.slice(8,10),
-					data: d.slice(2)
+					data: d.slice(6)
 				};
 			},
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ncd-io/node-red-enterprise-sensors",
-    "version": "1.0.4",
+    "version": "1.0.6",
     "description": "",
     "main": "index.js",
     "scripts": {