@ncd-io/node-red-enterprise-sensors 1.1.5 → 1.2.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/WirelessGateway.js +623 -226
- package/package.json +1 -1
- package/wireless.html +179 -37
- package/wireless.js +149 -17
package/lib/WirelessGateway.js
CHANGED
|
@@ -122,6 +122,25 @@ module.exports = class WirelessSensor{
|
|
|
122
122
|
this._emitter.emit("link_info",msg_obj);
|
|
123
123
|
}
|
|
124
124
|
parse(frame){
|
|
125
|
+
// NOTE this must be above the type selection to prevent rs-485 data from triggering other functionality.
|
|
126
|
+
if(globalDevices.hasOwnProperty(frame.mac) && globalDevices[frame.mac].hasOwnProperty('bridge') && globalDevices[frame.mac].bridge){
|
|
127
|
+
// if(type === undefined && globalDevices.hasOwnProperty(frame.mac) && globalDevices[frame.mac].hasOwnProperty('bridge') && globalDevices[frame.mac].bridge){
|
|
128
|
+
let query_data = {
|
|
129
|
+
addr: frame.mac,
|
|
130
|
+
payload: frame.data,
|
|
131
|
+
}
|
|
132
|
+
if(globalDevices[frame.mac].hasOwnProperty('command_queue') && globalDevices[frame.mac].command_queue.length != 0){
|
|
133
|
+
if(globalDevices[frame.mac].command_queue[0].hasOwnProperty('command')){
|
|
134
|
+
query_data.command = globalDevices[frame.mac].command_queue[0].command;
|
|
135
|
+
}
|
|
136
|
+
if(globalDevices[frame.mac].command_queue[0].hasOwnProperty('meta')){
|
|
137
|
+
query_data.meta = globalDevices[frame.mac].command_queue[0].meta;
|
|
138
|
+
}
|
|
139
|
+
};
|
|
140
|
+
this._emitter.emit('converter_ack-'+frame.mac, query_data);
|
|
141
|
+
return;
|
|
142
|
+
// }
|
|
143
|
+
}
|
|
125
144
|
var type = this.payloadType[frame.data[0]];
|
|
126
145
|
if(typeof this[type] == 'function'){
|
|
127
146
|
var data = this[type](frame.data.slice(1), frame);
|
|
@@ -141,7 +160,7 @@ module.exports = class WirelessSensor{
|
|
|
141
160
|
}
|
|
142
161
|
}
|
|
143
162
|
// #OTF
|
|
144
|
-
var otf_devices = [23,26,32,33,39,44,45,48,52,53,56,58,74,76,78,79,80,81,82,84,88,89,90,91,97,98,101,102,105,106,107,108,110,111,112,114,118,180,181,202,519,520,521,531,535,537,538,539,540,1010,1011];
|
|
163
|
+
var otf_devices = [4,12,21,23,26,32,33,39,44,45,48,52,53,56,58,74,76,78,79,80,81,82,84,88,89,90,91,97,98,101,102,105,106,107,108,110,111,112,114,118,120,180,181,202,217,519,520,521,531,535,537,538,539,540,1010,1011];
|
|
145
164
|
var device_type = msbLsb(frame.data[6], frame.data[7]);
|
|
146
165
|
// var device_type = frame.data[7];
|
|
147
166
|
|
|
@@ -303,7 +322,7 @@ module.exports = class WirelessSensor{
|
|
|
303
322
|
};
|
|
304
323
|
|
|
305
324
|
// #OTF
|
|
306
|
-
var otf_devices = [23,26,32,33,39,44,45,48,52,53,56,58,74,76,78,79,80,81,82,84,88,89,90,91,97,98,101,102,105,106,107,108,110,111,112,114,118,180,181,202,519,520,521,531,535,537,538,539,540,1010,1011];
|
|
325
|
+
var otf_devices = [4,12,21,23,26,32,33,39,44,45,48,52,53,56,58,74,76,78,79,80,81,82,84,88,89,90,91,97,98,101,102,105,106,107,108,110,111,112,114,118,120,180,181,202,217,519,520,521,531,535,537,538,539,540,1010,1011];
|
|
307
326
|
if(otf_devices.includes(parsed.sensor_type)){
|
|
308
327
|
// If the message says FLY and there is not FLY timer in progress.
|
|
309
328
|
if(payload[8] == 70 && payload[9] == 76 && payload[10] == 89) {
|
|
@@ -1288,6 +1307,12 @@ module.exports = class WirelessSensor{
|
|
|
1288
1307
|
console.log(packet);
|
|
1289
1308
|
return this.config_send(sensor_mac, packet);
|
|
1290
1309
|
}
|
|
1310
|
+
config_set_quality_of_service_108(sensor_mac, value){
|
|
1311
|
+
console.log('config_set_quality_of_service_108');
|
|
1312
|
+
var packet = [244, 52, 0, 0, 0, value]
|
|
1313
|
+
console.log(packet);
|
|
1314
|
+
return this.config_send(sensor_mac, packet);
|
|
1315
|
+
}
|
|
1291
1316
|
config_set_rtc_108(sensor_mac){
|
|
1292
1317
|
console.log('config_set_rtc_108');
|
|
1293
1318
|
var date = new Date();
|
|
@@ -1295,8 +1320,8 @@ module.exports = class WirelessSensor{
|
|
|
1295
1320
|
console.log(packet);
|
|
1296
1321
|
return this.config_send(sensor_mac, packet);
|
|
1297
1322
|
}
|
|
1298
|
-
|
|
1299
|
-
console.log('
|
|
1323
|
+
config_set_transmission_interval_108(sensor_mac, value){
|
|
1324
|
+
console.log('config_set_transmission_interval_108');
|
|
1300
1325
|
var packet = [244, 55, 0, 0, 0, value];
|
|
1301
1326
|
console.log(packet);
|
|
1302
1327
|
return this.config_send(sensor_mac, packet);
|
|
@@ -1631,6 +1656,14 @@ module.exports = class WirelessSensor{
|
|
|
1631
1656
|
console.log(packet);
|
|
1632
1657
|
return this.config_send(sensor_mac, packet);
|
|
1633
1658
|
}
|
|
1659
|
+
config_set_max_raw_sample_110(sensor_mac, value){
|
|
1660
|
+
console.log('config_set_max_raw_sample_110');
|
|
1661
|
+
var packet = [244, 79, 0, 0, 101, 87];
|
|
1662
|
+
var val = int2Bytes(value, 2);
|
|
1663
|
+
packet.push(...val);
|
|
1664
|
+
console.log(packet);
|
|
1665
|
+
return this.config_send(sensor_mac, packet);
|
|
1666
|
+
}
|
|
1634
1667
|
config_set_acceleration_interrupt_threshold_84(sensor_mac, value){
|
|
1635
1668
|
console.log('config_set_acceleration_interrupt_threshold_84');
|
|
1636
1669
|
var packet = [244, 79, 0, 0, 0, 60, value];
|
|
@@ -1928,6 +1961,44 @@ module.exports = class WirelessSensor{
|
|
|
1928
1961
|
console.log(packet);
|
|
1929
1962
|
return this.config_send(sensor_mac, packet);
|
|
1930
1963
|
}
|
|
1964
|
+
config_set_to_always_on_120(sensor_mac){
|
|
1965
|
+
console.log('config_set_to_always_on_120');
|
|
1966
|
+
let packet = [244, 10, 0, 0, 0, 1];
|
|
1967
|
+
console.log(packet);
|
|
1968
|
+
return this.config_send(sensor_mac, packet);
|
|
1969
|
+
}
|
|
1970
|
+
config_set_sensor_reset_120(sensor_mac){
|
|
1971
|
+
console.log('config_set_sensor_reset_120');
|
|
1972
|
+
let packet = [244, 12, 0, 0, 26];
|
|
1973
|
+
console.log(packet);
|
|
1974
|
+
return this.config_send(sensor_mac, packet);
|
|
1975
|
+
}
|
|
1976
|
+
config_set_sensor_calib_120(sensor_mac){
|
|
1977
|
+
console.log('config_set_sensor_calib_120');
|
|
1978
|
+
let packet = [244, 13, 0, 0, 74];
|
|
1979
|
+
console.log(packet);
|
|
1980
|
+
return this.config_send(sensor_mac, packet);
|
|
1981
|
+
}
|
|
1982
|
+
config_set_alert_threshold_120(sensor_mac, value){
|
|
1983
|
+
console.log('config_set_alert_threshold_120');
|
|
1984
|
+
let packet = [244, 14, 0, 0, value];
|
|
1985
|
+
console.log(packet);
|
|
1986
|
+
return this.config_send(sensor_mac, packet);
|
|
1987
|
+
}
|
|
1988
|
+
config_set_tare_the_scale_217(sensor_mac){
|
|
1989
|
+
console.log('config_set_tare_the_scale_217');
|
|
1990
|
+
var packet = [244, 32, 0, 0, 26];
|
|
1991
|
+
console.log(packet);
|
|
1992
|
+
return this.config_send(sensor_mac, packet);
|
|
1993
|
+
}
|
|
1994
|
+
config_set_weight_calib_217(sensor_mac, value){
|
|
1995
|
+
console.log('config_set_weight_calib_217');
|
|
1996
|
+
var packet = [244, 33, 0, 0, 26];
|
|
1997
|
+
let value_ = int2Bytes((value*100), 4);
|
|
1998
|
+
packet.push(...value_);
|
|
1999
|
+
console.log(packet);
|
|
2000
|
+
return this.config_send(sensor_mac, packet);
|
|
2001
|
+
}
|
|
1931
2002
|
config_get_delay(sensor_mac){
|
|
1932
2003
|
return new Promise((fulfill, reject) => {
|
|
1933
2004
|
this.config_send(sensor_mac, [247, 21, 0, 0, 0]).then((res) => {
|
|
@@ -2193,6 +2264,101 @@ module.exports = class WirelessSensor{
|
|
|
2193
2264
|
});
|
|
2194
2265
|
});
|
|
2195
2266
|
}
|
|
2267
|
+
queue_bridge_query(sensor_mac, data, meta = null, opts){
|
|
2268
|
+
var that = this;
|
|
2269
|
+
if(!globalDevices.hasOwnProperty(sensor_mac)){
|
|
2270
|
+
globalDevices[sensor_mac] = {bridge: true, command_queue: []};
|
|
2271
|
+
}
|
|
2272
|
+
// if(!Object.hasOwn(node._gateway_node.sensor_list[msg.payload.address], 'command_queue')){
|
|
2273
|
+
// if(!globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2274
|
+
// globalDevices[sensor_mac].command_queue = [{'command': data, 'meta': meta}];
|
|
2275
|
+
// }else{
|
|
2276
|
+
globalDevices[sensor_mac].command_queue.push({'command': data, 'meta': meta});
|
|
2277
|
+
// }
|
|
2278
|
+
|
|
2279
|
+
return new Promise((fulfill, reject) => {
|
|
2280
|
+
that.queue.add(() => {
|
|
2281
|
+
return new Promise((f, r) => {
|
|
2282
|
+
var tout;
|
|
2283
|
+
function fail(response){
|
|
2284
|
+
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
2285
|
+
clearTimeout(tout);
|
|
2286
|
+
|
|
2287
|
+
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2288
|
+
globalDevices[sensor_mac].command_queue.shift();
|
|
2289
|
+
}
|
|
2290
|
+
reject({
|
|
2291
|
+
err: response,
|
|
2292
|
+
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2293
|
+
});
|
|
2294
|
+
f();
|
|
2295
|
+
}
|
|
2296
|
+
function pass(response){
|
|
2297
|
+
clearTimeout(tout);
|
|
2298
|
+
|
|
2299
|
+
that._emitter.emit('converter_response', response);
|
|
2300
|
+
that._emitter.emit('converter_response-'+sensor_mac, response);
|
|
2301
|
+
|
|
2302
|
+
|
|
2303
|
+
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2304
|
+
globalDevices[sensor_mac].command_queue.shift();
|
|
2305
|
+
}
|
|
2306
|
+
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2307
|
+
fulfill(response);
|
|
2308
|
+
f();
|
|
2309
|
+
// that._emitter.
|
|
2310
|
+
};
|
|
2311
|
+
|
|
2312
|
+
that._emitter.once('converter_ack-'+sensor_mac, pass);
|
|
2313
|
+
that._emitter.once('converter_error-'+sensor_mac, fail);
|
|
2314
|
+
tout = setTimeout(() => {
|
|
2315
|
+
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2316
|
+
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
2317
|
+
|
|
2318
|
+
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2319
|
+
globalDevices[sensor_mac].command_queue.shift();
|
|
2320
|
+
};
|
|
2321
|
+
if(sensor_mac == '00:00:00:00:00:00:FF:FF'){
|
|
2322
|
+
reject({
|
|
2323
|
+
res: 'Broadcast mode, no target device',
|
|
2324
|
+
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2325
|
+
});
|
|
2326
|
+
}else{
|
|
2327
|
+
reject({
|
|
2328
|
+
err: 'Wireless Converter did not respond',
|
|
2329
|
+
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2330
|
+
});
|
|
2331
|
+
};
|
|
2332
|
+
|
|
2333
|
+
f();
|
|
2334
|
+
}, 1500);
|
|
2335
|
+
that.send.transmit_request(mac2bytes(sensor_mac), data, opts).then().catch((err) => {
|
|
2336
|
+
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2337
|
+
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
2338
|
+
reject({
|
|
2339
|
+
err: err,
|
|
2340
|
+
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2341
|
+
});
|
|
2342
|
+
f();
|
|
2343
|
+
}).then();
|
|
2344
|
+
});
|
|
2345
|
+
});
|
|
2346
|
+
this.queue.add(() => {
|
|
2347
|
+
return new Promise((f, r) => {
|
|
2348
|
+
setTimeout(f, 500);
|
|
2349
|
+
});
|
|
2350
|
+
});
|
|
2351
|
+
});
|
|
2352
|
+
};
|
|
2353
|
+
prepare_bridge_query(sensor_mac, commands){
|
|
2354
|
+
commands.forEach((command) => {
|
|
2355
|
+
if(command.hasOwnProperty('meta')){
|
|
2356
|
+
this.queue_bridge_query(sensor_mac, command.command, command.meta);
|
|
2357
|
+
}else{
|
|
2358
|
+
this.queue_bridge_query(sensor_mac, command.command);
|
|
2359
|
+
}
|
|
2360
|
+
});
|
|
2361
|
+
}
|
|
2196
2362
|
build_102_data(payload, deviceAddr, hour, minute, sdata_start, current_packet, firmware){
|
|
2197
2363
|
if(current_packet != 1){
|
|
2198
2364
|
console.log('bad packet cleanup');
|
|
@@ -2400,7 +2566,54 @@ module.exports = class WirelessSensor{
|
|
|
2400
2566
|
});
|
|
2401
2567
|
});
|
|
2402
2568
|
});
|
|
2403
|
-
}
|
|
2569
|
+
};
|
|
2570
|
+
local_at_send(parameter, value, ctrl_timeout = 1000){
|
|
2571
|
+
var that = this;
|
|
2572
|
+
return new Promise((fulfill, reject) => {
|
|
2573
|
+
that.queue.add(() => {
|
|
2574
|
+
return new Promise((f, r) => {
|
|
2575
|
+
var failed = false;
|
|
2576
|
+
var retries = 0;
|
|
2577
|
+
var tO;
|
|
2578
|
+
function fail(packet){
|
|
2579
|
+
failed = true;
|
|
2580
|
+
clearTimeout(tO);
|
|
2581
|
+
// that._emitter.removeListener('receive_packet-'+sensor_mac, pass);
|
|
2582
|
+
// that._emitter.removeListener('transmit_status-'+sensor_mac, pass);
|
|
2583
|
+
reject({
|
|
2584
|
+
err: packet,
|
|
2585
|
+
sent: ['Local Module', parameter, value]
|
|
2586
|
+
});
|
|
2587
|
+
r();
|
|
2588
|
+
}
|
|
2589
|
+
function pass(packet){
|
|
2590
|
+
if(failed) return;
|
|
2591
|
+
clearTimeout(tO);
|
|
2592
|
+
fulfill(packet);
|
|
2593
|
+
f();
|
|
2594
|
+
};
|
|
2595
|
+
|
|
2596
|
+
function send(){
|
|
2597
|
+
that.send.at_command(parameter, value).then(function(frame){
|
|
2598
|
+
if(frame.status == 'OK'){
|
|
2599
|
+
pass(frame);
|
|
2600
|
+
}else{
|
|
2601
|
+
tO = setTimeout(() => {
|
|
2602
|
+
if(retries < 0){
|
|
2603
|
+
retries++;
|
|
2604
|
+
send();
|
|
2605
|
+
}else{
|
|
2606
|
+
fail('AT response timeout');
|
|
2607
|
+
}
|
|
2608
|
+
}, ctrl_timeout);
|
|
2609
|
+
}
|
|
2610
|
+
}).catch(fail);
|
|
2611
|
+
};
|
|
2612
|
+
send();
|
|
2613
|
+
});
|
|
2614
|
+
});
|
|
2615
|
+
});
|
|
2616
|
+
};
|
|
2404
2617
|
route_discover(sensor_mac, opts){
|
|
2405
2618
|
var data = [85];
|
|
2406
2619
|
var that = this;
|
|
@@ -2725,7 +2938,7 @@ function sensor_types(parent){
|
|
|
2725
2938
|
}
|
|
2726
2939
|
},
|
|
2727
2940
|
'21': {
|
|
2728
|
-
name: '
|
|
2941
|
+
name: 'Differential Bidirectional Pressure Sensor',
|
|
2729
2942
|
parse: (d) => {
|
|
2730
2943
|
return {
|
|
2731
2944
|
pressure: signInt(d.slice(0, 2).reduce(msbLsb), 16) / 100,
|
|
@@ -6442,7 +6655,7 @@ function sensor_types(parent){
|
|
|
6442
6655
|
return {
|
|
6443
6656
|
mode: payload[8],
|
|
6444
6657
|
sampling_frequency: payload.slice(9, 13).reduce(msbLsb),
|
|
6445
|
-
rms_mv: payload.slice(13, 17).reduce(msbLsb) / 1000,
|
|
6658
|
+
rms_mv: signInt(payload.slice(13, 17).reduce(msbLsb), 32) / 1000,
|
|
6446
6659
|
freq_1: payload.slice(17, 19).reduce(msbLsb),
|
|
6447
6660
|
freq_2: payload.slice(19, 21).reduce(msbLsb),
|
|
6448
6661
|
freq_3: payload.slice(21, 23).reduce(msbLsb),
|
|
@@ -6475,10 +6688,10 @@ function sensor_types(parent){
|
|
|
6475
6688
|
'fly_rate': frame.slice(15, 17).reduce(msbLsb) + " min",
|
|
6476
6689
|
'sensor_gain_db': frame[17] + " dB",
|
|
6477
6690
|
'sensor_boot_time': frame[18] + " sec",
|
|
6478
|
-
'sampling_frequency':
|
|
6479
|
-
'hardware_id': frame.slice(23, 26),
|
|
6480
|
-
'report_rate': frame.slice(26, 30).reduce(msbLsb),
|
|
6481
|
-
'tx_life_count': frame.slice(30, 34).reduce(msbLsb),
|
|
6691
|
+
'sampling_frequency': frame.slice(19, 23).reduce(msbLsb) + " Hz",
|
|
6692
|
+
// 'hardware_id': frame.slice(23, 26),
|
|
6693
|
+
// 'report_rate': frame.slice(26, 30).reduce(msbLsb),
|
|
6694
|
+
// 'tx_life_count': frame.slice(30, 34).reduce(msbLsb),
|
|
6482
6695
|
'machine_values': {
|
|
6483
6696
|
'firmware': frame[2],
|
|
6484
6697
|
'mode':frame[12],
|
|
@@ -6487,10 +6700,10 @@ function sensor_types(parent){
|
|
|
6487
6700
|
'fly_rate': frame.slice(15, 17),
|
|
6488
6701
|
'sensor_gain_db': frame[17],
|
|
6489
6702
|
'sensor_boot_time': frame[18],
|
|
6490
|
-
'sampling_frequency': frame.slice(19, 23)
|
|
6491
|
-
'hardware_id': frame.slice(23, 26),
|
|
6492
|
-
'report_rate': frame.slice(26, 30),
|
|
6493
|
-
'tx_life_count': frame.slice(30, 34)
|
|
6703
|
+
'sampling_frequency': frame.slice(19, 23)
|
|
6704
|
+
// 'hardware_id': frame.slice(23, 26),
|
|
6705
|
+
// 'report_rate': frame.slice(26, 30),
|
|
6706
|
+
// 'tx_life_count': frame.slice(30, 34)
|
|
6494
6707
|
}
|
|
6495
6708
|
}
|
|
6496
6709
|
}
|
|
@@ -6619,14 +6832,14 @@ function sensor_types(parent){
|
|
|
6619
6832
|
return {
|
|
6620
6833
|
mode: payload[8],
|
|
6621
6834
|
sampling_frequency: payload.slice(9, 13).reduce(msbLsb),
|
|
6622
|
-
c1_rms_mv: payload.slice(13,
|
|
6623
|
-
c1_freq_1: payload.slice(
|
|
6624
|
-
c1_freq_2: payload.slice(
|
|
6625
|
-
c1_freq_3: payload.slice(
|
|
6626
|
-
c2_rms_mv: payload.slice(23,
|
|
6627
|
-
c2_freq_1: payload.slice(
|
|
6628
|
-
c2_freq_2: payload.slice(
|
|
6629
|
-
c2_freq_3: payload.slice(
|
|
6835
|
+
c1_rms_mv: signInt(payload.slice(13, 17).reduce(msbLsb), 32) / 1000,
|
|
6836
|
+
c1_freq_1: payload.slice(17, 19).reduce(msbLsb),
|
|
6837
|
+
c1_freq_2: payload.slice(19, 21).reduce(msbLsb),
|
|
6838
|
+
c1_freq_3: payload.slice(21, 23).reduce(msbLsb),
|
|
6839
|
+
c2_rms_mv: signInt(payload.slice(23, 27).reduce(msbLsb), 32) / 1000,
|
|
6840
|
+
c2_freq_1: payload.slice(27, 29).reduce(msbLsb),
|
|
6841
|
+
c2_freq_2: payload.slice(29, 31).reduce(msbLsb),
|
|
6842
|
+
c2_freq_3: payload.slice(31, 33).reduce(msbLsb)
|
|
6630
6843
|
};
|
|
6631
6844
|
}
|
|
6632
6845
|
},
|
|
@@ -6657,10 +6870,10 @@ function sensor_types(parent){
|
|
|
6657
6870
|
'c1_sensor_boot_time': frame[18] + " sec",
|
|
6658
6871
|
'c2_sensor_gain_db': frame[19] + " dB",
|
|
6659
6872
|
'c2_sensor_boot_time': frame[20] + " sec",
|
|
6660
|
-
'sampling_frequency':
|
|
6661
|
-
'hardware_id': frame.slice(25, 28),
|
|
6662
|
-
'report_rate': frame.slice(28, 32).reduce(msbLsb),
|
|
6663
|
-
'tx_life_count': frame.slice(32, 36).reduce(msbLsb),
|
|
6873
|
+
'sampling_frequency': frame.slice(21, 25).reduce(msbLsb) + " Hz",
|
|
6874
|
+
// 'hardware_id': frame.slice(25, 28),
|
|
6875
|
+
// 'report_rate': frame.slice(28, 32).reduce(msbLsb),
|
|
6876
|
+
// 'tx_life_count': frame.slice(32, 36).reduce(msbLsb),
|
|
6664
6877
|
'machine_values': {
|
|
6665
6878
|
'firmware': frame[2],
|
|
6666
6879
|
'mode': frame[12],
|
|
@@ -6671,10 +6884,10 @@ function sensor_types(parent){
|
|
|
6671
6884
|
'c1_sensor_boot_time': frame[18],
|
|
6672
6885
|
'c2_sensor_gain_db': frame[19],
|
|
6673
6886
|
'c2_sensor_boot_time': frame[20],
|
|
6674
|
-
'sampling_frequency': frame.slice(21, 25)
|
|
6675
|
-
'hardware_id': frame.slice(25, 28),
|
|
6676
|
-
'report_rate': frame.slice(28, 32),
|
|
6677
|
-
'tx_life_count': frame.slice(32, 36)
|
|
6887
|
+
'sampling_frequency': frame.slice(21, 25)
|
|
6888
|
+
// 'hardware_id': frame.slice(25, 28),
|
|
6889
|
+
// 'report_rate': frame.slice(28, 32),
|
|
6890
|
+
// 'tx_life_count': frame.slice(32, 36)
|
|
6678
6891
|
}
|
|
6679
6892
|
}
|
|
6680
6893
|
}
|
|
@@ -6811,23 +7024,47 @@ function sensor_types(parent){
|
|
|
6811
7024
|
}
|
|
6812
7025
|
}
|
|
6813
7026
|
},
|
|
7027
|
+
'109': {
|
|
7028
|
+
name: 'Wireless Custom Solar Sensor',
|
|
7029
|
+
parse: (d) => {
|
|
7030
|
+
return {
|
|
7031
|
+
illuminance: d.slice(0, 4).reduce(msbLsb),
|
|
7032
|
+
total_solar_radiation: d.slice(4, 6).reduce(msbLsb),
|
|
7033
|
+
ultraviolet_radiation: d.slice(6, 8).reduce(msbLsb)
|
|
7034
|
+
};
|
|
7035
|
+
},
|
|
7036
|
+
'parse_fly': (frame) => {
|
|
7037
|
+
return {
|
|
7038
|
+
'firmware': frame[2],
|
|
7039
|
+
'hardware_id': frame.slice(12, 15),
|
|
7040
|
+
'sample_rate': frame.slice(15, 19).reduce(msbLsb) + " Sec.",
|
|
7041
|
+
'tx_life_counter': frame.slice(19, 23).reduce(msbLsb),
|
|
7042
|
+
'machine_values': {
|
|
7043
|
+
'firmware': frame[2],
|
|
7044
|
+
'hardware_id': frame.slice(12, 15),
|
|
7045
|
+
'sample_rate': frame.slice(15, 19).reduce(msbLsb),
|
|
7046
|
+
'tx_life_counter': frame.slice(19, 23).reduce(msbLsb)
|
|
7047
|
+
}
|
|
7048
|
+
}
|
|
7049
|
+
}
|
|
7050
|
+
},
|
|
6814
7051
|
'110': {
|
|
6815
7052
|
name: 'One Channel Vibration Plus v4',
|
|
6816
7053
|
parse: (payload, parsed, mac) => {
|
|
6817
|
-
if(payload[7]
|
|
7054
|
+
if(payload[7] & 2){
|
|
6818
7055
|
console.log('Error found');
|
|
6819
7056
|
parsed.data = {error: 'Error found, Sensor Probe may be unattached'};
|
|
6820
7057
|
return parsed;
|
|
6821
7058
|
}
|
|
6822
|
-
|
|
7059
|
+
let msg_type = (payload[7] & 16)? 'motion' : 'regular';
|
|
6823
7060
|
if(payload[8] === 1){
|
|
6824
7061
|
var deviceAddr = mac;
|
|
6825
7062
|
var firmware = payload[1];
|
|
6826
7063
|
var hour = payload[12];
|
|
6827
7064
|
var minute = payload[13];
|
|
6828
|
-
var expected_packets = payload[16];
|
|
6829
|
-
var current_packet = payload[
|
|
6830
|
-
var sdata_start =
|
|
7065
|
+
var expected_packets = msbLsb(payload[16], payload[17]);
|
|
7066
|
+
var current_packet = msbLsb(payload[18], payload[19]);
|
|
7067
|
+
var sdata_start = 20;
|
|
6831
7068
|
|
|
6832
7069
|
if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
|
|
6833
7070
|
if(expected_packets != 1){
|
|
@@ -6998,12 +7235,15 @@ function sensor_types(parent){
|
|
|
6998
7235
|
}
|
|
6999
7236
|
}
|
|
7000
7237
|
var fft_concat_obj = {
|
|
7238
|
+
mode: payload[8],
|
|
7239
|
+
msg_type: msg_type,
|
|
7001
7240
|
time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
|
|
7002
7241
|
mac_address: deviceAddr,
|
|
7003
7242
|
en_axis: globalDevices[deviceAddr].en_axis,
|
|
7004
7243
|
fsr: fsr_text,
|
|
7005
7244
|
odr: globalDevices[deviceAddr].odr,
|
|
7006
7245
|
device_temp: globalDevices[deviceAddr].device_temp,
|
|
7246
|
+
total_samples: label,
|
|
7007
7247
|
data: fft_concat
|
|
7008
7248
|
};
|
|
7009
7249
|
sensor_data = fft_concat_obj;
|
|
@@ -7079,6 +7319,7 @@ function sensor_types(parent){
|
|
|
7079
7319
|
}
|
|
7080
7320
|
return {
|
|
7081
7321
|
mode: payload[8],
|
|
7322
|
+
msg_type: msg_type,
|
|
7082
7323
|
|
|
7083
7324
|
odr: odr,
|
|
7084
7325
|
temperature: signInt(payload.slice(10, 12).reduce(msbLsb), 16) / 100,
|
|
@@ -7126,6 +7367,9 @@ function sensor_types(parent){
|
|
|
7126
7367
|
case 2:
|
|
7127
7368
|
frame_data.mode = "Processed + Raw on demand";
|
|
7128
7369
|
break;
|
|
7370
|
+
case 3:
|
|
7371
|
+
frame_data.mode = "Smart";
|
|
7372
|
+
break;
|
|
7129
7373
|
}
|
|
7130
7374
|
switch(frame[17]){
|
|
7131
7375
|
case 6:
|
|
@@ -7237,30 +7481,39 @@ function sensor_types(parent){
|
|
|
7237
7481
|
switch(frame[22]){
|
|
7238
7482
|
case 0:
|
|
7239
7483
|
frame_data.sampling_interval = "5 Minutes";
|
|
7484
|
+
frame_data.sampling_interval_number = 5;
|
|
7240
7485
|
break;
|
|
7241
7486
|
case 1:
|
|
7242
7487
|
frame_data.sampling_interval = "10 Minutes";
|
|
7488
|
+
frame_data.sampling_interval_number = 10;
|
|
7243
7489
|
break;
|
|
7244
7490
|
case 2:
|
|
7245
7491
|
frame_data.sampling_interval = "15 Minutes";
|
|
7492
|
+
frame_data.sampling_interval_number = 15;
|
|
7246
7493
|
break;
|
|
7247
7494
|
case 2:
|
|
7248
7495
|
frame_data.sampling_interval = "20 Minutes";
|
|
7496
|
+
frame_data.sampling_interval_number = 20;
|
|
7249
7497
|
break;
|
|
7250
7498
|
case 4:
|
|
7251
7499
|
frame_data.sampling_interval = "30 Minutes";
|
|
7500
|
+
frame_data.sampling_interval_number = 30;
|
|
7252
7501
|
break;
|
|
7253
7502
|
case 5:
|
|
7254
7503
|
frame_data.sampling_interval = "60 Minutes";
|
|
7504
|
+
frame_data.sampling_interval_number = 60;
|
|
7255
7505
|
break;
|
|
7256
7506
|
case 6:
|
|
7257
7507
|
frame_data.sampling_interval = "120 Minutes";
|
|
7508
|
+
frame_data.sampling_interval_number = 120;
|
|
7258
7509
|
break;
|
|
7259
7510
|
case 7:
|
|
7260
7511
|
frame_data.sampling_interval = "180 Minutes";
|
|
7512
|
+
frame_data.sampling_interval_number = 180;
|
|
7261
7513
|
break;
|
|
7262
7514
|
case 8:
|
|
7263
7515
|
frame_data.sampling_interval = "1 Minute";
|
|
7516
|
+
frame_data.sampling_interval_number = 1;
|
|
7264
7517
|
break;
|
|
7265
7518
|
}
|
|
7266
7519
|
frame_data.on_request_timeout = frame[23] + " Seconds";
|
|
@@ -7295,6 +7548,9 @@ function sensor_types(parent){
|
|
|
7295
7548
|
break;
|
|
7296
7549
|
}
|
|
7297
7550
|
frame_data.rpm_status = frame[27]? 'Enabled': 'Disabled';
|
|
7551
|
+
frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
|
|
7552
|
+
frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
|
|
7553
|
+
frame_data.smart_mode_threshold = frame[34] * 50;
|
|
7298
7554
|
return {
|
|
7299
7555
|
'firmware': frame[2],
|
|
7300
7556
|
'destination_address': toMac(frame.slice(12, 16)),
|
|
@@ -7312,6 +7568,14 @@ function sensor_types(parent){
|
|
|
7312
7568
|
'payload_length': frame_data.payload_length,
|
|
7313
7569
|
'fsr': frame_data.fsr_text,
|
|
7314
7570
|
'rpm_compute_status': frame_data.rpm_status,
|
|
7571
|
+
'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
|
|
7572
|
+
'auto_raw_interval': frame_data.auto_raw_interval,
|
|
7573
|
+
'smart_mode_skip_count': frame[33],
|
|
7574
|
+
'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
|
|
7575
|
+
'uptime_counter': frame.slice(35, 39).reduce(msbLsb),
|
|
7576
|
+
'hardware_id': frame.slice(39, 42),
|
|
7577
|
+
'reserved': frame.slice(42, 46),
|
|
7578
|
+
'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
|
|
7315
7579
|
'machine_values': {
|
|
7316
7580
|
'firmware': frame[2],
|
|
7317
7581
|
'destination_address': toMac(frame.slice(12, 16), false),
|
|
@@ -7326,7 +7590,15 @@ function sensor_types(parent){
|
|
|
7326
7590
|
'deadband': frame[24],
|
|
7327
7591
|
'payload_length': frame[25],
|
|
7328
7592
|
'fsr': frame[26],
|
|
7329
|
-
'rpm_compute_status': frame[27]
|
|
7593
|
+
'rpm_compute_status': frame[27],
|
|
7594
|
+
'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
|
|
7595
|
+
'auto_raw_interval': frame[32],
|
|
7596
|
+
'smart_mode_skip_count': frame[33],
|
|
7597
|
+
'smart_mode_acc_threshold':frame[34],
|
|
7598
|
+
'uptime_counter': frame.slice(35, 39),
|
|
7599
|
+
'hardware_id': frame.slice(39, 42),
|
|
7600
|
+
'reserved': frame.slice(42, 46),
|
|
7601
|
+
'tx_lifetime_counter': frame.slice(46, 50)
|
|
7330
7602
|
}
|
|
7331
7603
|
}
|
|
7332
7604
|
}
|
|
@@ -7344,15 +7616,15 @@ function sensor_types(parent){
|
|
|
7344
7616
|
if(payload[7] & 2 && payload[7] & 4){
|
|
7345
7617
|
return parsed;
|
|
7346
7618
|
}
|
|
7347
|
-
|
|
7619
|
+
let msg_type = (payload[7] & 16)? 'motion' : 'regular';
|
|
7348
7620
|
if(payload[8] === 1){
|
|
7349
7621
|
var deviceAddr = mac;
|
|
7350
7622
|
var firmware = payload[1];
|
|
7351
7623
|
var hour = payload[12];
|
|
7352
7624
|
var minute = payload[13];
|
|
7353
|
-
var expected_packets = payload[16];
|
|
7354
|
-
var current_packet = payload[
|
|
7355
|
-
var sdata_start =
|
|
7625
|
+
var expected_packets = msbLsb(payload[16], payload[17]);
|
|
7626
|
+
var current_packet = msbLsb(payload[18], payload[19]);
|
|
7627
|
+
var sdata_start = 20;
|
|
7356
7628
|
|
|
7357
7629
|
if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
|
|
7358
7630
|
if(expected_packets != 1){
|
|
@@ -7532,6 +7804,8 @@ function sensor_types(parent){
|
|
|
7532
7804
|
}
|
|
7533
7805
|
|
|
7534
7806
|
var fft_concat_obj = {
|
|
7807
|
+
mode: payload[8],
|
|
7808
|
+
msg_type: msg_type,
|
|
7535
7809
|
probe: probe,
|
|
7536
7810
|
time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
|
|
7537
7811
|
probe: probe,
|
|
@@ -7540,6 +7814,7 @@ function sensor_types(parent){
|
|
|
7540
7814
|
fsr: fsr_text,
|
|
7541
7815
|
odr: globalDevices[deviceAddr].odr,
|
|
7542
7816
|
device_temp: globalDevices[deviceAddr].device_temp,
|
|
7817
|
+
total_samples: label,
|
|
7543
7818
|
data: fft_concat
|
|
7544
7819
|
};
|
|
7545
7820
|
sensor_data = fft_concat_obj;
|
|
@@ -7654,9 +7929,9 @@ function sensor_types(parent){
|
|
|
7654
7929
|
// else{
|
|
7655
7930
|
// probe = '1';
|
|
7656
7931
|
// }
|
|
7657
|
-
|
|
7658
7932
|
return {
|
|
7659
7933
|
mode: payload[8],
|
|
7934
|
+
msg_type: msg_type,
|
|
7660
7935
|
|
|
7661
7936
|
s1_odr: odr1,
|
|
7662
7937
|
s1_temperature: signInt(payload.slice(10, 12).reduce(msbLsb), 16) / 100,
|
|
@@ -7732,6 +8007,9 @@ function sensor_types(parent){
|
|
|
7732
8007
|
case 2:
|
|
7733
8008
|
frame_data.mode = "Processed + Raw on demand";
|
|
7734
8009
|
break;
|
|
8010
|
+
case 3:
|
|
8011
|
+
frame_data.mode = "Smart";
|
|
8012
|
+
break;
|
|
7735
8013
|
}
|
|
7736
8014
|
switch(frame[17]){
|
|
7737
8015
|
case 6:
|
|
@@ -7942,30 +8220,39 @@ function sensor_types(parent){
|
|
|
7942
8220
|
switch(frame[26]){
|
|
7943
8221
|
case 0:
|
|
7944
8222
|
frame_data.sampling_interval = "5 Minutes";
|
|
8223
|
+
frame_data.sampling_interval_number = 5;
|
|
7945
8224
|
break;
|
|
7946
8225
|
case 1:
|
|
7947
8226
|
frame_data.sampling_interval = "10 Minutes";
|
|
8227
|
+
frame_data.sampling_interval_number = 10;
|
|
7948
8228
|
break;
|
|
7949
8229
|
case 2:
|
|
7950
8230
|
frame_data.sampling_interval = "15 Minutes";
|
|
8231
|
+
frame_data.sampling_interval_number = 15;
|
|
7951
8232
|
break;
|
|
7952
8233
|
case 2:
|
|
7953
8234
|
frame_data.sampling_interval = "20 Minutes";
|
|
8235
|
+
frame_data.sampling_interval_number = 20;
|
|
7954
8236
|
break;
|
|
7955
8237
|
case 4:
|
|
7956
8238
|
frame_data.sampling_interval = "30 Minutes";
|
|
8239
|
+
frame_data.sampling_interval_number = 30;
|
|
7957
8240
|
break;
|
|
7958
8241
|
case 5:
|
|
7959
8242
|
frame_data.sampling_interval = "60 Minutes";
|
|
8243
|
+
frame_data.sampling_interval_number = 60;
|
|
7960
8244
|
break;
|
|
7961
8245
|
case 6:
|
|
7962
8246
|
frame_data.sampling_interval = "120 Minutes";
|
|
8247
|
+
frame_data.sampling_interval_number = 120;
|
|
7963
8248
|
break;
|
|
7964
8249
|
case 7:
|
|
7965
8250
|
frame_data.sampling_interval = "180 Minutes";
|
|
8251
|
+
frame_data.sampling_interval_number = 180;
|
|
7966
8252
|
break;
|
|
7967
8253
|
case 8:
|
|
7968
8254
|
frame_data.sampling_interval = "1 Minute";
|
|
8255
|
+
frame_data.sampling_interval_number = 1;
|
|
7969
8256
|
break;
|
|
7970
8257
|
}
|
|
7971
8258
|
frame_data.on_request_timeout = frame[27] + " Seconds";
|
|
@@ -7985,7 +8272,7 @@ function sensor_types(parent){
|
|
|
7985
8272
|
frame_data.payload_length = "180 Bytes";
|
|
7986
8273
|
break;
|
|
7987
8274
|
}
|
|
7988
|
-
switch(frame[
|
|
8275
|
+
switch(frame[30]){
|
|
7989
8276
|
case 0:
|
|
7990
8277
|
frame_data.fsr_text = "2g";
|
|
7991
8278
|
break;
|
|
@@ -8000,6 +8287,10 @@ function sensor_types(parent){
|
|
|
8000
8287
|
break;
|
|
8001
8288
|
}
|
|
8002
8289
|
frame_data.rpm_status = frame[31]? 'Enabled': 'Disabled';
|
|
8290
|
+
frame_data.auto_raw_interval = frame[36] * frame_data.sampling_interval_number || 'disabled';
|
|
8291
|
+
frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
|
|
8292
|
+
frame_data.p1_smart_mode_threshold = frame[38] * 50;
|
|
8293
|
+
frame_data.p2_smart_mode_threshold = frame[39] * 50;
|
|
8003
8294
|
return {
|
|
8004
8295
|
'firmware': frame[2],
|
|
8005
8296
|
'destination_address': toMac(frame.slice(12, 16)),
|
|
@@ -8021,8 +8312,18 @@ function sensor_types(parent){
|
|
|
8021
8312
|
'on_request_timeout': frame_data.on_request_timeout,
|
|
8022
8313
|
'deadband': frame_data.deadband,
|
|
8023
8314
|
'payload_length': frame_data.payload_length,
|
|
8024
|
-
'
|
|
8315
|
+
'fsr': frame_data.fsr_text,
|
|
8025
8316
|
'rpm_compute_status': frame_data.rpm_status,
|
|
8317
|
+
'auto_raw_destination_address': toMac(frame.slice(32 , 36)),
|
|
8318
|
+
'auto_raw_interval': frame_data.auto_raw_interval,
|
|
8319
|
+
'smart_mode_skip_count': frame[37],
|
|
8320
|
+
'smart_mode_acc_threshold_probe_1': frame_data.p1_smart_mode_threshold+'mg',
|
|
8321
|
+
'smart_mode_acc_threshold_probe_2': frame_data.p2_smart_mode_threshold+'mg',
|
|
8322
|
+
'uptime_counter_probe_1': frame.slice(40, 44).reduce(msbLsb),
|
|
8323
|
+
'uptime_counter_probe_2': frame.slice(44, 48).reduce(msbLsb),
|
|
8324
|
+
'hardware_id': frame.slice(48, 51),
|
|
8325
|
+
'reserved': frame.slice(51, 55),
|
|
8326
|
+
'tx_lifetime_counter': frame.slice(55, 59).reduce(msbLsb),
|
|
8026
8327
|
'machine_values': {
|
|
8027
8328
|
'firmware': frame[2],
|
|
8028
8329
|
'destination_address': toMac(frame.slice(12, 16), false),
|
|
@@ -8042,6 +8343,16 @@ function sensor_types(parent){
|
|
|
8042
8343
|
'payload_length': frame[29],
|
|
8043
8344
|
'fsm': frame[30],
|
|
8044
8345
|
'rpm_compute_status': frame[31],
|
|
8346
|
+
'auto_raw_destination_address': toMac(frame.slice(32 , 36)),
|
|
8347
|
+
'auto_raw_interval': frame[36],
|
|
8348
|
+
'smart_mode_skip_count': frame[37],
|
|
8349
|
+
'smart_mode_acc_threshold_probe_1':frame[38],
|
|
8350
|
+
'smart_mode_acc_threshold_probe_2':frame[39],
|
|
8351
|
+
'uptime_counter_probe_1': frame.slice(40, 44),
|
|
8352
|
+
'uptime_counter_probe_2': frame.slice(44, 48),
|
|
8353
|
+
'hardware_id': frame.slice(48, 51),
|
|
8354
|
+
'reserved': frame.slice(51, 55),
|
|
8355
|
+
'tx_lifetime_counter': frame.slice(55, 59).reduce(msbLsb)
|
|
8045
8356
|
}
|
|
8046
8357
|
}
|
|
8047
8358
|
}
|
|
@@ -8049,21 +8360,21 @@ function sensor_types(parent){
|
|
|
8049
8360
|
'112': {
|
|
8050
8361
|
name: 'Condition Based/Predictive Maintenance Sensor v4',
|
|
8051
8362
|
parse: (payload, parsed, mac) => {
|
|
8052
|
-
if(payload[7]
|
|
8363
|
+
if(payload[7] & 2){
|
|
8053
8364
|
console.log('Error found');
|
|
8054
8365
|
console.log(payload[7]);
|
|
8055
8366
|
parsed.data = {error: 'Error found, Sensor Probe may be unattached'};
|
|
8056
8367
|
return parsed;
|
|
8057
8368
|
}
|
|
8058
|
-
|
|
8369
|
+
let msg_type = (payload[7] & 16)? 'motion' : 'regular';
|
|
8059
8370
|
if(payload[8] === 1){
|
|
8060
8371
|
var deviceAddr = mac;
|
|
8061
8372
|
var firmware = payload[1];
|
|
8062
8373
|
var hour = payload[12];
|
|
8063
8374
|
var minute = payload[13];
|
|
8064
|
-
var expected_packets = payload[16];
|
|
8065
|
-
var current_packet = payload[
|
|
8066
|
-
var sdata_start =
|
|
8375
|
+
var expected_packets = msbLsb(payload[16], payload[17]);
|
|
8376
|
+
var current_packet = msbLsb(payload[18], payload[19]);
|
|
8377
|
+
var sdata_start = 20;
|
|
8067
8378
|
|
|
8068
8379
|
if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
|
|
8069
8380
|
if(expected_packets != 1){
|
|
@@ -8233,12 +8544,15 @@ function sensor_types(parent){
|
|
|
8233
8544
|
}
|
|
8234
8545
|
}
|
|
8235
8546
|
var fft_concat_obj = {
|
|
8547
|
+
mode: payload[8],
|
|
8548
|
+
msg_type: msg_type,
|
|
8236
8549
|
time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
|
|
8237
8550
|
mac_address: deviceAddr,
|
|
8238
8551
|
en_axis: globalDevices[deviceAddr].en_axis,
|
|
8239
8552
|
fsr: fsr_text,
|
|
8240
8553
|
odr: globalDevices[deviceAddr].odr,
|
|
8241
8554
|
device_temp: globalDevices[deviceAddr].device_temp,
|
|
8555
|
+
total_samples: label,
|
|
8242
8556
|
data: fft_concat
|
|
8243
8557
|
};
|
|
8244
8558
|
// console.log(globalDevices[deviceAddr].data);
|
|
@@ -8318,6 +8632,7 @@ function sensor_types(parent){
|
|
|
8318
8632
|
}
|
|
8319
8633
|
return {
|
|
8320
8634
|
mode: payload[8],
|
|
8635
|
+
msg_type: msg_type,
|
|
8321
8636
|
|
|
8322
8637
|
odr: odr,
|
|
8323
8638
|
temperature: signInt(payload.slice(10, 12).reduce(msbLsb), 16) / 100,
|
|
@@ -8366,6 +8681,9 @@ function sensor_types(parent){
|
|
|
8366
8681
|
case 2:
|
|
8367
8682
|
frame_data.mode = "Processed + Raw on demand";
|
|
8368
8683
|
break;
|
|
8684
|
+
case 3:
|
|
8685
|
+
frame_data.mode = "Smart";
|
|
8686
|
+
break;
|
|
8369
8687
|
}
|
|
8370
8688
|
switch(frame[17]){
|
|
8371
8689
|
case 6:
|
|
@@ -8477,30 +8795,39 @@ function sensor_types(parent){
|
|
|
8477
8795
|
switch(frame[22]){
|
|
8478
8796
|
case 0:
|
|
8479
8797
|
frame_data.sampling_interval = "5 Minutes";
|
|
8798
|
+
frame_data.sampling_interval_number = 5;
|
|
8480
8799
|
break;
|
|
8481
8800
|
case 1:
|
|
8482
8801
|
frame_data.sampling_interval = "10 Minutes";
|
|
8802
|
+
frame_data.sampling_interval_number = 10;
|
|
8483
8803
|
break;
|
|
8484
8804
|
case 2:
|
|
8485
8805
|
frame_data.sampling_interval = "15 Minutes";
|
|
8806
|
+
frame_data.sampling_interval_number = 15;
|
|
8486
8807
|
break;
|
|
8487
8808
|
case 2:
|
|
8488
8809
|
frame_data.sampling_interval = "20 Minutes";
|
|
8810
|
+
frame_data.sampling_interval_number = 20;
|
|
8489
8811
|
break;
|
|
8490
8812
|
case 4:
|
|
8491
8813
|
frame_data.sampling_interval = "30 Minutes";
|
|
8814
|
+
frame_data.sampling_interval_number = 30;
|
|
8492
8815
|
break;
|
|
8493
8816
|
case 5:
|
|
8494
8817
|
frame_data.sampling_interval = "60 Minutes";
|
|
8818
|
+
frame_data.sampling_interval_number = 60;
|
|
8495
8819
|
break;
|
|
8496
8820
|
case 6:
|
|
8497
8821
|
frame_data.sampling_interval = "120 Minutes";
|
|
8822
|
+
frame_data.sampling_interval_number = 120;
|
|
8498
8823
|
break;
|
|
8499
8824
|
case 7:
|
|
8500
8825
|
frame_data.sampling_interval = "180 Minutes";
|
|
8826
|
+
frame_data.sampling_interval_number = 180;
|
|
8501
8827
|
break;
|
|
8502
8828
|
case 8:
|
|
8503
8829
|
frame_data.sampling_interval = "1 Minute";
|
|
8830
|
+
frame_data.sampling_interval_number = 1;
|
|
8504
8831
|
break;
|
|
8505
8832
|
}
|
|
8506
8833
|
frame_data.on_request_timeout = frame[23] + " Seconds";
|
|
@@ -8535,6 +8862,9 @@ function sensor_types(parent){
|
|
|
8535
8862
|
break;
|
|
8536
8863
|
}
|
|
8537
8864
|
frame_data.rpm_status = frame[27]? 'Enabled': 'Disabled';
|
|
8865
|
+
frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
|
|
8866
|
+
frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
|
|
8867
|
+
frame_data.smart_mode_threshold = frame[34] * 50;
|
|
8538
8868
|
return {
|
|
8539
8869
|
'firmware': frame[2],
|
|
8540
8870
|
'destination_address': toMac(frame.slice(12, 16)),
|
|
@@ -8550,8 +8880,16 @@ function sensor_types(parent){
|
|
|
8550
8880
|
'on_request_timeout': frame_data.on_request_timeout,
|
|
8551
8881
|
'deadband': frame_data.deadband,
|
|
8552
8882
|
'payload_length': frame_data.payload_length,
|
|
8553
|
-
'
|
|
8883
|
+
'fsr': frame_data.fsr_text,
|
|
8554
8884
|
'rpm_compute_status': frame_data.rpm_status,
|
|
8885
|
+
'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
|
|
8886
|
+
'auto_raw_interval': frame_data.auto_raw_interval,
|
|
8887
|
+
'smart_mode_skip_count': frame[33],
|
|
8888
|
+
'smart_mode_acc_threshold': frame_data.smart_mode_threshold+'mg',
|
|
8889
|
+
'uptime_counter': frame.slice(35, 39).reduce(msbLsb),
|
|
8890
|
+
'hardware_id': frame.slice(39, 42),
|
|
8891
|
+
'reserved': frame.slice(42, 46),
|
|
8892
|
+
'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
|
|
8555
8893
|
'machine_values': {
|
|
8556
8894
|
'firmware': frame[2],
|
|
8557
8895
|
'destination_address': toMac(frame.slice(12, 16), false),
|
|
@@ -8566,7 +8904,15 @@ function sensor_types(parent){
|
|
|
8566
8904
|
'deadband': frame[24],
|
|
8567
8905
|
'payload_length': frame[25],
|
|
8568
8906
|
'fsm': frame[26],
|
|
8569
|
-
|
|
8907
|
+
'rpm_compute_status': frame[27],
|
|
8908
|
+
'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
|
|
8909
|
+
'auto_raw_interval': frame[32],
|
|
8910
|
+
'smart_mode_skip_count': frame[33],
|
|
8911
|
+
'smart_mode_acc_threshold':frame[34],
|
|
8912
|
+
'uptime_counter': frame.slice(35, 39),
|
|
8913
|
+
'hardware_id': frame.slice(39, 42),
|
|
8914
|
+
'reserved': frame.slice(42, 46),
|
|
8915
|
+
'tx_lifetime_counter': frame.slice(46, 50)
|
|
8570
8916
|
}
|
|
8571
8917
|
}
|
|
8572
8918
|
}
|
|
@@ -8574,72 +8920,57 @@ function sensor_types(parent){
|
|
|
8574
8920
|
'114': {
|
|
8575
8921
|
name: 'Standalone Smart Vibration Sensor v4',
|
|
8576
8922
|
parse: (payload, parsed, mac) => {
|
|
8577
|
-
if(payload[7]
|
|
8923
|
+
if(payload[7] & 2){
|
|
8578
8924
|
console.log('Error found');
|
|
8579
8925
|
parsed.data = {error: 'Error found, Sensor Probe may be unattached'};
|
|
8580
8926
|
return parsed;
|
|
8581
8927
|
}
|
|
8582
|
-
|
|
8928
|
+
let msg_type = (payload[7] & 16)? 'motion' : 'regular';
|
|
8583
8929
|
if(payload[8] === 1){
|
|
8584
8930
|
var deviceAddr = mac;
|
|
8585
8931
|
var firmware = payload[1];
|
|
8586
8932
|
var hour = payload[12];
|
|
8587
8933
|
var minute = payload[13];
|
|
8588
|
-
var expected_packets = payload[16];
|
|
8589
|
-
var current_packet = payload[
|
|
8590
|
-
var sdata_start =
|
|
8934
|
+
var expected_packets = msbLsb(payload[16], payload[17]);
|
|
8935
|
+
var current_packet = msbLsb(payload[18], payload[19]);
|
|
8936
|
+
var sdata_start = 20;
|
|
8591
8937
|
|
|
8592
8938
|
if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
|
|
8593
8939
|
if(expected_packets != 1){
|
|
8594
|
-
// if
|
|
8595
|
-
if(
|
|
8596
|
-
console.log('
|
|
8597
|
-
|
|
8598
|
-
|
|
8599
|
-
|
|
8600
|
-
|
|
8601
|
-
|
|
8602
|
-
console.log(!((current_packet-1) in globalDevices[deviceAddr].data));
|
|
8603
|
-
if(this.hasOwnProperty('failure_no')){
|
|
8604
|
-
this.failure_no = this.failure_no + 1;
|
|
8605
|
-
}
|
|
8606
|
-
else{
|
|
8607
|
-
this.failure_no = 1;
|
|
8608
|
-
}
|
|
8609
|
-
if(this.hasOwnProperty('failure_no')){
|
|
8610
|
-
console.log('####falure no');
|
|
8611
|
-
console.log(this.failure_no);
|
|
8612
|
-
}
|
|
8613
|
-
// console.log(globalDevices[deviceAddr].data);
|
|
8940
|
+
// if current packet is equal to last one (duplicated data). This does not apply to the last package
|
|
8941
|
+
if (globalDevices[deviceAddr].last_packet_counter == current_packet){
|
|
8942
|
+
console.log('Duplicated message')
|
|
8943
|
+
return;
|
|
8944
|
+
}
|
|
8945
|
+
// if current packet is equal to 1 or last packet counter is higher thant current packet
|
|
8946
|
+
if(current_packet == 1 || (globalDevices[deviceAddr].last_packet_counter > current_packet)){
|
|
8947
|
+
// clear stream
|
|
8614
8948
|
delete globalDevices[deviceAddr];
|
|
8615
|
-
|
|
8616
|
-
|
|
8617
|
-
|
|
8618
|
-
|
|
8619
|
-
|
|
8620
|
-
|
|
8621
|
-
|
|
8622
|
-
|
|
8623
|
-
|
|
8624
|
-
|
|
8625
|
-
|
|
8626
|
-
|
|
8627
|
-
|
|
8628
|
-
|
|
8629
|
-
|
|
8630
|
-
|
|
8631
|
-
fsr: fsr,
|
|
8632
|
-
hour: hour,
|
|
8633
|
-
minute: minute,
|
|
8634
|
-
device_temp: device_temp,
|
|
8635
|
-
}
|
|
8636
|
-
globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
|
|
8637
|
-
return;
|
|
8949
|
+
// create new stream
|
|
8950
|
+
var mode = payload[8];
|
|
8951
|
+
var odr = msbLsb(payload[9], payload[10])
|
|
8952
|
+
var en_axis = payload[11] & 7;
|
|
8953
|
+
var fsr = payload[11] >> 5;
|
|
8954
|
+
var device_temp = msbLsb(payload[14], payload[15])/100;
|
|
8955
|
+
|
|
8956
|
+
globalDevices[deviceAddr] = {
|
|
8957
|
+
data: {},
|
|
8958
|
+
odr: odr,
|
|
8959
|
+
mo: mode,
|
|
8960
|
+
en_axis: en_axis,
|
|
8961
|
+
fsr: fsr,
|
|
8962
|
+
hour: hour,
|
|
8963
|
+
minute: minute,
|
|
8964
|
+
device_temp: device_temp,
|
|
8638
8965
|
}
|
|
8639
|
-
|
|
8640
|
-
else{
|
|
8966
|
+
globalDevices[deviceAddr].last_packet_counter = current_packet;
|
|
8641
8967
|
globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
|
|
8968
|
+
return;
|
|
8642
8969
|
}
|
|
8970
|
+
else{
|
|
8971
|
+
globalDevices[deviceAddr].last_packet_counter = current_packet;
|
|
8972
|
+
globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
|
|
8973
|
+
}
|
|
8643
8974
|
}
|
|
8644
8975
|
else{
|
|
8645
8976
|
var mode = payload[8];
|
|
@@ -8649,7 +8980,6 @@ function sensor_types(parent){
|
|
|
8649
8980
|
var device_temp = msbLsb(payload[14], payload[15])/100;
|
|
8650
8981
|
|
|
8651
8982
|
globalDevices[deviceAddr] = {
|
|
8652
|
-
// stream_size: expected_packets,
|
|
8653
8983
|
data: {},
|
|
8654
8984
|
odr: odr,
|
|
8655
8985
|
mo: mode,
|
|
@@ -8659,126 +8989,11 @@ function sensor_types(parent){
|
|
|
8659
8989
|
minute: minute,
|
|
8660
8990
|
device_temp: device_temp,
|
|
8661
8991
|
}
|
|
8992
|
+
globalDevices[deviceAddr].last_packet_counter = current_packet;
|
|
8662
8993
|
globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
|
|
8663
8994
|
}
|
|
8664
|
-
|
|
8665
|
-
|
|
8666
|
-
for(const packet in globalDevices[deviceAddr].data){
|
|
8667
|
-
raw_data = raw_data.concat(globalDevices[deviceAddr].data[packet]);
|
|
8668
|
-
}
|
|
8669
|
-
var label = 0;
|
|
8670
|
-
|
|
8671
|
-
var fft = new Array();
|
|
8672
|
-
var fft_concat = {};
|
|
8673
|
-
|
|
8674
|
-
var en_axis_data = {};
|
|
8675
|
-
switch (globalDevices[deviceAddr].en_axis){
|
|
8676
|
-
case 1:
|
|
8677
|
-
en_axis_data.x_offset = 0;
|
|
8678
|
-
en_axis_data.increment = 2;
|
|
8679
|
-
break;
|
|
8680
|
-
case 2:
|
|
8681
|
-
en_axis_data.y_offset = 0;
|
|
8682
|
-
en_axis_data.increment = 2;
|
|
8683
|
-
break;
|
|
8684
|
-
case 3:
|
|
8685
|
-
en_axis_data.x_offset = 0;
|
|
8686
|
-
en_axis_data.y_offset = 2;
|
|
8687
|
-
en_axis_data.increment = 4;
|
|
8688
|
-
break;
|
|
8689
|
-
case 4:
|
|
8690
|
-
en_axis_data.z_offset = 0;
|
|
8691
|
-
en_axis_data.increment = 2;
|
|
8692
|
-
break;
|
|
8693
|
-
case 5:
|
|
8694
|
-
en_axis_data.x_offset = 0;
|
|
8695
|
-
en_axis_data.z_offset = 2;
|
|
8696
|
-
en_axis_data.increment = 4;
|
|
8697
|
-
break;
|
|
8698
|
-
case 6:
|
|
8699
|
-
en_axis_data.y_offset = 0;
|
|
8700
|
-
en_axis_data.z_offset = 2;
|
|
8701
|
-
en_axis_data.increment = 4;
|
|
8702
|
-
break;
|
|
8703
|
-
case 7:
|
|
8704
|
-
en_axis_data.x_offset = 0;
|
|
8705
|
-
en_axis_data.y_offset = 2;
|
|
8706
|
-
en_axis_data.z_offset = 4;
|
|
8707
|
-
en_axis_data.increment = 6;
|
|
8708
|
-
break;
|
|
8709
|
-
default:
|
|
8710
|
-
en_axis_data.increment = 0;
|
|
8711
|
-
}
|
|
8712
|
-
|
|
8713
|
-
var fsr_mult = .00006;
|
|
8714
|
-
var fsr_text = "";
|
|
8715
|
-
switch(globalDevices[deviceAddr].fsr){
|
|
8716
|
-
case 0:
|
|
8717
|
-
fsr_mult = 0.00006;
|
|
8718
|
-
break;
|
|
8719
|
-
case 1:
|
|
8720
|
-
fsr_mult = 0.00012;
|
|
8721
|
-
break;
|
|
8722
|
-
case 2:
|
|
8723
|
-
fsr_mult = 0.00024;
|
|
8724
|
-
break;
|
|
8725
|
-
case 3:
|
|
8726
|
-
fsr_mult = 0.00049;
|
|
8727
|
-
break;
|
|
8728
|
-
}
|
|
8729
|
-
switch(globalDevices[deviceAddr].fsr){
|
|
8730
|
-
case 0:
|
|
8731
|
-
fsr_text = "2g";
|
|
8732
|
-
break;
|
|
8733
|
-
case 1:
|
|
8734
|
-
fsr_text = "4g";
|
|
8735
|
-
break;
|
|
8736
|
-
case 2:
|
|
8737
|
-
fsr_text = "8g";
|
|
8738
|
-
break;
|
|
8739
|
-
case 3:
|
|
8740
|
-
fsr_text = "16g";
|
|
8741
|
-
break;
|
|
8742
|
-
}
|
|
8743
|
-
|
|
8744
|
-
for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
|
|
8745
|
-
label++;
|
|
8746
|
-
|
|
8747
|
-
fft_concat[label] = {};
|
|
8748
|
-
|
|
8749
|
-
if('x_offset' in en_axis_data){
|
|
8750
|
-
fft_concat[label].x = parseFloat((signInt(((raw_data[i+en_axis_data.x_offset]<<8)+(raw_data[i+en_axis_data.x_offset+1])), 16)*fsr_mult).toFixed(2));
|
|
8751
|
-
}
|
|
8752
|
-
if('y_offset' in en_axis_data){
|
|
8753
|
-
fft_concat[label].y = parseFloat((signInt(((raw_data[i+en_axis_data.y_offset]<<8)+(raw_data[i+en_axis_data.y_offset+1])), 16)*fsr_mult).toFixed(2));
|
|
8754
|
-
}
|
|
8755
|
-
if('z_offset' in en_axis_data){
|
|
8756
|
-
fft_concat[label].z = parseFloat((signInt(((raw_data[i+en_axis_data.z_offset]<<8)+(raw_data[i+en_axis_data.z_offset+1])), 16)*fsr_mult).toFixed(2));
|
|
8757
|
-
}
|
|
8758
|
-
}
|
|
8759
|
-
var fft_concat_obj = {
|
|
8760
|
-
time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
|
|
8761
|
-
mac_address: deviceAddr,
|
|
8762
|
-
en_axis: globalDevices[deviceAddr].en_axis,
|
|
8763
|
-
fsr: fsr_text,
|
|
8764
|
-
odr: globalDevices[deviceAddr].odr,
|
|
8765
|
-
device_temp: globalDevices[deviceAddr].device_temp,
|
|
8766
|
-
data: fft_concat
|
|
8767
|
-
};
|
|
8768
|
-
sensor_data = fft_concat_obj;
|
|
8769
|
-
delete globalDevices[deviceAddr];
|
|
8770
|
-
if(this.hasOwnProperty('failure_no')){
|
|
8771
|
-
console.log('####falure no');
|
|
8772
|
-
console.log(this.failure_no);
|
|
8773
|
-
}
|
|
8774
|
-
|
|
8775
|
-
return sensor_data;
|
|
8776
|
-
}
|
|
8777
|
-
else{
|
|
8778
|
-
return;
|
|
8779
|
-
}
|
|
8780
|
-
}else{
|
|
8781
|
-
|
|
8995
|
+
}
|
|
8996
|
+
else{
|
|
8782
8997
|
var mode = payload[8];
|
|
8783
8998
|
var odr = msbLsb(payload[9], payload[10])
|
|
8784
8999
|
var en_axis = payload[11] & 7;
|
|
@@ -8786,7 +9001,6 @@ function sensor_types(parent){
|
|
|
8786
9001
|
var device_temp = msbLsb(payload[14], payload[15])/100;
|
|
8787
9002
|
|
|
8788
9003
|
globalDevices[deviceAddr] = {
|
|
8789
|
-
// stream_size: expected_packets,
|
|
8790
9004
|
data: {},
|
|
8791
9005
|
odr: odr,
|
|
8792
9006
|
mo: mode,
|
|
@@ -8796,7 +9010,123 @@ function sensor_types(parent){
|
|
|
8796
9010
|
minute: minute,
|
|
8797
9011
|
device_temp: device_temp,
|
|
8798
9012
|
}
|
|
9013
|
+
globalDevices[deviceAddr].last_packet_counter = current_packet;
|
|
8799
9014
|
globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
|
|
9015
|
+
}
|
|
9016
|
+
if(current_packet == expected_packets){
|
|
9017
|
+
var raw_data = new Array();
|
|
9018
|
+
for(const packet in globalDevices[deviceAddr].data){
|
|
9019
|
+
raw_data = raw_data.concat(globalDevices[deviceAddr].data[packet]);
|
|
9020
|
+
}
|
|
9021
|
+
var label = 0;
|
|
9022
|
+
|
|
9023
|
+
var fft = new Array();
|
|
9024
|
+
var fft_concat = {};
|
|
9025
|
+
|
|
9026
|
+
var en_axis_data = {};
|
|
9027
|
+
switch (globalDevices[deviceAddr].en_axis){
|
|
9028
|
+
case 1:
|
|
9029
|
+
en_axis_data.x_offset = 0;
|
|
9030
|
+
en_axis_data.increment = 2;
|
|
9031
|
+
break;
|
|
9032
|
+
case 2:
|
|
9033
|
+
en_axis_data.y_offset = 0;
|
|
9034
|
+
en_axis_data.increment = 2;
|
|
9035
|
+
break;
|
|
9036
|
+
case 3:
|
|
9037
|
+
en_axis_data.x_offset = 0;
|
|
9038
|
+
en_axis_data.y_offset = 2;
|
|
9039
|
+
en_axis_data.increment = 4;
|
|
9040
|
+
break;
|
|
9041
|
+
case 4:
|
|
9042
|
+
en_axis_data.z_offset = 0;
|
|
9043
|
+
en_axis_data.increment = 2;
|
|
9044
|
+
break;
|
|
9045
|
+
case 5:
|
|
9046
|
+
en_axis_data.x_offset = 0;
|
|
9047
|
+
en_axis_data.z_offset = 2;
|
|
9048
|
+
en_axis_data.increment = 4;
|
|
9049
|
+
break;
|
|
9050
|
+
case 6:
|
|
9051
|
+
en_axis_data.y_offset = 0;
|
|
9052
|
+
en_axis_data.z_offset = 2;
|
|
9053
|
+
en_axis_data.increment = 4;
|
|
9054
|
+
break;
|
|
9055
|
+
case 7:
|
|
9056
|
+
en_axis_data.x_offset = 0;
|
|
9057
|
+
en_axis_data.y_offset = 2;
|
|
9058
|
+
en_axis_data.z_offset = 4;
|
|
9059
|
+
en_axis_data.increment = 6;
|
|
9060
|
+
break;
|
|
9061
|
+
default:
|
|
9062
|
+
en_axis_data.increment = 0;
|
|
9063
|
+
}
|
|
9064
|
+
|
|
9065
|
+
var fsr_mult = .00006;
|
|
9066
|
+
var fsr_text = "";
|
|
9067
|
+
|
|
9068
|
+
switch(globalDevices[deviceAddr].fsr){
|
|
9069
|
+
case 0:
|
|
9070
|
+
fsr_mult = 0.00006;
|
|
9071
|
+
break;
|
|
9072
|
+
case 1:
|
|
9073
|
+
fsr_mult = 0.00012;
|
|
9074
|
+
break;
|
|
9075
|
+
case 2:
|
|
9076
|
+
fsr_mult = 0.00024;
|
|
9077
|
+
break;
|
|
9078
|
+
case 3:
|
|
9079
|
+
fsr_mult = 0.00049;
|
|
9080
|
+
break;
|
|
9081
|
+
}
|
|
9082
|
+
switch(globalDevices[deviceAddr].fsr){
|
|
9083
|
+
case 0:
|
|
9084
|
+
fsr_text = "2g";
|
|
9085
|
+
break;
|
|
9086
|
+
case 1:
|
|
9087
|
+
fsr_text = "4g";
|
|
9088
|
+
break;
|
|
9089
|
+
case 2:
|
|
9090
|
+
fsr_text = "8g";
|
|
9091
|
+
break;
|
|
9092
|
+
case 3:
|
|
9093
|
+
fsr_text = "16g";
|
|
9094
|
+
break;
|
|
9095
|
+
}
|
|
9096
|
+
|
|
9097
|
+
for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
|
|
9098
|
+
label++;
|
|
9099
|
+
|
|
9100
|
+
fft_concat[label] = {};
|
|
9101
|
+
|
|
9102
|
+
if('x_offset' in en_axis_data){
|
|
9103
|
+
fft_concat[label].x = parseFloat((signInt(((raw_data[i+en_axis_data.x_offset]<<8)+(raw_data[i+en_axis_data.x_offset+1])), 16)*fsr_mult).toFixed(2));
|
|
9104
|
+
}
|
|
9105
|
+
if('y_offset' in en_axis_data){
|
|
9106
|
+
fft_concat[label].y = parseFloat((signInt(((raw_data[i+en_axis_data.y_offset]<<8)+(raw_data[i+en_axis_data.y_offset+1])), 16)*fsr_mult).toFixed(2));
|
|
9107
|
+
}
|
|
9108
|
+
if('z_offset' in en_axis_data){
|
|
9109
|
+
fft_concat[label].z = parseFloat((signInt(((raw_data[i+en_axis_data.z_offset]<<8)+(raw_data[i+en_axis_data.z_offset+1])), 16)*fsr_mult).toFixed(2));
|
|
9110
|
+
}
|
|
9111
|
+
}
|
|
9112
|
+
var fft_concat_obj = {
|
|
9113
|
+
mode: payload[8],
|
|
9114
|
+
msg_type: msg_type,
|
|
9115
|
+
time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
|
|
9116
|
+
mac_address: deviceAddr,
|
|
9117
|
+
en_axis: globalDevices[deviceAddr].en_axis,
|
|
9118
|
+
fsr: fsr_text,
|
|
9119
|
+
odr: globalDevices[deviceAddr].odr,
|
|
9120
|
+
device_temp: globalDevices[deviceAddr].device_temp,
|
|
9121
|
+
total_samples: label,
|
|
9122
|
+
ft_confidence : ((globalDevices[deviceAddr].counter / expected_packets) * 100).toFixed(2) + '%',
|
|
9123
|
+
data: fft_concat
|
|
9124
|
+
};
|
|
9125
|
+
sensor_data = fft_concat_obj;
|
|
9126
|
+
delete globalDevices[deviceAddr];
|
|
9127
|
+
return sensor_data;
|
|
9128
|
+
}
|
|
9129
|
+
else{
|
|
8800
9130
|
return;
|
|
8801
9131
|
}
|
|
8802
9132
|
}
|
|
@@ -8838,6 +9168,7 @@ function sensor_types(parent){
|
|
|
8838
9168
|
}
|
|
8839
9169
|
return {
|
|
8840
9170
|
mode: payload[8],
|
|
9171
|
+
msg_type: msg_type,
|
|
8841
9172
|
|
|
8842
9173
|
odr: odr,
|
|
8843
9174
|
temperature: signInt(payload.slice(10, 12).reduce(msbLsb), 16) / 100,
|
|
@@ -8885,6 +9216,9 @@ function sensor_types(parent){
|
|
|
8885
9216
|
case 2:
|
|
8886
9217
|
frame_data.mode = "Processed + Raw on demand";
|
|
8887
9218
|
break;
|
|
9219
|
+
case 3:
|
|
9220
|
+
frame_data.mode = "Smart";
|
|
9221
|
+
break;
|
|
8888
9222
|
}
|
|
8889
9223
|
switch(frame[17]){
|
|
8890
9224
|
case 6:
|
|
@@ -8996,30 +9330,39 @@ function sensor_types(parent){
|
|
|
8996
9330
|
switch(frame[22]){
|
|
8997
9331
|
case 0:
|
|
8998
9332
|
frame_data.sampling_interval = "5 Minutes";
|
|
9333
|
+
frame_data.sampling_interval_number = 5;
|
|
8999
9334
|
break;
|
|
9000
9335
|
case 1:
|
|
9001
9336
|
frame_data.sampling_interval = "10 Minutes";
|
|
9337
|
+
frame_data.sampling_interval_number = 10;
|
|
9002
9338
|
break;
|
|
9003
9339
|
case 2:
|
|
9004
9340
|
frame_data.sampling_interval = "15 Minutes";
|
|
9341
|
+
frame_data.sampling_interval_number = 15;
|
|
9005
9342
|
break;
|
|
9006
9343
|
case 2:
|
|
9007
9344
|
frame_data.sampling_interval = "20 Minutes";
|
|
9345
|
+
frame_data.sampling_interval_number = 20;
|
|
9008
9346
|
break;
|
|
9009
9347
|
case 4:
|
|
9010
9348
|
frame_data.sampling_interval = "30 Minutes";
|
|
9349
|
+
frame_data.sampling_interval_number = 30;
|
|
9011
9350
|
break;
|
|
9012
9351
|
case 5:
|
|
9013
9352
|
frame_data.sampling_interval = "60 Minutes";
|
|
9353
|
+
frame_data.sampling_interval_number = 60;
|
|
9014
9354
|
break;
|
|
9015
9355
|
case 6:
|
|
9016
9356
|
frame_data.sampling_interval = "120 Minutes";
|
|
9357
|
+
frame_data.sampling_interval_number = 120;
|
|
9017
9358
|
break;
|
|
9018
9359
|
case 7:
|
|
9019
9360
|
frame_data.sampling_interval = "180 Minutes";
|
|
9361
|
+
frame_data.sampling_interval_number = 180;
|
|
9020
9362
|
break;
|
|
9021
9363
|
case 8:
|
|
9022
9364
|
frame_data.sampling_interval = "1 Minute";
|
|
9365
|
+
frame_data.sampling_interval_number = 1;
|
|
9023
9366
|
break;
|
|
9024
9367
|
}
|
|
9025
9368
|
frame_data.on_request_timeout = frame[23] + " Seconds";
|
|
@@ -9054,6 +9397,9 @@ function sensor_types(parent){
|
|
|
9054
9397
|
break;
|
|
9055
9398
|
}
|
|
9056
9399
|
frame_data.rpm_status = frame[27]? 'Enabled': 'Disabled';
|
|
9400
|
+
frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
|
|
9401
|
+
frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
|
|
9402
|
+
frame_data.smart_mode_threshold = frame[34] * 50;
|
|
9057
9403
|
return {
|
|
9058
9404
|
'firmware': frame[2],
|
|
9059
9405
|
'destination_address': toMac(frame.slice(12, 16)),
|
|
@@ -9071,6 +9417,14 @@ function sensor_types(parent){
|
|
|
9071
9417
|
'payload_length': frame_data.payload_length,
|
|
9072
9418
|
'fsr': frame_data.fsr_text,
|
|
9073
9419
|
'rpm_compute_status': frame_data.rpm_status,
|
|
9420
|
+
'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
|
|
9421
|
+
'auto_raw_interval': frame_data.auto_raw_interval,
|
|
9422
|
+
'smart_mode_skip_count': frame[33],
|
|
9423
|
+
'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
|
|
9424
|
+
'uptime_counter': frame.slice(35, 39).reduce(msbLsb),
|
|
9425
|
+
'hardware_id': frame.slice(39, 42),
|
|
9426
|
+
'reserved': frame.slice(42, 46),
|
|
9427
|
+
'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
|
|
9074
9428
|
'machine_values': {
|
|
9075
9429
|
'firmware': frame[2],
|
|
9076
9430
|
'destination_address': toMac(frame.slice(12, 16), false),
|
|
@@ -9085,7 +9439,15 @@ function sensor_types(parent){
|
|
|
9085
9439
|
'deadband': frame[24],
|
|
9086
9440
|
'payload_length': frame[25],
|
|
9087
9441
|
'fsr': frame[26],
|
|
9088
|
-
|
|
9442
|
+
'rpm_compute_status': frame[27],
|
|
9443
|
+
'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
|
|
9444
|
+
'auto_raw_interval': frame[32],
|
|
9445
|
+
'smart_mode_skip_count': frame[33],
|
|
9446
|
+
'smart_mode_acc_threshold':frame[34],
|
|
9447
|
+
'uptime_counter': frame.slice(35, 39),
|
|
9448
|
+
'hardware_id': frame.slice(39, 42),
|
|
9449
|
+
'reserved': frame.slice(42, 46),
|
|
9450
|
+
'tx_lifetime_counter': frame.slice(46, 50)
|
|
9089
9451
|
}
|
|
9090
9452
|
}
|
|
9091
9453
|
}
|
|
@@ -9173,6 +9535,34 @@ function sensor_types(parent){
|
|
|
9173
9535
|
}
|
|
9174
9536
|
}
|
|
9175
9537
|
},
|
|
9538
|
+
'120': {
|
|
9539
|
+
name: 'Wireless H2S Sensor',
|
|
9540
|
+
parse: (d) => {
|
|
9541
|
+
return {
|
|
9542
|
+
ppm: d.slice(0, 2).reduce(msbLsb),
|
|
9543
|
+
temperature: signInt(d.slice(2, 4).reduce(msbLsb), 16) / 100,
|
|
9544
|
+
humidity: signInt(d.slice(4, 6).reduce(msbLsb), 16) / 100
|
|
9545
|
+
};
|
|
9546
|
+
},
|
|
9547
|
+
'parse_fly': (frame) => {
|
|
9548
|
+
return {
|
|
9549
|
+
'firmware': frame[2],
|
|
9550
|
+
'h2s_threshold': frame[12],
|
|
9551
|
+
'always_on_status': frame[13],
|
|
9552
|
+
'hardware_id': frame.slice(14, 17),
|
|
9553
|
+
'sample_rate': frame.slice(17, 21).reduce(msbLsb) + " Sec.",
|
|
9554
|
+
'tx_life_counter': frame.slice(21, 25).reduce(msbLsb),
|
|
9555
|
+
'machine_values': {
|
|
9556
|
+
'firmware': frame[2],
|
|
9557
|
+
'h2s threshold': frame[12],
|
|
9558
|
+
'always_on_status': frame[13],
|
|
9559
|
+
'hardware_id': frame.slice(14, 17),
|
|
9560
|
+
'sample_rate': frame.slice(17, 21).reduce(msbLsb),
|
|
9561
|
+
'tx_life_counter': frame.slice(21, 25).reduce(msbLsb)
|
|
9562
|
+
}
|
|
9563
|
+
}
|
|
9564
|
+
}
|
|
9565
|
+
},
|
|
9176
9566
|
'180': {
|
|
9177
9567
|
name: 'C1D2 One Channel Vibration Plus',
|
|
9178
9568
|
parse: (payload, parsed, mac) => {
|
|
@@ -9223,11 +9613,8 @@ function sensor_types(parent){
|
|
|
9223
9613
|
'217': {
|
|
9224
9614
|
name: 'Wireless Weight Scale',
|
|
9225
9615
|
parse: (d) => {
|
|
9226
|
-
let units;
|
|
9227
|
-
d[0] ? units = "Kg" : units = "Lbs"
|
|
9228
9616
|
return {
|
|
9229
|
-
|
|
9230
|
-
weight: signInt(d.slice(1, 4).reduce(msbLsb)) * 100
|
|
9617
|
+
weight: signInt(d.slice(0, 4).reduce(msbLsb)) / 100
|
|
9231
9618
|
};
|
|
9232
9619
|
}
|
|
9233
9620
|
},
|
|
@@ -9444,6 +9831,16 @@ function sensor_types(parent){
|
|
|
9444
9831
|
}
|
|
9445
9832
|
}
|
|
9446
9833
|
},
|
|
9834
|
+
'518': {
|
|
9835
|
+
name: 'Custom Air Velocity',
|
|
9836
|
+
parse: (d) => {
|
|
9837
|
+
return {
|
|
9838
|
+
pressure: signInt(d.slice(0, 4).reduce(msbLsb), 16) / 100,
|
|
9839
|
+
temperature: signInt(d.slice(4, 6).reduce(msbLsb), 16) / 100,
|
|
9840
|
+
velocity: signInt(d.slice(6, 8).reduce(msbLsb), 16) / 1000
|
|
9841
|
+
};
|
|
9842
|
+
}
|
|
9843
|
+
},
|
|
9447
9844
|
'519': {
|
|
9448
9845
|
name: 'Type 519 - Vibration',
|
|
9449
9846
|
parse: (payload, parsed, mac) => {
|