@ncd-io/node-red-enterprise-sensors 1.2.3 → 1.4.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.
Files changed (4) hide show
  1. package/lib/WirelessGateway.js +3067 -1145
  2. package/package.json +1 -1
  3. package/wireless.html +551 -213
  4. package/wireless.js +465 -39
package/lib/WirelessGateway.js CHANGED
@@ -136,9 +136,9 @@ module.exports = class WirelessSensor{
136
136
  if(globalDevices[frame.mac].command_queue[0].hasOwnProperty('meta')){
137
137
  query_data.meta = globalDevices[frame.mac].command_queue[0].meta;
138
138
  }
139
- };
140
- this._emitter.emit('converter_ack-'+frame.mac, query_data);
141
- return;
139
+ this._emitter.emit('converter_ack-'+frame.mac, query_data);
140
+ return;
141
+ }
142
142
  // }
143
143
  }
144
144
  var type = this.payloadType[frame.data[0]];
@@ -160,7 +160,7 @@ module.exports = class WirelessSensor{
160
160
  }
161
161
  }
162
162
  // #OTF
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];
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,103,105,106,107,108,109,110,111,112,114,117,118,120,121,122,180,181,202,217,519,520,521,531,535,537,538,539,540,1010,1011];
164
164
  var device_type = msbLsb(frame.data[6], frame.data[7]);
165
165
  // var device_type = frame.data[7];
166
166
 
@@ -214,12 +214,24 @@ module.exports = class WirelessSensor{
214
214
  };
215
215
 
216
216
  if(mode === 'FLY' && frame.data.length > 12 && typeof this.sensor_types[data.sensor_type].parse_fly == 'function'){
217
- this.sensor_pool[frame.mac].reported_config = this.sensor_types[data.sensor_type].parse_fly(frame.data);
217
+ try{
218
+ this.sensor_pool[frame.mac].reported_config = this.sensor_types[data.sensor_type].parse_fly(frame.data);
219
+ } catch(error) {
220
+ console.log('Error detect in parse_fly initiated by FLY message');
221
+ console.log(error);
222
+ this.sensor_pool[frame.mac].reported_config = "Error parsing reported config. See log for details."
223
+ }
218
224
  }else if(mode === 'OTF' && frame.data.length > 12 && typeof this.sensor_types[data.sensor_type].parse_fly == 'function'){
219
225
  // restructure and add dead bytes to match FLY message so we only need one parser.
220
226
  // If we ever need to add any of the additional information of this packet we will need to rebuild to match
221
- frame.data.splice(2,0,frame.data[5],0);
222
- this.sensor_pool[frame.mac].reported_config = this.sensor_types[data.sensor_type].parse_fly(frame.data);
227
+ try{
228
+ frame.data.splice(2,0,frame.data[5],0);
229
+ this.sensor_pool[frame.mac].reported_config = this.sensor_types[data.sensor_type].parse_fly(frame.data);
230
+ } catch(error){
231
+ console.log('Error detect in parse_fly initiated by OTF message');
232
+ console.log(error);
233
+ this.sensor_pool[frame.mac].reported_config = "Error parsing reported config. See log for details."
234
+ }
223
235
  }else if(mode === 'ACK'){
224
236
  this.sensor_pool[frame.mac].status = data.result;
225
237
  if(data.data.length){
@@ -322,7 +334,7 @@ module.exports = class WirelessSensor{
322
334
  };
323
335
 
324
336
  // #OTF
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];
337
+ 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,103,105,106,107,108,109,110,111,112,114,117,118,120,121,122,180,181,202,217,519,520,521,531,535,537,538,539,540,1010,1011];
326
338
  if(otf_devices.includes(parsed.sensor_type)){
327
339
  // If the message says FLY and there is not FLY timer in progress.
328
340
  if(payload[8] == 70 && payload[9] == 76 && payload[10] == 89) {
@@ -744,7 +756,7 @@ module.exports = class WirelessSensor{
744
756
  data: payload.slice(8)
745
757
  };
746
758
  // #OTF
747
- }else if(parsed.sensor_type == 33 || parsed.sensor_type == 80 || parsed.sensor_type == 81 || parsed.sensor_type == 82 || parsed.sensor_type == 84 || parsed.sensor_type == 97 || parsed.sensor_type == 98 || parsed.sensor_type == 110 || parsed.sensor_type == 111 || parsed.sensor_type == 112 || parsed.sensor_type == 114 || parsed.sensor_type == 180 || parsed.sensor_type == 181 || parsed.sensor_type == 202 || parsed.sensor_type == 515 || parsed.sensor_type == 519 || parsed.sensor_type == 531 || parsed.sensor_type == 537 || parsed.sensor_type == 538){
759
+ }else if(parsed.sensor_type == 21 || parsed.sensor_type == 33 || parsed.sensor_type == 80 || parsed.sensor_type == 81 || parsed.sensor_type == 82 || parsed.sensor_type == 84 || parsed.sensor_type == 97 || parsed.sensor_type == 98 || parsed.sensor_type == 103 || parsed.sensor_type == 110 || parsed.sensor_type == 111 || parsed.sensor_type == 112 || parsed.sensor_type == 114 || parsed.sensor_type == 117 || parsed.sensor_type == 180 || parsed.sensor_type == 181 || parsed.sensor_type == 202 || parsed.sensor_type == 515 || parsed.sensor_type == 519 || parsed.sensor_type == 531 || parsed.sensor_type == 537 || parsed.sensor_type == 538){
748
760
  parsed.sensor_data = this.sensor_types[parsed.sensor_type].parse(payload, parsed, frame.mac);
749
761
  if(!parsed.sensor_data){
750
762
  return;
@@ -780,6 +792,12 @@ module.exports = class WirelessSensor{
780
792
  let packet = [245, 58, 0, 0, 0].concat(Array.prototype.slice.call(manifest));
781
793
  return this.config_send(sensor_mac, packet);
782
794
  }
795
+ firmware_send_manifest_v13(sensor_mac, manifest){
796
+ console.log('firmware_send_manifest_v13');
797
+ // sensor_mac = "00:00:00:00:00:00:ff:ff";
798
+ let packet = [245, 58, 0, 0, 0].concat(Array.prototype.slice.call(manifest));
799
+ return this.firmware_send_v13(sensor_mac, packet, {}, 7000, 140, true);
800
+ }
783
801
  firmware_send_chunk(sensor_mac, offset, chunk){
784
802
  console.log('firmware_send_chunk');
785
803
  // sensor_mac = "00:00:00:00:00:00:ff:ff";
@@ -1358,6 +1376,12 @@ module.exports = class WirelessSensor{
1358
1376
  console.log(packet);
1359
1377
  return this.config_send(sensor_mac, packet);
1360
1378
  }
1379
+ config_set_sample_rate_108(sensor_mac, value){
1380
+ console.log('config_set_sample_rate_108');
1381
+ var packet = [244, 57, 0, 0, 0, value];
1382
+ console.log(packet);
1383
+ return this.config_send(sensor_mac, packet);
1384
+ }
1361
1385
  config_set_sample_rate_108(sensor_mac, value){
1362
1386
  console.log('config_set_sample_rate_108');
1363
1387
  var packet = [244, 57, 0, 0, 0, value];
@@ -1863,7 +1887,7 @@ module.exports = class WirelessSensor{
1863
1887
  }
1864
1888
  config_set_pressure_sensor_fs_ch2_118(sensor_mac, value){
1865
1889
  console.log('config_set_pressure_sensor_fs_ch2_118');
1866
- var packet = [244, 64, 0, 0, 118, value];
1890
+ var packet = [244, 72, 0, 0, 118, value];
1867
1891
  console.log(packet);
1868
1892
  return this.config_send(sensor_mac, packet);
1869
1893
  }
@@ -1923,6 +1947,12 @@ module.exports = class WirelessSensor{
1923
1947
  }
1924
1948
  config_set_pressure_sensor_type_21(sensor_mac, value){
1925
1949
  console.log('config_set_pressure_sensor_type_21');
1950
+ var packet = [244, 66, 0, 0, 21, value]
1951
+ console.log(packet);
1952
+ return this.config_send(sensor_mac, packet);
1953
+ }
1954
+ config_set_pressure_sensor_range_21(sensor_mac, value){
1955
+ console.log('config_set_pressure_sensor_range_21');
1926
1956
  var packet = [244, 64, 0, 0, 21, value]
1927
1957
  console.log(packet);
1928
1958
  return this.config_send(sensor_mac, packet);
@@ -1975,6 +2005,12 @@ module.exports = class WirelessSensor{
1975
2005
  console.log(packet);
1976
2006
  return this.config_send(sensor_mac, packet);
1977
2007
  }
2008
+ config_set_enable_filtering_110(sensor_mac, value){
2009
+ console.log('config_set_enable_filtering_110');
2010
+ let packet = [244, 79, 0, 0, 101, 13, value];
2011
+ console.log(packet);
2012
+ return this.config_send(sensor_mac, packet);
2013
+ }
1978
2014
  config_set_to_always_on_120(sensor_mac){
1979
2015
  console.log('config_set_to_always_on_120');
1980
2016
  let packet = [244, 10, 0, 0, 0, 1];
@@ -1999,20 +2035,58 @@ module.exports = class WirelessSensor{
1999
2035
  console.log(packet);
2000
2036
  return this.config_send(sensor_mac, packet);
2001
2037
  }
2038
+ config_set_wood_type_121(sensor_mac, value){
2039
+ console.log('config_set_wood_type_121');
2040
+ let packet = [244, 10, 0, 0, 121, value];
2041
+ console.log(packet);
2042
+ return this.config_send(sensor_mac, packet);
2043
+ }
2044
+ config_set_quality_of_service_121(sensor_mac, value){
2045
+ console.log('config_set_quality_of_service_121');
2046
+ var packet = [247, 52, 0, 0, 0, value];
2047
+ console.log(packet);
2048
+ return this.config_send(sensor_mac, packet);
2049
+ }
2002
2050
  config_set_tare_the_scale_217(sensor_mac){
2003
- console.log('config_set_tare_the_scale_217');
2004
- var packet = [244, 32, 0, 0, 26];
2005
- console.log(packet);
2006
- return this.config_send(sensor_mac, packet);
2007
- }
2008
- config_set_weight_calib_217(sensor_mac, value){
2009
- console.log('config_set_weight_calib_217');
2010
- var packet = [244, 33, 0, 0, 26];
2011
- let value_ = int2Bytes((value*100), 4);
2012
- packet.push(...value_);
2013
- console.log(packet);
2014
- return this.config_send(sensor_mac, packet);
2015
- }
2051
+ console.log('config_set_tare_the_scale_217');
2052
+ var packet = [244, 32, 0, 0, 26];
2053
+ console.log(packet);
2054
+ return this.config_send(sensor_mac, packet);
2055
+ }
2056
+ config_set_weight_calib_217(sensor_mac, value){
2057
+ console.log('config_set_weight_calib_217');
2058
+ var packet = [244, 33, 0, 0, 26];
2059
+ let value_ = int2Bytes((value*100), 4);
2060
+ packet.push(...value_);
2061
+ console.log(packet);
2062
+ return this.config_send(sensor_mac, packet);
2063
+ }
2064
+ config_set_pressure_limit_26(sensor_mac, value){
2065
+ console.log('config_set_pressure_limit_26');
2066
+ var packet = [244, 82, 0, 0, 26];
2067
+ let value_ = int2Bytes(value, 2);
2068
+ packet.push(...value_);
2069
+ console.log(packet);
2070
+ return this.config_send(sensor_mac, packet);
2071
+ }
2072
+ config_set_auto_pressure_check_26(sensor_mac, value){
2073
+ console.log('config_set_auto_pressure_check_26');
2074
+ var packet = [244, 80, 0, 0, 26, value];
2075
+ console.log(packet);
2076
+ return this.config_send(sensor_mac, packet);
2077
+ }
2078
+ config_set_fsr_420ma(sensor_mac, value){
2079
+ console.log('config_set_fsr_420ma');
2080
+ var packet = [244, 64, 0, 0, 45, value];
2081
+ console.log(packet);
2082
+ return this.config_send(sensor_mac, packet);
2083
+ }
2084
+ config_set_always_on_420ma(sensor_mac, value){
2085
+ console.log('config_set_always_on_420ma');
2086
+ var packet = [244, 81, 0, 0, 88, value];
2087
+ console.log(packet);
2088
+ return this.config_send(sensor_mac, packet);
2089
+ }
2016
2090
  config_get_delay(sensor_mac){
2017
2091
  return new Promise((fulfill, reject) => {
2018
2092
  this.config_send(sensor_mac, [247, 21, 0, 0, 0]).then((res) => {
@@ -2217,9 +2291,148 @@ module.exports = class WirelessSensor{
2217
2291
  delete this.queue;
2218
2292
  this.queue = new Queue(1);
2219
2293
  }
2294
+ firmware_send_chunk_v13(sensor_mac, offset, chunk){
2295
+ // console.log('firmware_send_chunk');
2296
+ // sensor_mac = "00:00:00:00:00:00:ff:ff";
2297
+ let packet = [245, 59, 0, 0, 0].concat(offset, Array.prototype.slice.call(chunk));
2298
+ // console.log(packet);
2299
+ return this.firmware_send_v13(sensor_mac, packet);
2300
+ }
2301
+ firmware_read_last_chunk_segment(sensor_mac){
2302
+ // console.log('firmware_read_last_chunk_segment');
2303
+ let packet = [245, 61, 0, 0, 0];
2304
+ return this.config_send(sensor_mac, packet);
2305
+ }
2306
+ clear_queue_except_last(){
2307
+ const pending = this.queue.pendingPromises;
2308
+ const temp_queue = this.queue.queue;
2309
+ const last_promise = [temp_queue.pop()];
2310
+
2311
+ console.log('MARK 1');
2312
+ console.log(last_promise);
2313
+
2314
+ // this.queue.queue = last_promise;
2315
+ // this.queue.pendingPromises = [];
2316
+ // this.queue.activeCount = 0;
2317
+
2318
+ console.log('MARK 2');
2319
+ console.log(pending);
2320
+
2321
+ // console.log(temp_queue);
2322
+ // console.log(temp_queue[0]);
2323
+ // while(this.queue.queue.length > 1){
2324
+ // let clear_promise = this.queue.queue.shift();
2325
+ // clear_promise.reject({
2326
+ // res: 'Promise rejected by queue clearing',
2327
+ // error: 'Promise rejected by queue clearing'
2328
+ // });
2329
+ // };
2330
+ // temp_queue.forEach(promise => {
2331
+ // // promise.reject(new Error('Promise rejected by queue clearing'));
2332
+ // promise.reject({
2333
+ // res: 'Promise rejected by queue clearing',
2334
+ // error: 'Promise rejected by queue clearing'
2335
+ // });
2336
+ // });
2337
+ }
2338
+ firmware_send_v13(sensor_mac, data, opts, cmd_timeout = 7000, cmd_delay = 140, manifest = false){
2339
+ var that = this;
2340
+ return new Promise((fulfill, reject) => {
2341
+ if(manifest){
2342
+ that.queue.add(() => {
2343
+ return new Promise((f, r) => {
2344
+ setTimeout(f, 500);
2345
+ });
2346
+ });
2347
+ };
2348
+ that.queue.add(() => {
2349
+ return new Promise((f, r) => {
2350
+ var tout;
2351
+ function fail(error){
2352
+ console.log('In Fail');
2353
+ // that._emitter.removeListener('config_ack-'+sensor_mac, pass);
2354
+ clearTimeout(tout);
2355
+ reject({
2356
+ error: error,
2357
+ sent: [mac2bytes(sensor_mac), data, opts]
2358
+ });
2359
+ f();
2360
+ }
2361
+ function pass(packet){
2362
+ clearTimeout(tout);
2363
+ // that._emitter.removeListener('config_error-'+sensor_mac, fail);
2364
+ packet.sent = data;
2365
+ fulfill(packet);
2366
+ f();
2367
+ };
2368
+ let retry_count = 0;
2369
+ const max_retries = 3;
2370
+ function attempt_transmission(){
2371
+ that.send.transmit_request(mac2bytes(sensor_mac), data, opts).then(function(frame){
2372
+ if(frame.hasError){
2373
+ console.log('FRAME FAILED DUE TO FAIL FLAG');
2374
+ if(retry_count < max_retries) {
2375
+ retry_count++;
2376
+ console.log(`Retrying (attempt ${retry_count}) due to failed status`);
2377
+ clearTimeout(tout);
2378
+ startTimeout();
2379
+ attempt_transmission();
2380
+ }else{
2381
+ fail('Transmit Status indicated error');
2382
+ // reject({
2383
+ // error: 'Transmit Status indicated error',
2384
+ // sent: [mac2bytes(sensor_mac), data, opts]
2385
+ // });
2386
+ };
2387
+ }else{
2388
+ pass(frame);
2389
+ }
2390
+ }).catch((err) => {
2391
+ if(retry_count < max_retries) {
2392
+ retry_count++;
2393
+ console.log(`Retrying (attempt ${retry_count}) due to failed status`);
2394
+ attempt_transmission();
2395
+ }else{
2396
+ console.log('In CATCH');
2397
+ // reject({
2398
+ // error: err,
2399
+ // sent: [mac2bytes(sensor_mac), data, opts]
2400
+ // });
2401
+ fail(err);
2402
+ }
2403
+ }).then();
2404
+ }
2405
+ // that._emitter.once('config_ack-'+sensor_mac, pass);
2406
+ // that._emitter.once('config_error-'+sensor_mac, fail);
2407
+ function startTimeout(){
2408
+ tout = setTimeout(() => {
2409
+ console.log('In Timeout');
2410
+ fail('Transmit Request Timed Out');
2411
+ }, cmd_timeout);
2412
+ }
2413
+ attempt_transmission();
2414
+ startTimeout();
2415
+ });
2416
+ });
2417
+ this.queue.add(() => {
2418
+ return new Promise((f, r) => {
2419
+ // NOTE: This timeout is required to allow the sensor to process and write to memory before a new chunk is transmitted.
2420
+ setTimeout(f, cmd_delay);
2421
+ });
2422
+ });
2423
+ });
2424
+ };
2220
2425
  config_send(sensor_mac, data, opts, cmd_timeout = 1500){
2221
2426
  var that = this;
2222
2427
  return new Promise((fulfill, reject) => {
2428
+ // Note: This code adds a delay before sending any communications. This is not generally required, but has shown increased reliability
2429
+ // in some cases when used directly after changing modem module settings such as entering FON network ID. Leaving it here for future reference or quick add during support.
2430
+ // consider adding a pre-time command parameter to allow this as in the v13 firmware send function.
2431
+ // that.queue.add(() => {
2432
+ // return new Promise((f, r) => {
2433
+ // setTimeout(f, 500);
2434
+ // });
2435
+ // });
2223
2436
  that.queue.add(() => {
2224
2437
  return new Promise((f, r) => {
2225
2438
  var tout;
@@ -2273,12 +2486,23 @@ module.exports = class WirelessSensor{
2273
2486
  });
2274
2487
  this.queue.add(() => {
2275
2488
  return new Promise((f, r) => {
2276
- setTimeout(f, 500);
2489
+ setTimeout(f, 250);
2277
2490
  });
2278
2491
  });
2279
2492
  });
2493
+ };
2494
+ prepare_bridge_query(sensor_mac, commands){
2495
+ commands.forEach((command) => {
2496
+ if(command.hasOwnProperty('meta')){
2497
+ this.queue_bridge_query(sensor_mac, command.command, command.meta);
2498
+ }else{
2499
+ this.queue_bridge_query(sensor_mac, command.command);
2500
+ }
2501
+ });
2280
2502
  }
2281
- queue_bridge_query(sensor_mac, data, meta = null, opts){
2503
+ queue_bridge_query(sensor_mac, data, meta = null, command_timeout = 1500, opts){
2504
+ console.log('Command Timeout:');
2505
+ console.log(command_timeout);
2282
2506
  var that = this;
2283
2507
  if(!globalDevices.hasOwnProperty(sensor_mac)){
2284
2508
  globalDevices[sensor_mac] = {bridge: true, command_queue: []};
@@ -2300,7 +2524,10 @@ module.exports = class WirelessSensor{
2300
2524
 
2301
2525
  if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
2302
2526
  globalDevices[sensor_mac].command_queue.shift();
2303
- }
2527
+ };
2528
+ // if(globalDevices[sensor_mac].command_queue.length == 0 && globalDevices[sensor_mac].hasOwnProperty('bridge')){
2529
+ // delete globalDevices[sensor_mac].bridge;
2530
+ // }
2304
2531
  reject({
2305
2532
  err: response,
2306
2533
  sent: [mac2bytes(sensor_mac), data, opts]
@@ -2317,6 +2544,9 @@ module.exports = class WirelessSensor{
2317
2544
  if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
2318
2545
  globalDevices[sensor_mac].command_queue.shift();
2319
2546
  }
2547
+ // if(globalDevices[sensor_mac].command_queue.length == 0 && globalDevices[sensor_mac].hasOwnProperty('bridge')){
2548
+ // delete globalDevices[sensor_mac].bridge;
2549
+ // }
2320
2550
  that._emitter.removeListener('converter_error-'+sensor_mac, fail);
2321
2551
  fulfill(response);
2322
2552
  f();
@@ -2345,7 +2575,7 @@ module.exports = class WirelessSensor{
2345
2575
  };
2346
2576
 
2347
2577
  f();
2348
- }, 1500);
2578
+ }, command_timeout);
2349
2579
  that.send.transmit_request(mac2bytes(sensor_mac), data, opts).then().catch((err) => {
2350
2580
  that._emitter.removeListener('converter_error-'+sensor_mac, fail);
2351
2581
  that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
@@ -2364,15 +2594,15 @@ module.exports = class WirelessSensor{
2364
2594
  });
2365
2595
  });
2366
2596
  };
2367
- prepare_bridge_query(sensor_mac, commands){
2597
+ prepare_bridge_query(sensor_mac, commands, timeout){
2368
2598
  commands.forEach((command) => {
2369
2599
  if(command.hasOwnProperty('meta')){
2370
- this.queue_bridge_query(sensor_mac, command.command, command.meta);
2600
+ this.queue_bridge_query(sensor_mac, command.command, command.meta, timeout);
2371
2601
  }else{
2372
- this.queue_bridge_query(sensor_mac, command.command);
2373
- }
2602
+ this.queue_bridge_query(sensor_mac, command.command, null, timeout);
2603
+ };
2374
2604
  });
2375
- }
2605
+ };
2376
2606
  build_102_data(payload, deviceAddr, hour, minute, sdata_start, current_packet, firmware){
2377
2607
  if(current_packet != 1){
2378
2608
  console.log('bad packet cleanup');
@@ -2900,6 +3130,57 @@ function sensor_types(parent){
2900
3130
  adc: adc,
2901
3131
  voltage: adc * 0.00322265625
2902
3132
  };
3133
+ },
3134
+ 'parse_fly': (frame) => {
3135
+ let firmware = frame[2];
3136
+ if(firmware > 13){ // firmware 14 and above
3137
+ let frame_data = {};
3138
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
3139
+ switch(frame[16]){
3140
+ case 0:
3141
+ frame_data.fsr = "+-0.256 V";
3142
+ break;
3143
+ case 1:
3144
+ frame_data.fsr = "+-0.512 V";
3145
+ break;
3146
+ case 2:
3147
+ frame_data.fsr = "+-1.024 V";
3148
+ break;
3149
+ case 3:
3150
+ frame_data.fsr = "+-2.048 V";
3151
+ break;
3152
+ case 4:
3153
+ frame_data.fsr = "+-4.096 V";
3154
+ break;
3155
+ case 5:
3156
+ frame_data.fsr = "+-6.144 V";
3157
+ break;
3158
+ }
3159
+ return {
3160
+ 'firmware': frame[2],
3161
+ 'fsr': frame_data.fsr,
3162
+ 'boot_time': frame[17] + " sec",
3163
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
3164
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
3165
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
3166
+ 'always_on': frame_data.always_on,
3167
+ 'hardware_id': frame.slice(25, 28),
3168
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
3169
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
3170
+ 'machine_values': {
3171
+ 'firmware': frame[2],
3172
+ 'fsr': frame[16],
3173
+ 'boot_time': frame[17],
3174
+ 'power_adc': frame.slice(18, 20),
3175
+ 'auto_check_interval': frame.slice(20, 22),
3176
+ 'auto_check_percentage': frame.slice(22, 24),
3177
+ 'always_on': frame[24],
3178
+ 'hardware_id': frame.slice(25, 28),
3179
+ 'report_rate': frame.slice(28, 32),
3180
+ 'tx_life_counter': frame.slice(32, 36)
3181
+ }
3182
+ }
3183
+ }
2903
3184
  }
2904
3185
  },
2905
3186
  '16': {
@@ -2953,11 +3234,204 @@ function sensor_types(parent){
2953
3234
  },
2954
3235
  '21': {
2955
3236
  name: 'Differential Bidirectional Pressure Sensor',
2956
- parse: (d) => {
3237
+ parse: (payload, parsed, mac) => {
3238
+ let pressure, temperature, raw_adc;
3239
+
3240
+ if (parsed.firmware <= 12) {
3241
+ pressure = signInt(payload.slice(8, 10).reduce(msbLsb), 16) / 100;
3242
+ temperature = signInt(payload.slice(10, 12).reduce(msbLsb), 16) / 100;
3243
+ // raw_adc not present in firmware ≤ 12
3244
+ return {
3245
+ pressure,
3246
+ temperature
3247
+ };
3248
+ } else {
3249
+ pressure = signInt(payload.slice(8, 10).reduce(msbLsb), 16) / 1000;
3250
+ temperature = signInt(payload.slice(10, 12).reduce(msbLsb), 16) / 100;
3251
+ raw_adc = signInt(payload.slice(12, 14).reduce(msbLsb), 16);
3252
+ return {
3253
+ pressure,
3254
+ temperature,
3255
+ raw_adc
3256
+ };
3257
+ }
3258
+ },
3259
+ 'parse_fly': (frame) => {
3260
+ let sensor_type = '';
3261
+ switch(frame[13]){
3262
+ case 0:
3263
+ sensor_type = 'AMS5812';
3264
+ break;
3265
+ case 1:
3266
+ sensor_type = 'AMS5915';
3267
+ break;
3268
+ }
3269
+ let sensor_range = '';
3270
+ if(frame[13]){ // if sensor type is 5915
3271
+ switch(frame[12]){
3272
+ case 0:
3273
+ sensor_range = '0005_D';
3274
+ break;
3275
+ case 1:
3276
+ sensor_range = '0010_D';
3277
+ break;
3278
+ case 2:
3279
+ sensor_range = '0002_D_B';
3280
+ break;
3281
+ case 3:
3282
+ sensor_range = '0005_D_B';
3283
+ break;
3284
+ case 4:
3285
+ sensor_range = '0010_D_B';
3286
+ break;
3287
+ case 5:
3288
+ sensor_range = '0020_D';
3289
+ break;
3290
+ case 6:
3291
+ sensor_range = '0035_D';
3292
+ break;
3293
+ case 7:
3294
+ sensor_range = '0050_D';
3295
+ break;
3296
+ case 8:
3297
+ sensor_range = '0100_D';
3298
+ break;
3299
+ case 9:
3300
+ sensor_range = '0020_D_B';
3301
+ break;
3302
+ case 10:
3303
+ sensor_range = '0035_D_B';
3304
+ break;
3305
+ case 11:
3306
+ sensor_range = '0050_D_B';
3307
+ break;
3308
+ case 12:
3309
+ sensor_range = '0100_D_B';
3310
+ break;
3311
+ case 13:
3312
+ sensor_range = '0200_D';
3313
+ break;
3314
+ case 14:
3315
+ sensor_range = '0350_D';
3316
+ break;
3317
+ case 15:
3318
+ sensor_range = '0500_D';
3319
+ break;
3320
+ case 16:
3321
+ sensor_range = '1000_D';
3322
+ break;
3323
+ case 17:
3324
+ sensor_range = '2000_D';
3325
+ break;
3326
+ case 18:
3327
+ sensor_range = '4000_D';
3328
+ break;
3329
+ case 19:
3330
+ sensor_range = '7000_D';
3331
+ break;
3332
+ case 20:
3333
+ sensor_range = '10000_D';
3334
+ break;
3335
+ case 21:
3336
+ sensor_range = '0200_D_B';
3337
+ break;
3338
+ case 22:
3339
+ sensor_range = '0350_D_B';
3340
+ break;
3341
+ case 23:
3342
+ sensor_range = '0500_D_B';
3343
+ break;
3344
+ case 24:
3345
+ sensor_range = '1000_D_B';
3346
+ break;
3347
+ }
3348
+ }
3349
+ else{ // sensor type is 5812
3350
+ switch(frame[12]){
3351
+ case 0:
3352
+ sensor_range = '0000_D';
3353
+ break;
3354
+ case 1:
3355
+ sensor_range = '0001_D';
3356
+ break;
3357
+ case 2:
3358
+ sensor_range = '0000_D_B';
3359
+ break;
3360
+ case 3:
3361
+ sensor_range = '0001_D_B';
3362
+ break;
3363
+ case 4:
3364
+ sensor_range = '0003_D';
3365
+ break;
3366
+ case 5:
3367
+ sensor_range = '0008_D';
3368
+ break;
3369
+ case 6:
3370
+ sensor_range = '0015_D';
3371
+ break;
3372
+ case 7:
3373
+ sensor_range = '0003_D_B';
3374
+ break;
3375
+ case 8:
3376
+ sensor_range = '0008_D_B';
3377
+ break;
3378
+ case 9:
3379
+ sensor_range = '0015_D_B';
3380
+ break;
3381
+ case 10:
3382
+ sensor_range = '0030_D';
3383
+ break;
3384
+ case 11:
3385
+ sensor_range = '0050_D';
3386
+ break;
3387
+ case 12:
3388
+ sensor_range = '0150_D';
3389
+ break;
3390
+ case 13:
3391
+ sensor_range = '0300_D';
3392
+ break;
3393
+ case 14:
3394
+ sensor_range = '0600_D';
3395
+ break;
3396
+ case 15:
3397
+ sensor_range = '1000_D';
3398
+ break;
3399
+ case 16:
3400
+ sensor_range = '0030_D_B';
3401
+ break;
3402
+ case 17:
3403
+ sensor_range = '0050_D_B';
3404
+ break;
3405
+ case 18:
3406
+ sensor_range = '0150_D_B';
3407
+ break;
3408
+ case 19:
3409
+ sensor_range = '0150_B';
3410
+ break;
3411
+ case 20:
3412
+ sensor_range = '0150_A';
3413
+ break;
3414
+ case 21:
3415
+ sensor_range = '0300_A';
3416
+ break;
3417
+ }
3418
+ }
2957
3419
  return {
2958
- pressure: signInt(d.slice(0, 2).reduce(msbLsb), 16) / 100,
2959
- temperature: signInt(d.slice(2, 4).reduce(msbLsb), 16) / 100,
2960
- };
3420
+ 'firmware': frame[2],
3421
+ 'sensor_range': sensor_range,
3422
+ 'sensor_type': sensor_type,
3423
+ 'hardware_id': frame.slice(14, 17),
3424
+ 'report_rate': frame.slice(17, 21).reduce(msbLsb) + ' sec',
3425
+ 'tx_counter': frame.slice(21, 25).reduce(msbLsb),
3426
+ 'machine_values': {
3427
+ 'firmware': frame[2],
3428
+ 'sensor_range': frame[12],
3429
+ 'sensor_type': frame[13],
3430
+ 'hardware_id': frame.slice(14, 17),
3431
+ 'report_rate': frame.slice(17, 21),
3432
+ 'tx_counter': frame.slice(21, 25)
3433
+ }
3434
+ }
2961
3435
  }
2962
3436
  },
2963
3437
  '22': {
@@ -3212,21 +3686,72 @@ function sensor_types(parent){
3212
3686
  adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
3213
3687
  mA: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
3214
3688
  };
3215
- }
3216
- },
3217
- '46': {
3218
- name: 'Motion Detection Sensor',
3219
- parse: (d) => {
3220
- return {
3221
- input_1: d[0]
3222
- };
3223
- }
3224
- },
3225
- '47': {
3226
- name: 'Wireless Tilt Sensor',
3227
- parse: (d) => {
3228
- return {
3229
- Roll: signInt(d.slice(0, 2).reduce(msbLsb), 16) / 100,
3689
+ },
3690
+ 'parse_fly': (frame) => {
3691
+ let firmware = frame[2];
3692
+ if(firmware > 13){ // firmware 14 and above
3693
+ let frame_data = {};
3694
+ frame_data.always_on = frame[23]?"Enabled":"Disabled";
3695
+ switch(frame[16]){
3696
+ case 0:
3697
+ frame_data.fsr = "+-0.256 V";
3698
+ break;
3699
+ case 1:
3700
+ frame_data.fsr = "+-0.512 V";
3701
+ break;
3702
+ case 2:
3703
+ frame_data.fsr = "+-1.024 V";
3704
+ break;
3705
+ case 3:
3706
+ frame_data.fsr = "+-2.048 V";
3707
+ break;
3708
+ case 4:
3709
+ frame_data.fsr = "+-4.096 V";
3710
+ break;
3711
+ case 5:
3712
+ frame_data.fsr = "+-6.144 V";
3713
+ break;
3714
+ }
3715
+ return {
3716
+ 'firmware': frame[2],
3717
+ 'fsr': frame_data.fsr,
3718
+ 'boot_time': frame[17] + " sec",
3719
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
3720
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
3721
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
3722
+ 'always_on': frame_data.always_on,
3723
+ 'hardware_id': frame.slice(25, 28),
3724
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
3725
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
3726
+ 'machine_values': {
3727
+ 'firmware': frame[2],
3728
+ 'fsr': frame[16],
3729
+ 'boot_time': frame[17],
3730
+ 'power_adc': frame.slice(18, 20),
3731
+ 'auto_check_interval': frame.slice(20, 22),
3732
+ 'auto_check_percentage': frame.slice(22, 24),
3733
+ 'always_on': frame[24],
3734
+ 'hardware_id': frame.slice(25, 28),
3735
+ 'report_rate': frame.slice(28, 32),
3736
+ 'tx_life_counter': frame.slice(32, 36)
3737
+ }
3738
+ }
3739
+ }
3740
+ }
3741
+ },
3742
+ '46': {
3743
+ name: 'Motion Detection Sensor',
3744
+ parse: (d) => {
3745
+ return {
3746
+ input_1: d[0]
3747
+ };
3748
+ }
3749
+ },
3750
+ '47': {
3751
+ name: 'Wireless Tilt Sensor',
3752
+ parse: (d) => {
3753
+ return {
3754
+ Roll: signInt(d.slice(0, 2).reduce(msbLsb), 16) / 100,
3230
3755
  Pitch: signInt(d.slice(2, 4).reduce(msbLsb), 16) / 100
3231
3756
  };
3232
3757
  }
@@ -3238,6 +3763,57 @@ function sensor_types(parent){
3238
3763
  adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
3239
3764
  mA: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
3240
3765
  };
3766
+ },
3767
+ 'parse_fly': (frame) => {
3768
+ let firmware = frame[2];
3769
+ if(firmware > 13){ // firmware 14 and above
3770
+ let frame_data = {};
3771
+ frame_data.always_on = frame[23]?"Enabled":"Disabled";
3772
+ switch(frame[16]){
3773
+ case 0:
3774
+ frame_data.fsr = "+-0.256 V";
3775
+ break;
3776
+ case 1:
3777
+ frame_data.fsr = "+-0.512 V";
3778
+ break;
3779
+ case 2:
3780
+ frame_data.fsr = "+-1.024 V";
3781
+ break;
3782
+ case 3:
3783
+ frame_data.fsr = "+-2.048 V";
3784
+ break;
3785
+ case 4:
3786
+ frame_data.fsr = "+-4.096 V";
3787
+ break;
3788
+ case 5:
3789
+ frame_data.fsr = "+-6.144 V";
3790
+ break;
3791
+ }
3792
+ return {
3793
+ 'firmware': frame[2],
3794
+ 'fsr': frame_data.fsr,
3795
+ 'boot_time': frame[17] + " sec",
3796
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
3797
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
3798
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
3799
+ 'always_on': frame_data.always_on,
3800
+ 'hardware_id': frame.slice(25, 28),
3801
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
3802
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
3803
+ 'machine_values': {
3804
+ 'firmware': frame[2],
3805
+ 'fsr': frame[16],
3806
+ 'boot_time': frame[17],
3807
+ 'power_adc': frame.slice(18, 20),
3808
+ 'auto_check_interval': frame.slice(20, 22),
3809
+ 'auto_check_percentage': frame.slice(22, 24),
3810
+ 'always_on': frame[24],
3811
+ 'hardware_id': frame.slice(25, 28),
3812
+ 'report_rate': frame.slice(28, 32),
3813
+ 'tx_life_counter': frame.slice(32, 36)
3814
+ }
3815
+ }
3816
+ }
3241
3817
  }
3242
3818
  },
3243
3819
  '49': {
@@ -3312,11 +3888,12 @@ function sensor_types(parent){
3312
3888
  return {
3313
3889
  adc1: adc1,
3314
3890
  adc2: adc2,
3315
- mA1: parseFloat((adc1 * 0.0006863).toFixed(2)),
3316
- mA2: parseFloat((adc2 * 0.0006863).toFixed(2))
3891
+ mA1: signInt(d.slice(4, 6).reduce(msbLsb))/100,
3892
+ mA2: signInt(d.slice(6, 8).reduce(msbLsb))/100
3317
3893
  };
3318
3894
  },
3319
3895
  'parse_fly': (frame) => {
3896
+ let firmware = frame[2];
3320
3897
  let frame_data = {};
3321
3898
  switch(frame[16]){
3322
3899
  case 0:
@@ -3338,7 +3915,34 @@ function sensor_types(parent){
3338
3915
  frame_data.fsr = "+-6.144 V";
3339
3916
  break;
3340
3917
  }
3341
- if(frame[2]>12){
3918
+ if(firmware > 13){ // firmware 14 and above
3919
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
3920
+ return {
3921
+ 'firmware': frame[2],
3922
+ 'fsr': frame_data.fsr,
3923
+ 'boot_time': frame[17] + " sec",
3924
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
3925
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
3926
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
3927
+ 'always_on': frame_data.always_on,
3928
+ 'hardware_id': frame.slice(25, 28),
3929
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
3930
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
3931
+ 'machine_values': {
3932
+ 'firmware': frame[2],
3933
+ 'fsr': frame[16],
3934
+ 'boot_time': frame[17],
3935
+ 'power_adc': frame.slice(18, 20),
3936
+ 'auto_check_interval': frame.slice(20, 22),
3937
+ 'auto_check_percentage': frame.slice(22, 24),
3938
+ 'always_on': frame[24],
3939
+ 'hardware_id': frame.slice(25, 28),
3940
+ 'report_rate': frame.slice(28, 32),
3941
+ 'tx_life_counter': frame.slice(32, 36)
3942
+ }
3943
+ }
3944
+ }
3945
+ else if(firmware > 12){
3342
3946
  return {
3343
3947
  'firmware': frame[2],
3344
3948
  'report_rate': frame.slice(12, 16).reduce(msbLsb),
@@ -3413,6 +4017,57 @@ function sensor_types(parent){
3413
4017
  VDC1: parseFloat((adc1 * 0.00034122).toFixed(2)),
3414
4018
  VDC2: parseFloat((adc2 * 0.00034122).toFixed(2))
3415
4019
  };
4020
+ },
4021
+ 'parse_fly': (frame) => {
4022
+ let firmware = frame[2];
4023
+ if(firmware > 13){ // firmware 14 and above
4024
+ let frame_data = {};
4025
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
4026
+ switch(frame[16]){
4027
+ case 0:
4028
+ frame_data.fsr = "+-0.256 V";
4029
+ break;
4030
+ case 1:
4031
+ frame_data.fsr = "+-0.512 V";
4032
+ break;
4033
+ case 2:
4034
+ frame_data.fsr = "+-1.024 V";
4035
+ break;
4036
+ case 3:
4037
+ frame_data.fsr = "+-2.048 V";
4038
+ break;
4039
+ case 4:
4040
+ frame_data.fsr = "+-4.096 V";
4041
+ break;
4042
+ case 5:
4043
+ frame_data.fsr = "+-6.144 V";
4044
+ break;
4045
+ }
4046
+ return {
4047
+ 'firmware': frame[2],
4048
+ 'fsr': frame_data.fsr,
4049
+ 'boot_time': frame[17] + " sec",
4050
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
4051
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
4052
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
4053
+ 'always_on': frame_data.always_on,
4054
+ 'hardware_id': frame.slice(25, 28),
4055
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
4056
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
4057
+ 'machine_values': {
4058
+ 'firmware': frame[2],
4059
+ 'fsr': frame[16],
4060
+ 'boot_time': frame[17],
4061
+ 'power_adc': frame.slice(18, 20),
4062
+ 'auto_check_interval': frame.slice(20, 22),
4063
+ 'auto_check_percentage': frame.slice(22, 24),
4064
+ 'always_on': frame[24],
4065
+ 'hardware_id': frame.slice(25, 28),
4066
+ 'report_rate': frame.slice(28, 32),
4067
+ 'tx_life_counter': frame.slice(32, 36)
4068
+ }
4069
+ }
4070
+ }
3416
4071
  }
3417
4072
  },
3418
4073
  '58': {
@@ -3646,6 +4301,57 @@ function sensor_types(parent){
3646
4301
  mA: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100,
3647
4302
  Velocity: signInt(d.slice(4, 8).reduce(msbLsb), 32) / 100
3648
4303
  };
4304
+ },
4305
+ 'parse_fly': (frame) => {
4306
+ let firmware = frame[2];
4307
+ if(firmware > 13){ // firmware 14 and above
4308
+ let frame_data = {};
4309
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
4310
+ switch(frame[16]){
4311
+ case 0:
4312
+ frame_data.fsr = "+-0.256 V";
4313
+ break;
4314
+ case 1:
4315
+ frame_data.fsr = "+-0.512 V";
4316
+ break;
4317
+ case 2:
4318
+ frame_data.fsr = "+-1.024 V";
4319
+ break;
4320
+ case 3:
4321
+ frame_data.fsr = "+-2.048 V";
4322
+ break;
4323
+ case 4:
4324
+ frame_data.fsr = "+-4.096 V";
4325
+ break;
4326
+ case 5:
4327
+ frame_data.fsr = "+-6.144 V";
4328
+ break;
4329
+ }
4330
+ return {
4331
+ 'firmware': frame[2],
4332
+ 'fsr': frame_data.fsr,
4333
+ 'boot_time': frame[17] + " sec",
4334
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
4335
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
4336
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
4337
+ 'always_on': frame_data.always_on,
4338
+ 'hardware_id': frame.slice(25, 28),
4339
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
4340
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
4341
+ 'machine_values': {
4342
+ 'firmware': frame[2],
4343
+ 'fsr': frame[16],
4344
+ 'boot_time': frame[17],
4345
+ 'power_adc': frame.slice(18, 20),
4346
+ 'auto_check_interval': frame.slice(20, 22),
4347
+ 'auto_check_percentage': frame.slice(22, 24),
4348
+ 'always_on': frame[24],
4349
+ 'hardware_id': frame.slice(25, 28),
4350
+ 'report_rate': frame.slice(28, 32),
4351
+ 'tx_life_counter': frame.slice(32, 36)
4352
+ }
4353
+ }
4354
+ }
3649
4355
  }
3650
4356
  },
3651
4357
  '76': {
@@ -3656,6 +4362,57 @@ function sensor_types(parent){
3656
4362
  temperature: signInt((msbLsb(d[2], d[3])), 16)/100,
3657
4363
  co_ppm: msbLsb(d[4], d[5])
3658
4364
  };
4365
+ },
4366
+ 'parse_fly': (frame) => {
4367
+ let firmware = frame[2];
4368
+ if(firmware > 13){ // firmware 14 and above
4369
+ let frame_data = {};
4370
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
4371
+ switch(frame[16]){
4372
+ case 0:
4373
+ frame_data.fsr = "+-0.256 V";
4374
+ break;
4375
+ case 1:
4376
+ frame_data.fsr = "+-0.512 V";
4377
+ break;
4378
+ case 2:
4379
+ frame_data.fsr = "+-1.024 V";
4380
+ break;
4381
+ case 3:
4382
+ frame_data.fsr = "+-2.048 V";
4383
+ break;
4384
+ case 4:
4385
+ frame_data.fsr = "+-4.096 V";
4386
+ break;
4387
+ case 5:
4388
+ frame_data.fsr = "+-6.144 V";
4389
+ break;
4390
+ }
4391
+ return {
4392
+ 'firmware': frame[2],
4393
+ 'fsr': frame_data.fsr,
4394
+ 'boot_time': frame[17] + " sec",
4395
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
4396
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
4397
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
4398
+ 'always_on': frame_data.always_on,
4399
+ 'hardware_id': frame.slice(25, 28),
4400
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
4401
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
4402
+ 'machine_values': {
4403
+ 'firmware': frame[2],
4404
+ 'fsr': frame[16],
4405
+ 'boot_time': frame[17],
4406
+ 'power_adc': frame.slice(18, 20),
4407
+ 'auto_check_interval': frame.slice(20, 22),
4408
+ 'auto_check_percentage': frame.slice(22, 24),
4409
+ 'always_on': frame[24],
4410
+ 'hardware_id': frame.slice(25, 28),
4411
+ 'report_rate': frame.slice(28, 32),
4412
+ 'tx_life_counter': frame.slice(32, 36)
4413
+ }
4414
+ }
4415
+ }
3659
4416
  }
3660
4417
  },
3661
4418
  '77': {
@@ -3748,11 +4505,66 @@ function sensor_types(parent){
3748
4505
  if(payload[8] === 1){
3749
4506
  var deviceAddr = mac;
3750
4507
  var firmware = payload[1];
3751
- var hour = payload[11];
3752
- var minute = payload[12];
3753
- var expected_packets = payload[15];
3754
- var current_packet = payload[16];
3755
- var sdata_start = 17;
4508
+
4509
+ if(firmware > 25){
4510
+ var mode = payload[8];
4511
+ var odr = msbLsb(payload[9], payload[10]);
4512
+ var en_axis = payload[11] & 7;
4513
+ var fsr = payload[11] >> 5;
4514
+ var hour = payload[12];
4515
+ var minute = payload[13];
4516
+ var device_temp = msbLsb(payload[14], payload[15])/100;
4517
+ var expected_packets = payload[16];
4518
+ var current_packet = payload[17];
4519
+ var sdata_start = 18;
4520
+
4521
+ } else{
4522
+ var mode = payload[8];
4523
+ var odr = payload[9];
4524
+ var en_axis = payload[10] & 7;
4525
+ var fsr = payload[10] >> 5;
4526
+ var hour = payload[11];
4527
+ var minute = payload[12];
4528
+ var device_temp = msbLsb(payload[13], payload[14])/100;
4529
+ var expected_packets = payload[15];
4530
+ var current_packet = payload[16];
4531
+ var sdata_start = 17;
4532
+
4533
+ switch(odr){
4534
+ case 6:
4535
+ odr = 50;
4536
+ break;
4537
+ case 7:
4538
+ odr = 100;
4539
+ break;
4540
+ case 8:
4541
+ odr = 200;
4542
+ break;
4543
+ case 9:
4544
+ odr = 400;
4545
+ break;
4546
+ case 10:
4547
+ odr = 800;
4548
+ break;
4549
+ case 11:
4550
+ odr = 1600;
4551
+ break;
4552
+ case 12:
4553
+ odr = 3200;
4554
+ break;
4555
+ case 13:
4556
+ odr = 6400;
4557
+ break;
4558
+ case 14:
4559
+ odr = 12800;
4560
+ break;
4561
+ case 15:
4562
+ odr = 25600;
4563
+ break;
4564
+ default:
4565
+ odr = 0;
4566
+ }
4567
+ }
3756
4568
 
3757
4569
  if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
3758
4570
  if(expected_packets != 1){
@@ -3781,48 +4593,6 @@ function sensor_types(parent){
3781
4593
  return;
3782
4594
  } else{
3783
4595
 
3784
- var mode = payload[8];
3785
- var odr = payload[9];
3786
- var en_axis = payload[10] & 7;
3787
- var fsr = payload[10] >> 5;
3788
- var device_temp = msbLsb(payload[13], payload[14])/100;
3789
-
3790
-
3791
- switch(odr){
3792
- case 6:
3793
- odr = 50;
3794
- break;
3795
- case 7:
3796
- odr = 100;
3797
- break;
3798
- case 8:
3799
- odr = 200;
3800
- break;
3801
- case 9:
3802
- odr = 400;
3803
- break;
3804
- case 10:
3805
- odr = 800;
3806
- break;
3807
- case 11:
3808
- odr = 1600;
3809
- break;
3810
- case 12:
3811
- odr = 3200;
3812
- break;
3813
- case 13:
3814
- odr = 6400;
3815
- break;
3816
- case 14:
3817
- odr = 12800;
3818
- break;
3819
- case 15:
3820
- odr = 25600;
3821
- break;
3822
- default:
3823
- odr = 0;
3824
- }
3825
-
3826
4596
  globalDevices[deviceAddr] = {
3827
4597
  // stream_size: expected_packets,
3828
4598
  data: {},
@@ -3843,61 +4613,20 @@ function sensor_types(parent){
3843
4613
  }
3844
4614
  }
3845
4615
  else{
3846
- var mode = payload[8];
3847
- var odr = payload[9];
3848
- var en_axis = payload[10] & 7;
3849
- var fsr = payload[10] >> 5;
3850
- var device_temp = msbLsb(payload[13], payload[14])/100;
3851
4616
 
3852
-
3853
- switch(odr){
3854
- case 6:
3855
- odr = 50;
3856
- break;
3857
- case 7:
3858
- odr = 100;
3859
- break;
3860
- case 8:
3861
- odr = 200;
3862
- break;
3863
- case 9:
3864
- odr = 400;
3865
- break;
3866
- case 10:
3867
- odr = 800;
3868
- break;
3869
- case 11:
3870
- odr = 1600;
3871
- break;
3872
- case 12:
3873
- odr = 3200;
3874
- break;
3875
- case 13:
3876
- odr = 6400;
3877
- break;
3878
- case 14:
3879
- odr = 12800;
3880
- break;
3881
- case 15:
3882
- odr = 25600;
3883
- break;
3884
- default:
3885
- odr = 0;
3886
- }
3887
-
3888
- globalDevices[deviceAddr] = {
3889
- // stream_size: expected_packets,
3890
- data: {},
3891
- odr: odr,
3892
- mo: mode,
3893
- en_axis: en_axis,
3894
- fsr: fsr,
3895
- hour: hour,
3896
- minute: minute,
3897
- device_temp: device_temp,
3898
- }
3899
- globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
3900
- }
4617
+ globalDevices[deviceAddr] = {
4618
+ // stream_size: expected_packets,
4619
+ data: {},
4620
+ odr: odr,
4621
+ mo: mode,
4622
+ en_axis: en_axis,
4623
+ fsr: fsr,
4624
+ hour: hour,
4625
+ minute: minute,
4626
+ device_temp: device_temp,
4627
+ }
4628
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
4629
+ }
3901
4630
 
3902
4631
  if(Object.keys(globalDevices[deviceAddr].data).length == expected_packets){
3903
4632
  var raw_data = new Array();
@@ -4017,48 +4746,6 @@ function sensor_types(parent){
4017
4746
  }
4018
4747
  }else{
4019
4748
 
4020
- var mode = payload[8];
4021
- var odr = payload[9];
4022
- var en_axis = payload[10] & 7;
4023
- var fsr = payload[10] >> 5;
4024
- var device_temp = msbLsb(payload[13], payload[14])/100;
4025
-
4026
-
4027
- switch(odr){
4028
- case 6:
4029
- odr = 50;
4030
- break;
4031
- case 7:
4032
- odr = 100;
4033
- break;
4034
- case 8:
4035
- odr = 200;
4036
- break;
4037
- case 9:
4038
- odr = 400;
4039
- break;
4040
- case 10:
4041
- odr = 800;
4042
- break;
4043
- case 11:
4044
- odr = 1600;
4045
- break;
4046
- case 12:
4047
- odr = 3200;
4048
- break;
4049
- case 13:
4050
- odr = 6400;
4051
- break;
4052
- case 14:
4053
- odr = 12800;
4054
- break;
4055
- case 15:
4056
- odr = 25600;
4057
- break;
4058
- default:
4059
- odr = 0;
4060
- }
4061
-
4062
4749
  globalDevices[deviceAddr] = {
4063
4750
  // stream_size: expected_packets,
4064
4751
  data: {},
@@ -4369,11 +5056,66 @@ function sensor_types(parent){
4369
5056
  if(payload[8] === 1){
4370
5057
  var deviceAddr = mac;
4371
5058
  var firmware = payload[1];
4372
- var hour = payload[11];
4373
- var minute = payload[12];
4374
- var expected_packets = payload[15];
4375
- var current_packet = payload[16];
4376
- var sdata_start = 17;
5059
+
5060
+ if(firmware > 25){
5061
+ var mode = payload[8];
5062
+ var odr = msbLsb(payload[9], payload[10]);
5063
+ var en_axis = payload[11] & 7;
5064
+ var fsr = payload[11] >> 5;
5065
+ var hour = payload[12];
5066
+ var minute = payload[13];
5067
+ var device_temp = msbLsb(payload[14], payload[15])/100;
5068
+ var expected_packets = payload[16];
5069
+ var current_packet = payload[17];
5070
+ var sdata_start = 18;
5071
+
5072
+ }else{
5073
+ var mode = payload[8];
5074
+ var odr = payload[9];
5075
+ var en_axis = payload[10] & 7;
5076
+ var fsr = payload[10] >> 5;
5077
+ var hour = payload[11];
5078
+ var minute = payload[12];
5079
+ var device_temp = msbLsb(payload[13], payload[14])/100;
5080
+ var expected_packets = payload[15];
5081
+ var current_packet = payload[16];
5082
+ var sdata_start = 17;
5083
+
5084
+ switch(odr){
5085
+ case 6:
5086
+ odr = 50;
5087
+ break;
5088
+ case 7:
5089
+ odr = 100;
5090
+ break;
5091
+ case 8:
5092
+ odr = 200;
5093
+ break;
5094
+ case 9:
5095
+ odr = 400;
5096
+ break;
5097
+ case 10:
5098
+ odr = 800;
5099
+ break;
5100
+ case 11:
5101
+ odr = 1600;
5102
+ break;
5103
+ case 12:
5104
+ odr = 3200;
5105
+ break;
5106
+ case 13:
5107
+ odr = 6400;
5108
+ break;
5109
+ case 14:
5110
+ odr = 12800;
5111
+ break;
5112
+ case 15:
5113
+ odr = 25600;
5114
+ break;
5115
+ default:
5116
+ odr = 0;
5117
+ }
5118
+ }
4377
5119
 
4378
5120
  if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
4379
5121
  if(expected_packets != 1){
@@ -4401,46 +5143,6 @@ function sensor_types(parent){
4401
5143
  if(current_packet != 1){
4402
5144
  return;
4403
5145
  } else{
4404
- var mode = payload[8];
4405
- var odr = payload[9];
4406
- var en_axis = payload[10] & 7;
4407
- var fsr = payload[10] >> 5;
4408
- var device_temp = msbLsb(payload[13], payload[14])/100;
4409
-
4410
- switch(odr){
4411
- case 6:
4412
- odr = 50;
4413
- break;
4414
- case 7:
4415
- odr = 100;
4416
- break;
4417
- case 8:
4418
- odr = 200;
4419
- break;
4420
- case 9:
4421
- odr = 400;
4422
- break;
4423
- case 10:
4424
- odr = 800;
4425
- break;
4426
- case 11:
4427
- odr = 1600;
4428
- break;
4429
- case 12:
4430
- odr = 3200;
4431
- break;
4432
- case 13:
4433
- odr = 6400;
4434
- break;
4435
- case 14:
4436
- odr = 12800;
4437
- break;
4438
- case 15:
4439
- odr = 25600;
4440
- break;
4441
- default:
4442
- odr = 0;
4443
- }
4444
5146
 
4445
5147
  globalDevices[deviceAddr] = {
4446
5148
  // stream_size: expected_packets,
@@ -4462,47 +5164,6 @@ function sensor_types(parent){
4462
5164
  }
4463
5165
  }
4464
5166
  else{
4465
- var mode = payload[8];
4466
- var odr = payload[9];
4467
- var en_axis = payload[10] & 7;
4468
- var fsr = payload[10] >> 5;
4469
- var device_temp = msbLsb(payload[13], payload[14])/100;
4470
-
4471
-
4472
- switch(odr){
4473
- case 6:
4474
- odr = 50;
4475
- break;
4476
- case 7:
4477
- odr = 100;
4478
- break;
4479
- case 8:
4480
- odr = 200;
4481
- break;
4482
- case 9:
4483
- odr = 400;
4484
- break;
4485
- case 10:
4486
- odr = 800;
4487
- break;
4488
- case 11:
4489
- odr = 1600;
4490
- break;
4491
- case 12:
4492
- odr = 3200;
4493
- break;
4494
- case 13:
4495
- odr = 6400;
4496
- break;
4497
- case 14:
4498
- odr = 12800;
4499
- break;
4500
- case 15:
4501
- odr = 25600;
4502
- break;
4503
- default:
4504
- odr = 0;
4505
- }
4506
5167
 
4507
5168
  globalDevices[deviceAddr] = {
4508
5169
  // stream_size: expected_packets,
@@ -4626,7 +5287,6 @@ function sensor_types(parent){
4626
5287
  var fft_concat_obj = {
4627
5288
  probe: probe,
4628
5289
  time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
4629
- probe: probe,
4630
5290
  mac_address: deviceAddr,
4631
5291
  en_axis: globalDevices[deviceAddr].en_axis,
4632
5292
  fsr: fsr_text,
@@ -4647,47 +5307,6 @@ function sensor_types(parent){
4647
5307
  return;
4648
5308
  }
4649
5309
  }else{
4650
- var mode = payload[8];
4651
- var odr = payload[9];
4652
- var en_axis = payload[10] & 7;
4653
- var fsr = payload[10] >> 5;
4654
- var device_temp = msbLsb(payload[13], payload[14])/100;
4655
-
4656
-
4657
- switch(odr){
4658
- case 6:
4659
- odr = 50;
4660
- break;
4661
- case 7:
4662
- odr = 100;
4663
- break;
4664
- case 8:
4665
- odr = 200;
4666
- break;
4667
- case 9:
4668
- odr = 400;
4669
- break;
4670
- case 10:
4671
- odr = 800;
4672
- break;
4673
- case 11:
4674
- odr = 1600;
4675
- break;
4676
- case 12:
4677
- odr = 3200;
4678
- break;
4679
- case 13:
4680
- odr = 6400;
4681
- break;
4682
- case 14:
4683
- odr = 12800;
4684
- break;
4685
- case 15:
4686
- odr = 25600;
4687
- break;
4688
- default:
4689
- odr = 0;
4690
- }
4691
5310
 
4692
5311
  globalDevices[deviceAddr] = {
4693
5312
  // stream_size: expected_packets,
@@ -5175,11 +5794,66 @@ function sensor_types(parent){
5175
5794
  if(payload[8] === 1){
5176
5795
  var deviceAddr = mac;
5177
5796
  var firmware = payload[1];
5178
- var hour = payload[11];
5179
- var minute = payload[12];
5180
- var expected_packets = payload[15];
5181
- var current_packet = payload[16];
5182
- var sdata_start = 17;
5797
+
5798
+ if(firmware > 25){
5799
+ var mode = payload[8];
5800
+ var odr = msbLsb(payload[9], payload[10]);
5801
+ var en_axis = payload[11] & 7;
5802
+ var fsr = payload[11] >> 5;
5803
+ var hour = payload[12];
5804
+ var minute = payload[13];
5805
+ var device_temp = msbLsb(payload[14], payload[15])/100;
5806
+ var expected_packets = payload[16];
5807
+ var current_packet = payload[17];
5808
+ var sdata_start = 18;
5809
+
5810
+ } else{
5811
+ var mode = payload[8];
5812
+ var odr = payload[9];
5813
+ var en_axis = payload[10] & 7;
5814
+ var fsr = payload[10] >> 5;
5815
+ var hour = payload[11];
5816
+ var minute = payload[12];
5817
+ var device_temp = msbLsb(payload[13], payload[14])/100;
5818
+ var expected_packets = payload[15];
5819
+ var current_packet = payload[16];
5820
+ var sdata_start = 17;
5821
+
5822
+ switch(odr){
5823
+ case 6:
5824
+ odr = 50;
5825
+ break;
5826
+ case 7:
5827
+ odr = 100;
5828
+ break;
5829
+ case 8:
5830
+ odr = 200;
5831
+ break;
5832
+ case 9:
5833
+ odr = 400;
5834
+ break;
5835
+ case 10:
5836
+ odr = 800;
5837
+ break;
5838
+ case 11:
5839
+ odr = 1600;
5840
+ break;
5841
+ case 12:
5842
+ odr = 3200;
5843
+ break;
5844
+ case 13:
5845
+ odr = 6400;
5846
+ break;
5847
+ case 14:
5848
+ odr = 12800;
5849
+ break;
5850
+ case 15:
5851
+ odr = 25600;
5852
+ break;
5853
+ default:
5854
+ odr = 0;
5855
+ }
5856
+ }
5183
5857
 
5184
5858
  if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
5185
5859
  if(expected_packets != 1){
@@ -5208,48 +5882,6 @@ function sensor_types(parent){
5208
5882
  return;
5209
5883
  } else{
5210
5884
 
5211
- var mode = payload[8];
5212
- var odr = payload[9];
5213
- var en_axis = payload[10] & 7;
5214
- var fsr = payload[10] >> 5;
5215
- var device_temp = msbLsb(payload[13], payload[14])/100;
5216
-
5217
-
5218
- switch(odr){
5219
- case 6:
5220
- odr = 50;
5221
- break;
5222
- case 7:
5223
- odr = 100;
5224
- break;
5225
- case 8:
5226
- odr = 200;
5227
- break;
5228
- case 9:
5229
- odr = 400;
5230
- break;
5231
- case 10:
5232
- odr = 800;
5233
- break;
5234
- case 11:
5235
- odr = 1600;
5236
- break;
5237
- case 12:
5238
- odr = 3200;
5239
- break;
5240
- case 13:
5241
- odr = 6400;
5242
- break;
5243
- case 14:
5244
- odr = 12800;
5245
- break;
5246
- case 15:
5247
- odr = 25600;
5248
- break;
5249
- default:
5250
- odr = 0;
5251
- }
5252
-
5253
5885
  globalDevices[deviceAddr] = {
5254
5886
  // stream_size: expected_packets,
5255
5887
  data: {},
@@ -5270,47 +5902,6 @@ function sensor_types(parent){
5270
5902
  }
5271
5903
  }
5272
5904
  else{
5273
- var mode = payload[8];
5274
- var odr = payload[9];
5275
- var en_axis = payload[10] & 7;
5276
- var fsr = payload[10] >> 5;
5277
- var device_temp = msbLsb(payload[13], payload[14])/100;
5278
-
5279
-
5280
- switch(odr){
5281
- case 6:
5282
- odr = 50;
5283
- break;
5284
- case 7:
5285
- odr = 100;
5286
- break;
5287
- case 8:
5288
- odr = 200;
5289
- break;
5290
- case 9:
5291
- odr = 400;
5292
- break;
5293
- case 10:
5294
- odr = 800;
5295
- break;
5296
- case 11:
5297
- odr = 1600;
5298
- break;
5299
- case 12:
5300
- odr = 3200;
5301
- break;
5302
- case 13:
5303
- odr = 6400;
5304
- break;
5305
- case 14:
5306
- odr = 12800;
5307
- break;
5308
- case 15:
5309
- odr = 25600;
5310
- break;
5311
- default:
5312
- odr = 0;
5313
- }
5314
5905
 
5315
5906
  globalDevices[deviceAddr] = {
5316
5907
  // stream_size: expected_packets,
@@ -5447,48 +6038,6 @@ function sensor_types(parent){
5447
6038
  }
5448
6039
  }else{
5449
6040
 
5450
- var mode = payload[8];
5451
- var odr = payload[9];
5452
- var en_axis = payload[10] & 7;
5453
- var fsr = payload[10] >> 5;
5454
- var device_temp = msbLsb(payload[13], payload[14])/100;
5455
-
5456
-
5457
- switch(odr){
5458
- case 6:
5459
- odr = 50;
5460
- break;
5461
- case 7:
5462
- odr = 100;
5463
- break;
5464
- case 8:
5465
- odr = 200;
5466
- break;
5467
- case 9:
5468
- odr = 400;
5469
- break;
5470
- case 10:
5471
- odr = 800;
5472
- break;
5473
- case 11:
5474
- odr = 1600;
5475
- break;
5476
- case 12:
5477
- odr = 3200;
5478
- break;
5479
- case 13:
5480
- odr = 6400;
5481
- break;
5482
- case 14:
5483
- odr = 12800;
5484
- break;
5485
- case 15:
5486
- odr = 25600;
5487
- break;
5488
- default:
5489
- odr = 0;
5490
- }
5491
-
5492
6041
  globalDevices[deviceAddr] = {
5493
6042
  // stream_size: expected_packets,
5494
6043
  data: {},
@@ -5789,11 +6338,66 @@ function sensor_types(parent){
5789
6338
  if(payload[8] === 1){
5790
6339
  var deviceAddr = mac;
5791
6340
  var firmware = payload[1];
5792
- var hour = payload[11];
5793
- var minute = payload[12];
5794
- var expected_packets = payload[15];
5795
- var current_packet = payload[16];
5796
- var sdata_start = 17;
6341
+
6342
+ if(firmware > 25){
6343
+ var mode = payload[8];
6344
+ var odr = msbLsb(payload[9], payload[10]);
6345
+ var en_axis = payload[11] & 7;
6346
+ var fsr = payload[11] >> 5;
6347
+ var hour = payload[12];
6348
+ var minute = payload[13];
6349
+ var device_temp = msbLsb(payload[14], payload[15])/100;
6350
+ var expected_packets = payload[16];
6351
+ var current_packet = payload[17];
6352
+ var sdata_start = 18;
6353
+
6354
+ } else{
6355
+ var mode = payload[8];
6356
+ var odr = payload[9];
6357
+ var en_axis = payload[10] & 7;
6358
+ var fsr = payload[10] >> 5;
6359
+ var hour = payload[11];
6360
+ var minute = payload[12];
6361
+ var device_temp = msbLsb(payload[13], payload[14])/100;
6362
+ var expected_packets = payload[15];
6363
+ var current_packet = payload[16];
6364
+ var sdata_start = 17;
6365
+
6366
+ switch(odr){
6367
+ case 6:
6368
+ odr = 50;
6369
+ break;
6370
+ case 7:
6371
+ odr = 100;
6372
+ break;
6373
+ case 8:
6374
+ odr = 200;
6375
+ break;
6376
+ case 9:
6377
+ odr = 400;
6378
+ break;
6379
+ case 10:
6380
+ odr = 800;
6381
+ break;
6382
+ case 11:
6383
+ odr = 1600;
6384
+ break;
6385
+ case 12:
6386
+ odr = 3200;
6387
+ break;
6388
+ case 13:
6389
+ odr = 6400;
6390
+ break;
6391
+ case 14:
6392
+ odr = 12800;
6393
+ break;
6394
+ case 15:
6395
+ odr = 25600;
6396
+ break;
6397
+ default:
6398
+ odr = 0;
6399
+ }
6400
+ }
5797
6401
 
5798
6402
  if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
5799
6403
  if(expected_packets != 1){
@@ -5822,109 +6426,26 @@ function sensor_types(parent){
5822
6426
  return;
5823
6427
  } else{
5824
6428
 
5825
- var mode = payload[8];
5826
- var odr = payload[9];
5827
- var en_axis = payload[10] & 7;
5828
- var fsr = payload[10] >> 5;
5829
- var device_temp = msbLsb(payload[13], payload[14])/100;
5830
-
5831
-
5832
- switch(odr){
5833
- case 6:
5834
- odr = 50;
5835
- break;
5836
- case 7:
5837
- odr = 100;
5838
- break;
5839
- case 8:
5840
- odr = 200;
5841
- break;
5842
- case 9:
5843
- odr = 400;
5844
- break;
5845
- case 10:
5846
- odr = 800;
5847
- break;
5848
- case 11:
5849
- odr = 1600;
5850
- break;
5851
- case 12:
5852
- odr = 3200;
5853
- break;
5854
- case 13:
5855
- odr = 6400;
5856
- break;
5857
- case 14:
5858
- odr = 12800;
5859
- break;
5860
- case 15:
5861
- odr = 25600;
5862
- break;
5863
- default:
5864
- odr = 0;
5865
- }
5866
-
5867
- globalDevices[deviceAddr] = {
5868
- // stream_size: expected_packets,
5869
- data: {},
5870
- odr: odr,
5871
- mo: mode,
5872
- en_axis: en_axis,
5873
- fsr: fsr,
5874
- hour: hour,
5875
- minute: minute,
5876
- device_temp: device_temp,
5877
- }
5878
- globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
5879
- return;
5880
- }
5881
- }
5882
- else{
5883
- globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
5884
- }
5885
- }
5886
- else{
5887
- var mode = payload[8];
5888
- var odr = payload[9];
5889
- var en_axis = payload[10] & 7;
5890
- var fsr = payload[10] >> 5;
5891
- var device_temp = msbLsb(payload[13], payload[14])/100;
5892
-
5893
-
5894
- switch(odr){
5895
- case 6:
5896
- odr = 50;
5897
- break;
5898
- case 7:
5899
- odr = 100;
5900
- break;
5901
- case 8:
5902
- odr = 200;
5903
- break;
5904
- case 9:
5905
- odr = 400;
5906
- break;
5907
- case 10:
5908
- odr = 800;
5909
- break;
5910
- case 11:
5911
- odr = 1600;
5912
- break;
5913
- case 12:
5914
- odr = 3200;
5915
- break;
5916
- case 13:
5917
- odr = 6400;
5918
- break;
5919
- case 14:
5920
- odr = 12800;
5921
- break;
5922
- case 15:
5923
- odr = 25600;
5924
- break;
5925
- default:
5926
- odr = 0;
5927
- }
6429
+ globalDevices[deviceAddr] = {
6430
+ // stream_size: expected_packets,
6431
+ data: {},
6432
+ odr: odr,
6433
+ mo: mode,
6434
+ en_axis: en_axis,
6435
+ fsr: fsr,
6436
+ hour: hour,
6437
+ minute: minute,
6438
+ device_temp: device_temp,
6439
+ }
6440
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
6441
+ return;
6442
+ }
6443
+ }
6444
+ else{
6445
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
6446
+ }
6447
+ }
6448
+ else{
5928
6449
 
5929
6450
  globalDevices[deviceAddr] = {
5930
6451
  // stream_size: expected_packets,
@@ -6057,48 +6578,6 @@ function sensor_types(parent){
6057
6578
  }
6058
6579
  }else{
6059
6580
 
6060
- var mode = payload[8];
6061
- var odr = payload[9];
6062
- var en_axis = payload[10] & 7;
6063
- var fsr = payload[10] >> 5;
6064
- var device_temp = msbLsb(payload[13], payload[14])/100;
6065
-
6066
-
6067
- switch(odr){
6068
- case 6:
6069
- odr = 50;
6070
- break;
6071
- case 7:
6072
- odr = 100;
6073
- break;
6074
- case 8:
6075
- odr = 200;
6076
- break;
6077
- case 9:
6078
- odr = 400;
6079
- break;
6080
- case 10:
6081
- odr = 800;
6082
- break;
6083
- case 11:
6084
- odr = 1600;
6085
- break;
6086
- case 12:
6087
- odr = 3200;
6088
- break;
6089
- case 13:
6090
- odr = 6400;
6091
- break;
6092
- case 14:
6093
- odr = 12800;
6094
- break;
6095
- case 15:
6096
- odr = 25600;
6097
- break;
6098
- default:
6099
- odr = 0;
6100
- }
6101
-
6102
6581
  globalDevices[deviceAddr] = {
6103
6582
  // stream_size: expected_packets,
6104
6583
  data: {},
@@ -6413,6 +6892,7 @@ function sensor_types(parent){
6413
6892
  };
6414
6893
  },
6415
6894
  'parse_fly': (frame) => {
6895
+ let firmware = frame[2];
6416
6896
  let frame_data = {};
6417
6897
  switch(frame[16]){
6418
6898
  case 0:
@@ -6434,19 +6914,47 @@ function sensor_types(parent){
6434
6914
  frame_data.fsr = "+-6.144 V";
6435
6915
  break;
6436
6916
  }
6437
- return {
6438
- 'firmware': frame[2],
6439
- 'report_rate': frame.slice(12, 16).reduce(msbLsb),
6440
- 'fsr':frame_data.fsr,
6441
- 'boot_up_time': frame[17],
6442
- // 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
6443
- 'machine_values': {
6917
+ if(firmware > 13){ // firmware 14 and above
6918
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
6919
+ return {
6920
+ 'firmware': frame[2],
6921
+ 'fsr': frame_data.fsr,
6922
+ 'boot_time': frame[17] + " sec",
6923
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
6924
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
6925
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
6926
+ 'always_on': frame_data.always_on,
6927
+ 'hardware_id': frame.slice(25, 28),
6928
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
6929
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
6930
+ 'machine_values': {
6931
+ 'firmware': frame[2],
6932
+ 'fsr': frame[16],
6933
+ 'boot_time': frame[17],
6934
+ 'power_adc': frame.slice(18, 20),
6935
+ 'auto_check_interval': frame.slice(20, 22),
6936
+ 'auto_check_percentage': frame.slice(22, 24),
6937
+ 'always_on': frame[24],
6938
+ 'hardware_id': frame.slice(25, 28),
6939
+ 'report_rate': frame.slice(28, 32),
6940
+ 'tx_life_counter': frame.slice(32, 36)
6941
+ }
6942
+ }
6943
+ }else{
6944
+ return {
6444
6945
  'firmware': frame[2],
6445
- 'report_rate': frame.slice(12, 16),
6446
- 'fsr':frame[16],
6946
+ 'report_rate': frame.slice(12, 16).reduce(msbLsb),
6947
+ 'fsr':frame_data.fsr,
6447
6948
  'boot_up_time': frame[17],
6448
- // 'adc_pin_reading': frame.slice(18, 20),
6449
- 'frame': frame
6949
+ // 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
6950
+ 'machine_values': {
6951
+ 'firmware': frame[2],
6952
+ 'report_rate': frame.slice(12, 16),
6953
+ 'fsr':frame[16],
6954
+ 'boot_up_time': frame[17],
6955
+ // 'adc_pin_reading': frame.slice(18, 20),
6956
+ 'frame': frame
6957
+ }
6450
6958
  }
6451
6959
  }
6452
6960
  }
@@ -6464,6 +6972,7 @@ function sensor_types(parent){
6464
6972
  };
6465
6973
  },
6466
6974
  'parse_fly': (frame) => {
6975
+ let firmware = frame[2];
6467
6976
  let frame_data = {};
6468
6977
  switch(frame[16]){
6469
6978
  case 0:
@@ -6485,19 +6994,47 @@ function sensor_types(parent){
6485
6994
  frame_data.fsr = "+-6.144 V";
6486
6995
  break;
6487
6996
  }
6488
- return {
6489
- 'firmware': frame[2],
6490
- 'report_rate': frame.slice(12, 16).reduce(msbLsb),
6491
- 'fsr':frame_data.fsr,
6492
- 'boot_up_time': frame[17],
6493
- // 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
6494
- 'machine_values': {
6997
+ if(firmware > 13){ // firmware 14 and above
6998
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
6999
+ return {
7000
+ 'firmware': frame[2],
7001
+ 'fsr': frame_data.fsr,
7002
+ 'boot_time': frame[17] + " sec",
7003
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
7004
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
7005
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
7006
+ 'always_on': frame_data.always_on,
7007
+ 'hardware_id': frame.slice(25, 28),
7008
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
7009
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
7010
+ 'machine_values': {
7011
+ 'firmware': frame[2],
7012
+ 'fsr': frame[16],
7013
+ 'boot_time': frame[17],
7014
+ 'power_adc': frame.slice(18, 20),
7015
+ 'auto_check_interval': frame.slice(20, 22),
7016
+ 'auto_check_percentage': frame.slice(22, 24),
7017
+ 'always_on': frame[24],
7018
+ 'hardware_id': frame.slice(25, 28),
7019
+ 'report_rate': frame.slice(28, 32),
7020
+ 'tx_life_counter': frame.slice(32, 36)
7021
+ }
7022
+ }
7023
+ }else{
7024
+ return {
6495
7025
  'firmware': frame[2],
6496
- 'report_rate': frame.slice(12, 16),
6497
- 'fsr':frame[16],
7026
+ 'report_rate': frame.slice(12, 16).reduce(msbLsb),
7027
+ 'fsr':frame_data.fsr,
6498
7028
  'boot_up_time': frame[17],
6499
- // 'adc_pin_reading': frame.slice(18, 20),
6500
- 'frame': frame
7029
+ // 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
7030
+ 'machine_values': {
7031
+ 'firmware': frame[2],
7032
+ 'report_rate': frame.slice(12, 16),
7033
+ 'fsr':frame[16],
7034
+ 'boot_up_time': frame[17],
7035
+ // 'adc_pin_reading': frame.slice(18, 20),
7036
+ 'frame': frame
7037
+ }
6501
7038
  }
6502
7039
  }
6503
7040
  }
@@ -6509,6 +7046,57 @@ function sensor_types(parent){
6509
7046
  raw_adc: d.slice(0, 2).reduce(msbLsb),
6510
7047
  amps: d.slice(2, 6).reduce(msbLsb) / 10,
6511
7048
  };
7049
+ },
7050
+ 'parse_fly': (frame) => {
7051
+ let firmware = frame[2];
7052
+ if(firmware > 13){ // firmware 14 and above
7053
+ let frame_data = {};
7054
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
7055
+ switch(frame[16]){
7056
+ case 0:
7057
+ frame_data.fsr = "+-0.256 V";
7058
+ break;
7059
+ case 1:
7060
+ frame_data.fsr = "+-0.512 V";
7061
+ break;
7062
+ case 2:
7063
+ frame_data.fsr = "+-1.024 V";
7064
+ break;
7065
+ case 3:
7066
+ frame_data.fsr = "+-2.048 V";
7067
+ break;
7068
+ case 4:
7069
+ frame_data.fsr = "+-4.096 V";
7070
+ break;
7071
+ case 5:
7072
+ frame_data.fsr = "+-6.144 V";
7073
+ break;
7074
+ }
7075
+ return {
7076
+ 'firmware': frame[2],
7077
+ 'fsr': frame_data.fsr,
7078
+ 'boot_time': frame[17] + " sec",
7079
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
7080
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
7081
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
7082
+ 'always_on': frame_data.always_on,
7083
+ 'hardware_id': frame.slice(25, 28),
7084
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
7085
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
7086
+ 'machine_values': {
7087
+ 'firmware': frame[2],
7088
+ 'fsr': frame[16],
7089
+ 'boot_time': frame[17],
7090
+ 'power_adc': frame.slice(18, 20),
7091
+ 'auto_check_interval': frame.slice(20, 22),
7092
+ 'auto_check_percentage': frame.slice(22, 24),
7093
+ 'always_on': frame[24],
7094
+ 'hardware_id': frame.slice(25, 28),
7095
+ 'report_rate': frame.slice(28, 32),
7096
+ 'tx_life_counter': frame.slice(32, 36)
7097
+ }
7098
+ }
7099
+ }
6512
7100
  }
6513
7101
  },
6514
7102
  '91': {
@@ -6534,6 +7122,57 @@ function sensor_types(parent){
6534
7122
  adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
6535
7123
  vdc: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
6536
7124
  };
7125
+ },
7126
+ 'parse_fly': (frame) => {
7127
+ let firmware = frame[2];
7128
+ if(firmware > 13){ // firmware 14 and above
7129
+ let frame_data = {};
7130
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
7131
+ switch(frame[16]){
7132
+ case 0:
7133
+ frame_data.fsr = "+-0.256 V";
7134
+ break;
7135
+ case 1:
7136
+ frame_data.fsr = "+-0.512 V";
7137
+ break;
7138
+ case 2:
7139
+ frame_data.fsr = "+-1.024 V";
7140
+ break;
7141
+ case 3:
7142
+ frame_data.fsr = "+-2.048 V";
7143
+ break;
7144
+ case 4:
7145
+ frame_data.fsr = "+-4.096 V";
7146
+ break;
7147
+ case 5:
7148
+ frame_data.fsr = "+-6.144 V";
7149
+ break;
7150
+ }
7151
+ return {
7152
+ 'firmware': frame[2],
7153
+ 'fsr': frame_data.fsr,
7154
+ 'boot_time': frame[17] + " sec",
7155
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
7156
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
7157
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
7158
+ 'always_on': frame_data.always_on,
7159
+ 'hardware_id': frame.slice(25, 28),
7160
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
7161
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
7162
+ 'machine_values': {
7163
+ 'firmware': frame[2],
7164
+ 'fsr': frame[16],
7165
+ 'boot_time': frame[17],
7166
+ 'power_adc': frame.slice(18, 20),
7167
+ 'auto_check_interval': frame.slice(20, 22),
7168
+ 'auto_check_percentage': frame.slice(22, 24),
7169
+ 'always_on': frame[24],
7170
+ 'hardware_id': frame.slice(25, 28),
7171
+ 'report_rate': frame.slice(28, 32),
7172
+ 'tx_life_counter': frame.slice(32, 36)
7173
+ }
7174
+ }
7175
+ }
6537
7176
  }
6538
7177
  },
6539
7178
  '96': {
@@ -6543,6 +7182,57 @@ function sensor_types(parent){
6543
7182
  adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
6544
7183
  vdc: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
6545
7184
  };
7185
+ },
7186
+ 'parse_fly': (frame) => {
7187
+ let firmware = frame[2];
7188
+ if(firmware > 13){ // firmware 14 and above
7189
+ let frame_data = {};
7190
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
7191
+ switch(frame[16]){
7192
+ case 0:
7193
+ frame_data.fsr = "+-0.256 V";
7194
+ break;
7195
+ case 1:
7196
+ frame_data.fsr = "+-0.512 V";
7197
+ break;
7198
+ case 2:
7199
+ frame_data.fsr = "+-1.024 V";
7200
+ break;
7201
+ case 3:
7202
+ frame_data.fsr = "+-2.048 V";
7203
+ break;
7204
+ case 4:
7205
+ frame_data.fsr = "+-4.096 V";
7206
+ break;
7207
+ case 5:
7208
+ frame_data.fsr = "+-6.144 V";
7209
+ break;
7210
+ }
7211
+ return {
7212
+ 'firmware': frame[2],
7213
+ 'fsr': frame_data.fsr,
7214
+ 'boot_time': frame[17] + " sec",
7215
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
7216
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
7217
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
7218
+ 'always_on': frame_data.always_on,
7219
+ 'hardware_id': frame.slice(25, 28),
7220
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
7221
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
7222
+ 'machine_values': {
7223
+ 'firmware': frame[2],
7224
+ 'fsr': frame[16],
7225
+ 'boot_time': frame[17],
7226
+ 'power_adc': frame.slice(18, 20),
7227
+ 'auto_check_interval': frame.slice(20, 22),
7228
+ 'auto_check_percentage': frame.slice(22, 24),
7229
+ 'always_on': frame[24],
7230
+ 'hardware_id': frame.slice(25, 28),
7231
+ 'report_rate': frame.slice(28, 32),
7232
+ 'tx_life_counter': frame.slice(32, 36)
7233
+ }
7234
+ }
7235
+ }
6546
7236
  }
6547
7237
  },
6548
7238
  '97': {
@@ -6914,16 +7604,350 @@ function sensor_types(parent){
6914
7604
  };
6915
7605
  }
6916
7606
  },
6917
- '105': {
6918
- name: '1 Channel Automatic Luber With Ultrasound Vibration Sensor',
6919
- parse: (d) => {
6920
- return {
6921
- raw_adc: d.slice(0, 2).reduce(msbLsb),
6922
- ma: d.slice(2, 4).reduce(msbLsb) / 100,
6923
- db: d.slice(4, 6).reduce(msbLsb) / 100
6924
- };
6925
- }
6926
- },
7607
+ '103': {
7608
+ name: 'Custom Wireless Accelerometer Sensor',
7609
+ parse: (payload, parsed, mac) => {
7610
+ if(payload[9] === 0){ // mode raw
7611
+ var deviceAddr = mac;
7612
+ var data = {};
7613
+ switch(payload[8]){
7614
+ case 1:
7615
+ data.sensor_type = 'adxl';
7616
+ break;
7617
+ case 2:
7618
+ data.sensor_type = 'gyro';
7619
+ break;
7620
+ }
7621
+ switch(payload[10]){
7622
+ case 1:
7623
+ data.event_type = 'report';
7624
+ break;
7625
+ case 2:
7626
+ data.event_type = 'motion';
7627
+ break;
7628
+ }
7629
+ var hour = payload[13];
7630
+ var minute = payload[14];
7631
+ var expected_packets = payload.slice(19, 21).reduce(msbLsb);
7632
+ var current_packet = payload.slice(21, 23).reduce(msbLsb);
7633
+ var data_start = 23;
7634
+
7635
+ if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
7636
+ if(expected_packets != 1){
7637
+ // if a packet is already stored with the same packet ID, or if packet ID is 1, or if current packet ID is not one more than last packet ID
7638
+ if(current_packet in globalDevices[deviceAddr].data || current_packet == 1 || !((current_packet-1) in globalDevices[deviceAddr].data)) {
7639
+ console.log('-----');
7640
+ console.log('bad packet breakdown deleting stream');
7641
+ console.log(current_packet);
7642
+ console.log(expected_packets);
7643
+ console.log(current_packet in globalDevices[deviceAddr].data);
7644
+ console.log(current_packet == 1);
7645
+ console.log(!((current_packet-1) in globalDevices[deviceAddr].data));
7646
+ if(this.hasOwnProperty('failure_no')){
7647
+ this.failure_no = this.failure_no + 1;
7648
+ }
7649
+ else{
7650
+ this.failure_no = 1;
7651
+ }
7652
+ if(this.hasOwnProperty('failure_no')){
7653
+ console.log('####falure no');
7654
+ console.log(this.failure_no);
7655
+ }
7656
+ // console.log(globalDevices[deviceAddr].data);
7657
+ delete globalDevices[deviceAddr];
7658
+ if(current_packet != 1){
7659
+ return;
7660
+ } else{
7661
+
7662
+ var mode = payload[9];
7663
+ var odr = payload[11];
7664
+ var en_axis = payload[12] & 7;
7665
+ var fsr = payload[12] >> 5;
7666
+ var device_temp = payload.slice(15, 17).reduce(msbLsb) / 100;
7667
+ var external_temperature = payload.slice(17, 19).reduce(msbLsb) / 100;
7668
+
7669
+ globalDevices[deviceAddr] = {
7670
+ // stream_size: expected_packets,
7671
+ data: {},
7672
+ odr: odr,
7673
+ mo: mode,
7674
+ en_axis: en_axis,
7675
+ fsr: fsr,
7676
+ hour: hour,
7677
+ minute: minute,
7678
+ device_temp: device_temp,
7679
+ external_temp: external_temperature
7680
+ }
7681
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(data_start);
7682
+ return;
7683
+ }
7684
+ }
7685
+ else{
7686
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(data_start);
7687
+ }
7688
+ }
7689
+ else{
7690
+ var mode = payload[9];
7691
+ var odr = payload[11];
7692
+ var en_axis = payload[12] & 7;
7693
+ var fsr = payload[12] >> 5;
7694
+ var device_temp = payload.slice(15, 17).reduce(msbLsb) / 100;
7695
+ var external_temperature = payload.slice(17, 19).reduce(msbLsb) / 100;
7696
+
7697
+ globalDevices[deviceAddr] = {
7698
+ // stream_size: expected_packets,
7699
+ data: {},
7700
+ odr: odr,
7701
+ mo: mode,
7702
+ en_axis: en_axis,
7703
+ fsr: fsr,
7704
+ hour: hour,
7705
+ minute: minute,
7706
+ device_temp: device_temp,
7707
+ external_temp: external_temperature
7708
+ }
7709
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(data_start);
7710
+ }
7711
+ if(Object.keys(globalDevices[deviceAddr].data).length == expected_packets){
7712
+ var raw_data = new Array();
7713
+ for(const packet in globalDevices[deviceAddr].data){
7714
+ raw_data = raw_data.concat(globalDevices[deviceAddr].data[packet]);
7715
+ }
7716
+ var label = 0;
7717
+
7718
+ var fft = new Array();
7719
+ var fft_concat = {};
7720
+
7721
+ var en_axis_data = {};
7722
+ switch (globalDevices[deviceAddr].en_axis){
7723
+ case 1:
7724
+ en_axis_data.x_offset = 0;
7725
+ en_axis_data.increment = 2;
7726
+ break;
7727
+ case 2:
7728
+ en_axis_data.y_offset = 0;
7729
+ en_axis_data.increment = 2;
7730
+ break;
7731
+ case 3:
7732
+ en_axis_data.x_offset = 0;
7733
+ en_axis_data.y_offset = 2;
7734
+ en_axis_data.increment = 4;
7735
+ break;
7736
+ case 4:
7737
+ en_axis_data.z_offset = 0;
7738
+ en_axis_data.increment = 2;
7739
+ break;
7740
+ case 5:
7741
+ en_axis_data.x_offset = 0;
7742
+ en_axis_data.z_offset = 2;
7743
+ en_axis_data.increment = 4;
7744
+ break;
7745
+ case 6:
7746
+ en_axis_data.y_offset = 0;
7747
+ en_axis_data.z_offset = 2;
7748
+ en_axis_data.increment = 4;
7749
+ break;
7750
+ case 7:
7751
+ en_axis_data.x_offset = 0;
7752
+ en_axis_data.y_offset = 2;
7753
+ en_axis_data.z_offset = 4;
7754
+ en_axis_data.increment = 6;
7755
+ break;
7756
+ default:
7757
+ en_axis_data.increment = 0;
7758
+ }
7759
+ /* Evaluate sensor type */
7760
+ if(payload[0] == 1){ // adxl
7761
+ var fsr_mult = .00030;
7762
+ var fsr_text = "";
7763
+ switch(globalDevices[deviceAddr].fsr){
7764
+ case 0:
7765
+ fsr_mult = 0.00030;
7766
+ break;
7767
+ case 1:
7768
+ fsr_mult = 0.00061;
7769
+ break;
7770
+ case 2:
7771
+ fsr_mult = 0.00122;
7772
+ break;
7773
+ }
7774
+ switch(globalDevices[deviceAddr].fsr){
7775
+ case 0:
7776
+ fsr_text = "10g";
7777
+ break;
7778
+ case 1:
7779
+ fsr_text = "20g";
7780
+ break;
7781
+ case 2:
7782
+ fsr_text = "40g";
7783
+ break;
7784
+ }
7785
+ }else{ // gyro
7786
+ var fsr_mult = 0.00047;
7787
+ var fsr_text = "";
7788
+ switch(globalDevices[deviceAddr].fsr){
7789
+ case 0:
7790
+ fsr_mult = 0.00047;
7791
+ break;
7792
+ case 1:
7793
+ fsr_mult = 0.00095;
7794
+ break;
7795
+ case 2:
7796
+ fsr_mult = 0.00190;
7797
+ break;
7798
+ case 3:
7799
+ fsr_mult = 0.00381;
7800
+ break;
7801
+ }
7802
+ switch(globalDevices[deviceAddr].fsr){
7803
+ case 0:
7804
+ fsr_text = "250dps";
7805
+ break;
7806
+ case 1:
7807
+ fsr_text = "500dps";
7808
+ break;
7809
+ case 2:
7810
+ fsr_text = "1000dps";
7811
+ break;
7812
+ case 3:
7813
+ fsr_text = "2000dps";
7814
+ break;
7815
+ }
7816
+ }
7817
+
7818
+ for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
7819
+ label++;
7820
+
7821
+ fft_concat[label] = {};
7822
+
7823
+ if('x_offset' in en_axis_data){
7824
+ 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));
7825
+ }
7826
+ if('y_offset' in en_axis_data){
7827
+ 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));
7828
+ }
7829
+ if('z_offset' in en_axis_data){
7830
+ 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));
7831
+ }
7832
+ }
7833
+ var fft_concat_obj = {
7834
+ mode: payload[9],
7835
+ sensor_type: data.sensor_type,
7836
+ msg_type: data.event_type,
7837
+ time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
7838
+ mac_address: deviceAddr,
7839
+ en_axis: globalDevices[deviceAddr].en_axis,
7840
+ fsr: fsr_text,
7841
+ odr: globalDevices[deviceAddr].odr,
7842
+ device_temp: globalDevices[deviceAddr].device_temp,
7843
+ external_temp: globalDevices[deviceAddr].external_temp,
7844
+ total_samples: label,
7845
+ data: fft_concat
7846
+ };
7847
+ // console.log(globalDevices[deviceAddr].data);
7848
+ // console.log(raw_data);
7849
+ sensor_data = fft_concat_obj;
7850
+ // parsed.raw_packets = globalDevices[deviceAddr].data;
7851
+ // parsed.raw_data = raw_data;
7852
+ delete globalDevices[deviceAddr];
7853
+ if(this.hasOwnProperty('failure_no')){
7854
+ console.log('####falure no');
7855
+ console.log(this.failure_no);
7856
+ }
7857
+
7858
+ return sensor_data;
7859
+ }
7860
+ else{
7861
+ return;
7862
+ }
7863
+ }else{
7864
+
7865
+ var mode = payload[9];
7866
+ var odr = payload[11];
7867
+ var en_axis = payload[12] & 7;
7868
+ var fsr = payload[12] >> 5;
7869
+ var device_temp = payload.slice(15, 17).reduce(msbLsb) / 100;
7870
+ var external_temperature = payload.slice(17, 19).reduce(msbLsb) / 100;
7871
+
7872
+ globalDevices[deviceAddr] = {
7873
+ // stream_size: expected_packets,
7874
+ data: {},
7875
+ odr: odr,
7876
+ mo: mode,
7877
+ en_axis: en_axis,
7878
+ fsr: fsr,
7879
+ hour: hour,
7880
+ minute: minute,
7881
+ device_temp: device_temp,
7882
+ external_temp: external_temperature
7883
+ }
7884
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(data_start);
7885
+ return;
7886
+ }
7887
+ }
7888
+ }
7889
+ },
7890
+ '105': {
7891
+ name: '1 Channel Automatic Luber With Ultrasound Vibration Sensor',
7892
+ parse: (d) => {
7893
+ return {
7894
+ raw_adc: d.slice(0, 2).reduce(msbLsb),
7895
+ ma: d.slice(2, 4).reduce(msbLsb) / 100,
7896
+ db: d.slice(4, 6).reduce(msbLsb) / 100
7897
+ };
7898
+ },
7899
+ 'parse_fly': (frame) => {
7900
+ let firmware = frame[2];
7901
+ if(firmware > 13){ // firmware 14 and above
7902
+ let frame_data = {};
7903
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
7904
+ switch(frame[16]){
7905
+ case 0:
7906
+ frame_data.fsr = "+-0.256 V";
7907
+ break;
7908
+ case 1:
7909
+ frame_data.fsr = "+-0.512 V";
7910
+ break;
7911
+ case 2:
7912
+ frame_data.fsr = "+-1.024 V";
7913
+ break;
7914
+ case 3:
7915
+ frame_data.fsr = "+-2.048 V";
7916
+ break;
7917
+ case 4:
7918
+ frame_data.fsr = "+-4.096 V";
7919
+ break;
7920
+ case 5:
7921
+ frame_data.fsr = "+-6.144 V";
7922
+ break;
7923
+ }
7924
+ return {
7925
+ 'firmware': frame[2],
7926
+ 'fsr': frame_data.fsr,
7927
+ 'boot_time': frame[17] + " sec",
7928
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
7929
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
7930
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
7931
+ 'always_on': frame_data.always_on,
7932
+ 'hardware_id': frame.slice(25, 28),
7933
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
7934
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
7935
+ 'machine_values': {
7936
+ 'firmware': frame[2],
7937
+ 'fsr': frame[16],
7938
+ 'boot_time': frame[17],
7939
+ 'power_adc': frame.slice(18, 20),
7940
+ 'auto_check_interval': frame.slice(20, 22),
7941
+ 'auto_check_percentage': frame.slice(22, 24),
7942
+ 'always_on': frame[24],
7943
+ 'hardware_id': frame.slice(25, 28),
7944
+ 'report_rate': frame.slice(28, 32),
7945
+ 'tx_life_counter': frame.slice(32, 36)
7946
+ }
7947
+ }
7948
+ }
7949
+ }
7950
+ },
6927
7951
  '106': {
6928
7952
  name: '2 Channel Automatic Luber With Ultrasound Vibration Sensor',
6929
7953
  parse: (d) => {
@@ -6935,6 +7959,57 @@ function sensor_types(parent){
6935
7959
  c2_ma: d.slice(8, 10).reduce(msbLsb) / 100,
6936
7960
  c2_db: d.slice(10, 12).reduce(msbLsb) / 100
6937
7961
  };
7962
+ },
7963
+ 'parse_fly': (frame) => {
7964
+ let firmware = frame[2];
7965
+ if(firmware > 13){ // firmware 14 and above
7966
+ let frame_data = {};
7967
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
7968
+ switch(frame[16]){
7969
+ case 0:
7970
+ frame_data.fsr = "+-0.256 V";
7971
+ break;
7972
+ case 1:
7973
+ frame_data.fsr = "+-0.512 V";
7974
+ break;
7975
+ case 2:
7976
+ frame_data.fsr = "+-1.024 V";
7977
+ break;
7978
+ case 3:
7979
+ frame_data.fsr = "+-2.048 V";
7980
+ break;
7981
+ case 4:
7982
+ frame_data.fsr = "+-4.096 V";
7983
+ break;
7984
+ case 5:
7985
+ frame_data.fsr = "+-6.144 V";
7986
+ break;
7987
+ }
7988
+ return {
7989
+ 'firmware': frame[2],
7990
+ 'fsr': frame_data.fsr,
7991
+ 'boot_time': frame[17] + " sec",
7992
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
7993
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
7994
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
7995
+ 'always_on': frame_data.always_on,
7996
+ 'hardware_id': frame.slice(25, 28),
7997
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
7998
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
7999
+ 'machine_values': {
8000
+ 'firmware': frame[2],
8001
+ 'fsr': frame[16],
8002
+ 'boot_time': frame[17],
8003
+ 'power_adc': frame.slice(18, 20),
8004
+ 'auto_check_interval': frame.slice(20, 22),
8005
+ 'auto_check_percentage': frame.slice(22, 24),
8006
+ 'always_on': frame[24],
8007
+ 'hardware_id': frame.slice(25, 28),
8008
+ 'report_rate': frame.slice(28, 32),
8009
+ 'tx_life_counter': frame.slice(32, 36)
8010
+ }
8011
+ }
8012
+ }
6938
8013
  }
6939
8014
  },
6940
8015
  '107': {
@@ -6958,6 +8033,57 @@ function sensor_types(parent){
6958
8033
  ma3: ma3,
6959
8034
  ma4: ma4
6960
8035
  };
8036
+ },
8037
+ 'parse_fly': (frame) => {
8038
+ let firmware = frame[2];
8039
+ if(firmware > 13){ // firmware 14 and above
8040
+ let frame_data = {};
8041
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
8042
+ switch(frame[16]){
8043
+ case 0:
8044
+ frame_data.fsr = "+-0.256 V";
8045
+ break;
8046
+ case 1:
8047
+ frame_data.fsr = "+-0.512 V";
8048
+ break;
8049
+ case 2:
8050
+ frame_data.fsr = "+-1.024 V";
8051
+ break;
8052
+ case 3:
8053
+ frame_data.fsr = "+-2.048 V";
8054
+ break;
8055
+ case 4:
8056
+ frame_data.fsr = "+-4.096 V";
8057
+ break;
8058
+ case 5:
8059
+ frame_data.fsr = "+-6.144 V";
8060
+ break;
8061
+ }
8062
+ return {
8063
+ 'firmware': frame[2],
8064
+ 'fsr': frame_data.fsr,
8065
+ 'boot_time': frame[17] + " sec",
8066
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
8067
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
8068
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
8069
+ 'always_on': frame_data.always_on,
8070
+ 'hardware_id': frame.slice(25, 28),
8071
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
8072
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
8073
+ 'machine_values': {
8074
+ 'firmware': frame[2],
8075
+ 'fsr': frame[16],
8076
+ 'boot_time': frame[17],
8077
+ 'power_adc': frame.slice(18, 20),
8078
+ 'auto_check_interval': frame.slice(20, 22),
8079
+ 'auto_check_percentage': frame.slice(22, 24),
8080
+ 'always_on': frame[24],
8081
+ 'hardware_id': frame.slice(25, 28),
8082
+ 'report_rate': frame.slice(28, 32),
8083
+ 'tx_life_counter': frame.slice(32, 36)
8084
+ }
8085
+ }
8086
+ }
6961
8087
  }
6962
8088
  },
6963
8089
  '108': {
@@ -6971,7 +8097,21 @@ function sensor_types(parent){
6971
8097
  return error;
6972
8098
  }
6973
8099
  if(firmware > 4){
6974
- let report_type = d[41]? "Shift": "Regular";
8100
+ let report_type = "Regular";
8101
+ switch(d[41]){
8102
+ case 0:
8103
+ report_type = "Regular";
8104
+ break;
8105
+ case 1:
8106
+ report_type = "Shift end";
8107
+ break;
8108
+ case 2:
8109
+ report_type = "Interrupt";
8110
+ break;
8111
+ case 3:
8112
+ report_type = "Threshold";
8113
+ break;
8114
+ }
6975
8115
  return {
6976
8116
  digital_input_counter: d.slice(0, 4).reduce(msbLsb),
6977
8117
  digital_input_uptime: d.slice(4, 8).reduce(msbLsb),
@@ -6997,43 +8137,367 @@ function sensor_types(parent){
6997
8137
  };
6998
8138
  }else{
6999
8139
  return {
7000
- digital_input_counter: d.slice(0, 4).reduce(msbLsb),
7001
- digital_input_uptime: d.slice(4, 8).reduce(msbLsb),
7002
- ct_input_counter: d.slice(8, 12).reduce(msbLsb),
7003
- ct_input_uptime: d.slice(12, 16).reduce(msbLsb),
7004
- opto_input_counter: d.slice(16, 20).reduce(msbLsb),
7005
- opto_input_uptime: d.slice(20, 24).reduce(msbLsb),
7006
- accelerometer_counter: d.slice(24, 28).reduce(msbLsb),
7007
- accelerometer_uptime: d.slice(28, 32).reduce(msbLsb),
7008
- magnetometer_counter: d.slice(32, 36).reduce(msbLsb),
7009
- magnetometer_uptime: d.slice(36, 40).reduce(msbLsb),
7010
- input_di: d[40] & 1 ? 1 : 0,
7011
- input_ct: d[40] & 2 ? 1 : 0,
7012
- input_opto: d[40] & 4 ? 1 : 0,
7013
- input_acc: d[40] & 8 ? 1 : 0,
7014
- input_mag: d[40] & 16 ? 1 : 0
7015
- };
8140
+ digital_input_counter: d.slice(0, 4).reduce(msbLsb),
8141
+ digital_input_uptime: d.slice(4, 8).reduce(msbLsb),
8142
+ ct_input_counter: d.slice(8, 12).reduce(msbLsb),
8143
+ ct_input_uptime: d.slice(12, 16).reduce(msbLsb),
8144
+ opto_input_counter: d.slice(16, 20).reduce(msbLsb),
8145
+ opto_input_uptime: d.slice(20, 24).reduce(msbLsb),
8146
+ accelerometer_counter: d.slice(24, 28).reduce(msbLsb),
8147
+ accelerometer_uptime: d.slice(28, 32).reduce(msbLsb),
8148
+ magnetometer_counter: d.slice(32, 36).reduce(msbLsb),
8149
+ magnetometer_uptime: d.slice(36, 40).reduce(msbLsb),
8150
+ input_di: d[40] & 1 ? 1 : 0,
8151
+ input_ct: d[40] & 2 ? 1 : 0,
8152
+ input_opto: d[40] & 4 ? 1 : 0,
8153
+ input_acc: d[40] & 8 ? 1 : 0,
8154
+ input_mag: d[40] & 16 ? 1 : 0
8155
+ };
8156
+ }
8157
+ },
8158
+ 'parse_fly': (frame) => {
8159
+ if(frame[2] > 8){
8160
+ let reset_mode = "Disabled";
8161
+ switch(frame[37]){
8162
+ case 0:
8163
+ reset_mode = "Disabled";
8164
+ break;
8165
+ case 1:
8166
+ reset_mode = "Shift Ends";
8167
+ break;
8168
+ case 2:
8169
+ reset_mode = "Timeout";
8170
+ break;
8171
+ }
8172
+ let acc_odr = "10Hz";
8173
+ switch(frame[39]){
8174
+ case 0:
8175
+ acc_odr = "10Hz";
8176
+ break;
8177
+ case 1:
8178
+ acc_odr = "20Hz";
8179
+ break;
8180
+ case 2:
8181
+ acc_odr = "50Hz";
8182
+ break;
8183
+ case 3:
8184
+ acc_odr = "100Hz";
8185
+ break;
8186
+ case 4:
8187
+ acc_odr = "200Hz";
8188
+ break;
8189
+ case 5:
8190
+ acc_odr = "400Hz";
8191
+ break;
8192
+ }
8193
+ let rtc_sampling_interval = "5 seconds";
8194
+ switch(frame[38]){
8195
+ case 0:
8196
+ rtc_sampling_interval = "1 minute";
8197
+ break;
8198
+ case 1:
8199
+ rtc_sampling_interval = "5 minutes";
8200
+ break;
8201
+ case 2:
8202
+ rtc_sampling_interval = "15 minutes";
8203
+ break;
8204
+ case 3:
8205
+ rtc_sampling_interval = "30 minutes";
8206
+ break;
8207
+ case 4:
8208
+ rtc_sampling_interval = "1 hour";
8209
+ break;
8210
+ case 5:
8211
+ rtc_sampling_interval = "2 hours";
8212
+ break;
8213
+ case 6:
8214
+ rtc_sampling_interval = "3 hours";
8215
+ break;
8216
+ case 7:
8217
+ rtc_sampling_interval = "6 hours";
8218
+ break;
8219
+ case 8:
8220
+ rtc_sampling_interval = "12 hours";
8221
+ break;
8222
+ case 9:
8223
+ rtc_sampling_interval = "5 seconds";
8224
+ break;
8225
+ case 10:
8226
+ rtc_sampling_interval = "10 seconds";
8227
+ break;
8228
+ case 11:
8229
+ rtc_sampling_interval = "15 seconds";
8230
+ break;
8231
+ case 12:
8232
+ rtc_sampling_interval = "30 seconds";
8233
+ break;
8234
+ }
8235
+ return {
8236
+ 'firmware': frame[2],
8237
+ 'accelerometer_threshold': (frame[16]* 32) + "mg",
8238
+ 'debouncing_timeout': frame[17] + "sec",
8239
+ 'accelero_state': frame[18]? "Enabled": "Disabled",
8240
+ 'input_1_active_edge': frame[19]? "Rising": "Falling",
8241
+ 'input_2_active_edge': frame[20]? "Rising": "Falling",
8242
+ 'input_3_active_edge': frame[21]? "Rising": "Falling",
8243
+ 'counter_threshold': frame.slice(22, 26).reduce(msbLsb) + "sec",
8244
+ 'trasnmit_on_change_status': frame[26]? "Enabled": "Disabled",
8245
+ 'Shift_end_1': [
8246
+ String(frame[27]).padStart(2, '0'),
8247
+ String(frame[28]).padStart(2, '0')
8248
+ ].join(':'),
8249
+ 'Shift_end_2': [
8250
+ String(frame[29]).padStart(2, '0'),
8251
+ String(frame[30]).padStart(2, '0')
8252
+ ].join(':'),
8253
+ 'Shift_end_3': [
8254
+ String(frame[31]).padStart(2, '0'),
8255
+ String(frame[32]).padStart(2, '0')
8256
+ ].join(':'),
8257
+ 'Shift_end_4': [
8258
+ String(frame[33]).padStart(2, '0'),
8259
+ String(frame[34]).padStart(2, '0')
8260
+ ].join(':'),
8261
+ 'reset_timeout': frame.slice(35, 37).reduce(msbLsb) + "min",
8262
+ 'counter_reset_mode': reset_mode,
8263
+ 'sampling_interval': rtc_sampling_interval,
8264
+ 'acc_odr': acc_odr,
8265
+ 'hardware_id': frame.slice(40, 43),
8266
+ 'report_rate': frame.slice(43, 47).reduce(msbLsb) + "sec",
8267
+ 'tx_life_counter': frame.slice(47, 51).reduce(msbLsb),
8268
+ 'machine_values': {
8269
+ 'firmware': frame[2],
8270
+ 'accelerometer_threshold': frame[16],
8271
+ 'debouncing_timeout': frame[17],
8272
+ 'accelero_state': frame[18],
8273
+ 'input_1_active_edge': frame[19],
8274
+ 'input_2_active_edge': frame[20],
8275
+ 'input_3_active_edge': frame[21],
8276
+ 'counter_threshold': frame.slice(22, 26),
8277
+ 'trasnmit_on_change_status': frame[26],
8278
+ 'Shift_end_1': frame.slice(27, 29),
8279
+ 'Shift_end_2': frame.slice(29, 31),
8280
+ 'Shift_end_3': frame.slice(31, 33),
8281
+ 'Shift_end_4': frame.slice(33, 35),
8282
+ 'reset_timeout': frame.slice(35, 37),
8283
+ 'counter_reset_mode': frame[37],
8284
+ 'sampling_interval': frame[38],
8285
+ 'acc_odr': frame[39],
8286
+ 'hardware_id': frame.slice(40, 43),
8287
+ 'report_rate': frame.slice(43, 47),
8288
+ 'tx_life_counter': frame.slice(47, 51)
8289
+ }
8290
+ }
8291
+ } else{
8292
+ return {
8293
+ 'firmware': frame[2],
8294
+ 'report_rate': frame.slice(12, 16).reduce(msbLsb).toString() + "sec.",
8295
+ 'accelerometer_threshold': (frame[16]* 32).toString() + "mg.",
8296
+ 'debouncing_timeout': frame[17].toString() + "sec.",
8297
+ 'accelero_state': frame[18],
8298
+ 'digital_inputs_active_edge': frame.slice(19, 22).reduce(msbLsb),
8299
+ 'counter_threshold': frame.slice(22, 26).reduce(msbLsb).toString() + "sec.",
8300
+ 'trasnmit_on_change_status': frame[26],
8301
+ 'machine_values': {
8302
+ 'firmware': frame[2],
8303
+ 'report_rate': frame.slice(12, 16),
8304
+ 'accelerometer_threshold': frame[16],
8305
+ 'debouncing_timeout': frame[17],
8306
+ 'accelero_active_state': frame[18],
8307
+ 'digital_inputs_active_edge': frame.slice(19, 22),
8308
+ 'counter_threshold': frame.slice(22, 26),
8309
+ 'trasnmit_on_change_status': frame[26]
8310
+ }
8311
+ }
8312
+ }
8313
+ }
8314
+ },
8315
+ '109': {
8316
+ name: 'Wireless Custom Solar Sensor',
8317
+ parse: (d) => {
8318
+ return {
8319
+ illuminance: d.slice(0, 4).reduce(msbLsb),
8320
+ total_solar_radiation: d.slice(4, 6).reduce(msbLsb),
8321
+ ultraviolet_radiation: d.slice(6, 8).reduce(msbLsb)
8322
+ };
8323
+ },
8324
+ 'parse_fly': (frame) => {
8325
+ if(frame[2] > 8){
8326
+ let reset_mode = "Disabled";
8327
+ switch(frame[37]){
8328
+ case 0:
8329
+ reset_mode = "Disabled";
8330
+ break;
8331
+ case 1:
8332
+ reset_mode = "Shift Ends";
8333
+ break;
8334
+ case 2:
8335
+ reset_mode = "Timeout";
8336
+ break;
8337
+ }
8338
+ let acc_odr = "10Hz";
8339
+ switch(frame[39]){
8340
+ case 0:
8341
+ acc_odr = "10Hz";
8342
+ break;
8343
+ case 1:
8344
+ acc_odr = "20Hz";
8345
+ break;
8346
+ case 2:
8347
+ acc_odr = "50Hz";
8348
+ break;
8349
+ case 3:
8350
+ acc_odr = "100Hz";
8351
+ break;
8352
+ case 4:
8353
+ acc_odr = "200Hz";
8354
+ break;
8355
+ case 5:
8356
+ acc_odr = "400Hz";
8357
+ break;
8358
+ }
8359
+ let rtc_sampling_interval = "5 seconds";
8360
+ switch(frame[38]){
8361
+ case 0:
8362
+ rtc_sampling_interval = "1 minute";
8363
+ break;
8364
+ case 1:
8365
+ rtc_sampling_interval = "5 minutes";
8366
+ break;
8367
+ case 2:
8368
+ rtc_sampling_interval = "15 minutes";
8369
+ break;
8370
+ case 3:
8371
+ rtc_sampling_interval = "30 minutes";
8372
+ break;
8373
+ case 4:
8374
+ rtc_sampling_interval = "1 hour";
8375
+ break;
8376
+ case 5:
8377
+ rtc_sampling_interval = "2 hours";
8378
+ break;
8379
+ case 6:
8380
+ rtc_sampling_interval = "3 hours";
8381
+ break;
8382
+ case 7:
8383
+ rtc_sampling_interval = "6 hours";
8384
+ break;
8385
+ case 8:
8386
+ rtc_sampling_interval = "12 hours";
8387
+ break;
8388
+ case 9:
8389
+ rtc_sampling_interval = "5 seconds";
8390
+ break;
8391
+ case 10:
8392
+ rtc_sampling_interval = "10 seconds";
8393
+ break;
8394
+ case 11:
8395
+ rtc_sampling_interval = "15 seconds";
8396
+ break;
8397
+ case 12:
8398
+ rtc_sampling_interval = "30 seconds";
8399
+ break;
8400
+ }
8401
+ return {
8402
+ 'firmware': frame[2],
8403
+ 'accelerometer_threshold': (frame[16]* 32) + "mg",
8404
+ 'debouncing_timeout': frame[17] + "sec",
8405
+ 'accelero_state': frame[18]? "Enabled": "Disabled",
8406
+ 'input_1_active_edge': frame[19]? "Rising": "Falling",
8407
+ 'input_2_active_edge': frame[20]? "Rising": "Falling",
8408
+ 'input_3_active_edge': frame[21]? "Rising": "Falling",
8409
+ 'counter_threshold': frame.slice(22, 26).reduce(msbLsb) + "sec",
8410
+ 'trasnmit_on_change_status': frame[26]? "Enabled": "Disabled",
8411
+ 'Shift_end_1': [
8412
+ String(frame[27]).padStart(2, '0'),
8413
+ String(frame[28]).padStart(2, '0')
8414
+ ].join(':'),
8415
+ 'Shift_end_2': [
8416
+ String(frame[29]).padStart(2, '0'),
8417
+ String(frame[30]).padStart(2, '0')
8418
+ ].join(':'),
8419
+ 'Shift_end_3': [
8420
+ String(frame[31]).padStart(2, '0'),
8421
+ String(frame[32]).padStart(2, '0')
8422
+ ].join(':'),
8423
+ 'Shift_end_4': [
8424
+ String(frame[33]).padStart(2, '0'),
8425
+ String(frame[34]).padStart(2, '0')
8426
+ ].join(':'),
8427
+ 'reset_timeout': frame.slice(35, 37).reduce(msbLsb) + "min",
8428
+ 'counter_reset_mode': reset_mode,
8429
+ 'sampling_interval': rtc_sampling_interval,
8430
+ 'acc_odr': acc_odr,
8431
+ 'hardware_id': frame.slice(40, 43),
8432
+ 'report_rate': frame.slice(43, 47).reduce(msbLsb) + "sec",
8433
+ 'tx_life_counter': frame.slice(47, 51).reduce(msbLsb),
8434
+ 'machine_values': {
8435
+ 'firmware': frame[2],
8436
+ 'accelerometer_threshold': frame[16],
8437
+ 'debouncing_timeout': frame[17],
8438
+ 'accelero_state': frame[18],
8439
+ 'input_1_active_edge': frame[19],
8440
+ 'input_2_active_edge': frame[20],
8441
+ 'input_3_active_edge': frame[21],
8442
+ 'counter_threshold': frame.slice(22, 26),
8443
+ 'trasnmit_on_change_status': frame[26],
8444
+ 'Shift_end_1': frame.slice(27, 29),
8445
+ 'Shift_end_2': frame.slice(29, 31),
8446
+ 'Shift_end_3': frame.slice(31, 33),
8447
+ 'Shift_end_4': frame.slice(33, 35),
8448
+ 'reset_timeout': frame.slice(35, 37),
8449
+ 'counter_reset_mode': frame[37],
8450
+ 'sampling_interval': frame[38],
8451
+ 'acc_odr': frame[39],
8452
+ 'hardware_id': frame.slice(40, 43),
8453
+ 'report_rate': frame.slice(43, 47),
8454
+ 'tx_life_counter': frame.slice(47, 51)
8455
+ }
8456
+ }
8457
+ } else{
8458
+ return {
8459
+ 'firmware': frame[2],
8460
+ 'report_rate': frame.slice(12, 16).reduce(msbLsb).toString() + "sec.",
8461
+ 'accelerometer_threshold': (frame[16]* 32).toString() + "mg.",
8462
+ 'debouncing_timeout': frame[17].toString() + "sec.",
8463
+ 'accelero_state': frame[18],
8464
+ 'digital_inputs_active_edge': frame.slice(19, 22).reduce(msbLsb),
8465
+ 'counter_threshold': frame.slice(22, 26).reduce(msbLsb).toString() + "sec.",
8466
+ 'trasnmit_on_change_status': frame[26],
8467
+ 'machine_values': {
8468
+ 'firmware': frame[2],
8469
+ 'report_rate': frame.slice(12, 16),
8470
+ 'accelerometer_threshold': frame[16],
8471
+ 'debouncing_timeout': frame[17],
8472
+ 'accelero_active_state': frame[18],
8473
+ 'digital_inputs_active_edge': frame.slice(19, 22),
8474
+ 'counter_threshold': frame.slice(22, 26),
8475
+ 'trasnmit_on_change_status': frame[26]
8476
+ }
8477
+ }
7016
8478
  }
8479
+ }
8480
+ },
8481
+ '109': {
8482
+ name: 'Wireless Custom Solar Sensor',
8483
+ parse: (d) => {
8484
+ return {
8485
+ illuminance: d.slice(0, 4).reduce(msbLsb),
8486
+ total_solar_radiation: d.slice(4, 6).reduce(msbLsb),
8487
+ ultraviolet_radiation: d.slice(6, 8).reduce(msbLsb)
8488
+ };
7017
8489
  },
7018
8490
  'parse_fly': (frame) => {
7019
8491
  return {
7020
8492
  'firmware': frame[2],
7021
- 'report_rate': frame.slice(12, 16).reduce(msbLsb).toString() + "sec.",
7022
- 'accelerometer_threshold': (frame[16]* 32).toString() + "mg.",
7023
- 'debouncing_timeout': frame[17].toString() + "sec.",
7024
- 'accelero_active_state': frame[18],
7025
- 'digital_inputs_active_edge': frame.slice(19, 22).reduce(msbLsb),
7026
- 'counter_threshold': frame.slice(22, 26).reduce(msbLsb).toString() + "sec.",
7027
- 'trasnmit_on_change_status': frame[26],
8493
+ 'hardware_id': frame.slice(12, 15),
8494
+ 'sample_rate': frame.slice(15, 19).reduce(msbLsb) + " Sec.",
8495
+ 'tx_life_counter': frame.slice(19, 23).reduce(msbLsb),
7028
8496
  'machine_values': {
7029
8497
  'firmware': frame[2],
7030
- 'report_rate': frame.slice(12, 16),
7031
- 'accelerometer_threshold': frame[16],
7032
- 'debouncing_timeout': frame[17],
7033
- 'accelero_active_state': frame[18],
7034
- 'digital_inputs_active_edge': frame.slice(19, 22),
7035
- 'counter_threshold': frame.slice(22, 26),
7036
- 'trasnmit_on_change_status': frame[26]
8498
+ 'hardware_id': frame.slice(12, 15),
8499
+ 'sample_rate': frame.slice(15, 19),
8500
+ 'tx_life_counter': frame.slice(19, 23)
7037
8501
  }
7038
8502
  }
7039
8503
  }
@@ -7083,7 +8547,7 @@ function sensor_types(parent){
7083
8547
  if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
7084
8548
  if(expected_packets != 1){
7085
8549
  // if a packet is already stored with the same packet ID, or if packet ID is 1, or if current packet ID is not one more than last packet ID
7086
- if(current_packet in globalDevices[deviceAddr].data || current_packet == 1 || !(((current_packet&127)-1) in globalDevices[deviceAddr].data)) {
8550
+ if(current_packet in globalDevices[deviceAddr].data || current_packet == 1 || !(((current_packet)-1) in globalDevices[deviceAddr].data)) {
7087
8551
  console.log('-----');
7088
8552
  console.log('bad packet breakdown deleting stream');
7089
8553
  console.log(current_packet);
@@ -7108,8 +8572,7 @@ function sensor_types(parent){
7108
8572
  } else{
7109
8573
 
7110
8574
  var mode = payload[8];
7111
- var odr = msbLsb(payload[9], payload[10])
7112
- var en_axis = payload[11] & 7;
8575
+ var odr = msbLsb(payload[9], payload[10]);
7113
8576
  var fsr = payload[11] >> 5;
7114
8577
  var device_temp = msbLsb(payload[14], payload[15])/100;
7115
8578
 
@@ -7118,7 +8581,6 @@ function sensor_types(parent){
7118
8581
  data: {},
7119
8582
  odr: odr,
7120
8583
  mo: mode,
7121
- en_axis: en_axis,
7122
8584
  fsr: fsr,
7123
8585
  hour: hour,
7124
8586
  minute: minute,
@@ -7134,8 +8596,7 @@ function sensor_types(parent){
7134
8596
  }
7135
8597
  else{
7136
8598
  var mode = payload[8];
7137
- var odr = msbLsb(payload[9], payload[10])
7138
- var en_axis = payload[11] & 7;
8599
+ var odr = msbLsb(payload[9], payload[10]);
7139
8600
  var fsr = payload[11] >> 5;
7140
8601
  var device_temp = msbLsb(payload[14], payload[15])/100;
7141
8602
 
@@ -7144,7 +8605,6 @@ function sensor_types(parent){
7144
8605
  data: {},
7145
8606
  odr: odr,
7146
8607
  mo: mode,
7147
- en_axis: en_axis,
7148
8608
  fsr: fsr,
7149
8609
  hour: hour,
7150
8610
  minute: minute,
@@ -7164,43 +8624,11 @@ function sensor_types(parent){
7164
8624
  var fft_concat = {};
7165
8625
 
7166
8626
  var en_axis_data = {};
7167
- switch (globalDevices[deviceAddr].en_axis){
7168
- case 1:
7169
- en_axis_data.x_offset = 0;
7170
- en_axis_data.increment = 2;
7171
- break;
7172
- case 2:
7173
- en_axis_data.y_offset = 0;
7174
- en_axis_data.increment = 2;
7175
- break;
7176
- case 3:
7177
- en_axis_data.x_offset = 0;
7178
- en_axis_data.y_offset = 2;
7179
- en_axis_data.increment = 4;
7180
- break;
7181
- case 4:
7182
- en_axis_data.z_offset = 0;
7183
- en_axis_data.increment = 2;
7184
- break;
7185
- case 5:
7186
- en_axis_data.x_offset = 0;
7187
- en_axis_data.z_offset = 2;
7188
- en_axis_data.increment = 4;
7189
- break;
7190
- case 6:
7191
- en_axis_data.y_offset = 0;
7192
- en_axis_data.z_offset = 2;
7193
- en_axis_data.increment = 4;
7194
- break;
7195
- case 7:
7196
- en_axis_data.x_offset = 0;
7197
- en_axis_data.y_offset = 2;
7198
- en_axis_data.z_offset = 4;
7199
- en_axis_data.increment = 6;
7200
- break;
7201
- default:
7202
- en_axis_data.increment = 0;
7203
- }
8627
+ en_axis_data.x_offset = 0;
8628
+ en_axis_data.y_offset = 2;
8629
+ en_axis_data.z_offset = 4;
8630
+ en_axis_data.increment = 6;
8631
+ fft_concat = {x: [], y: [], z: []};
7204
8632
 
7205
8633
  var fsr_mult = .00006;
7206
8634
  var fsr_text = "";
@@ -7233,19 +8661,18 @@ function sensor_types(parent){
7233
8661
  break;
7234
8662
  }
7235
8663
 
8664
+
7236
8665
  for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
7237
8666
  label++;
7238
8667
 
7239
- fft_concat[label] = {};
7240
-
7241
8668
  if('x_offset' in en_axis_data){
7242
- 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));
8669
+ fft_concat.x.push(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)));
7243
8670
  }
7244
8671
  if('y_offset' in en_axis_data){
7245
- 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));
8672
+ fft_concat.y.push(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)));
7246
8673
  }
7247
8674
  if('z_offset' in en_axis_data){
7248
- 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));
8675
+ fft_concat.z.push(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)));
7249
8676
  }
7250
8677
  }
7251
8678
  var fft_concat_obj = {
@@ -7253,7 +8680,6 @@ function sensor_types(parent){
7253
8680
  msg_type: msg_type,
7254
8681
  time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
7255
8682
  mac_address: deviceAddr,
7256
- en_axis: globalDevices[deviceAddr].en_axis,
7257
8683
  fsr: fsr_text,
7258
8684
  odr: globalDevices[deviceAddr].odr,
7259
8685
  device_temp: globalDevices[deviceAddr].device_temp,
@@ -7275,8 +8701,7 @@ function sensor_types(parent){
7275
8701
  }else{
7276
8702
 
7277
8703
  var mode = payload[8];
7278
- var odr = msbLsb(payload[9], payload[10])
7279
- var en_axis = payload[11] & 7;
8704
+ var odr = msbLsb(payload[9], payload[10]);
7280
8705
  var fsr = payload[11] >> 5;
7281
8706
  var device_temp = msbLsb(payload[14], payload[15])/100;
7282
8707
 
@@ -7285,7 +8710,6 @@ function sensor_types(parent){
7285
8710
  data: {},
7286
8711
  odr: odr,
7287
8712
  mo: mode,
7288
- en_axis: en_axis,
7289
8713
  fsr: fsr,
7290
8714
  hour: hour,
7291
8715
  minute: minute,
@@ -7565,54 +8989,109 @@ function sensor_types(parent){
7565
8989
  frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
7566
8990
  frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
7567
8991
  frame_data.smart_mode_threshold = frame[34] * 50;
7568
- return {
7569
- 'firmware': frame[2],
7570
- 'destination_address': toMac(frame.slice(12, 16)),
7571
- 'mode': frame_data.mode,
7572
- 'odr': frame_data.odr_1+'Hz',
7573
- 'sampling_duration': frame_data.sampling_duration_1,
7574
- 'filter_status': frame_data.filter_status,
7575
- 'lpf_coeff': frame_data.lpf_coeff_1,
7576
- 'lpf_freq': frame_data.lpf_freq_1+'Hz',
7577
- 'hpf_coeff': frame_data.hpf_coeff_1,
7578
- 'hpf_freq': frame_data.hpf_freq_1+'Hz',
7579
- 'sampling_interval': frame_data.sampling_interval,
7580
- 'on_request_timeout': frame_data.on_request_timeout,
7581
- 'deadband': frame_data.deadband,
7582
- 'payload_length': frame_data.payload_length,
7583
- 'fsr': frame_data.fsr_text,
7584
- 'rpm_compute_status': frame_data.rpm_status,
7585
- 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
7586
- 'auto_raw_interval': frame_data.auto_raw_interval,
7587
- 'smart_mode_skip_count': frame[33],
7588
- 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
7589
- 'uptime_counter': frame.slice(35, 39).reduce(msbLsb),
7590
- 'hardware_id': frame.slice(39, 42),
7591
- 'reserved': frame.slice(42, 46),
7592
- 'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
7593
- 'machine_values': {
8992
+ if(frame[2] > 4){ // for Firmware v5 and above
8993
+ return {
7594
8994
  'firmware': frame[2],
7595
- 'destination_address': toMac(frame.slice(12, 16), false),
7596
- 'mode': frame[16],
7597
- 'odr': frame[17],
7598
- 'sampling_duration': frame[18],
7599
- 'filter_status': frame[19],
7600
- 'lpf_coeff': frame[20],
7601
- 'hpf_coeff': frame[21],
7602
- 'sampling_interval': frame[22],
7603
- 'on_request_timeout': frame[23],
7604
- 'deadband': frame[24],
7605
- 'payload_length': frame[25],
7606
- 'fsr': frame[26],
7607
- 'rpm_compute_status': frame[27],
8995
+ 'destination_address': toMac(frame.slice(12, 16)),
8996
+ 'mode': frame_data.mode,
8997
+ 'odr': frame_data.odr_1+'Hz',
8998
+ 'sampling_duration': frame_data.sampling_duration_1,
8999
+ 'filter_status': frame_data.filter_status,
9000
+ 'lpf_coeff': frame_data.lpf_coeff_1,
9001
+ 'lpf_freq': frame_data.lpf_freq_1+'Hz',
9002
+ 'hpf_coeff': frame_data.hpf_coeff_1,
9003
+ 'hpf_freq': frame_data.hpf_freq_1+'Hz',
9004
+ 'sampling_interval': frame_data.sampling_interval,
9005
+ 'on_request_timeout': frame_data.on_request_timeout,
9006
+ 'deadband': frame_data.deadband,
9007
+ 'payload_length': frame_data.payload_length,
9008
+ 'fsr': frame_data.fsr_text,
9009
+ 'rpm_compute_status': frame_data.rpm_status,
9010
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
9011
+ 'auto_raw_interval': frame_data.auto_raw_interval,
9012
+ 'smart_mode_skip_count': frame[33],
9013
+ 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
9014
+ 'uptime_counter': frame.slice(35, 39).reduce(msbLsb)+'sec',
9015
+ 'max_tx_raw_samples': frame.slice(39, 41).reduce(msbLsb),
9016
+ 'hardware_id': frame.slice(41, 44),
9017
+ 'reserved': frame.slice(44, 48),
9018
+ 'tx_lifetime_counter': frame.slice(48, 52).reduce(msbLsb),
9019
+ 'machine_values': {
9020
+ 'firmware': frame[2],
9021
+ 'destination_address': toMac(frame.slice(12, 16), false),
9022
+ 'mode': frame[16],
9023
+ 'odr': frame[17],
9024
+ 'sampling_duration': frame[18],
9025
+ 'filter_status': frame[19],
9026
+ 'lpf_coeff': frame[20],
9027
+ 'hpf_coeff': frame[21],
9028
+ 'sampling_interval': frame[22],
9029
+ 'on_request_timeout': frame[23],
9030
+ 'deadband': frame[24],
9031
+ 'payload_length': frame[25],
9032
+ 'fsr': frame[26],
9033
+ 'rpm_compute_status': frame[27],
9034
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32), false),
9035
+ 'auto_raw_interval': frame[32],
9036
+ 'smart_mode_skip_count': frame[33],
9037
+ 'smart_mode_acc_threshold':frame[34],
9038
+ 'uptime_counter': frame.slice(35, 39),
9039
+ 'max_tx_raw_samples': frame.slice(39, 41),
9040
+ 'hardware_id': frame.slice(41, 44),
9041
+ 'reserved': frame.slice(44, 48),
9042
+ 'tx_lifetime_counter': frame.slice(48, 52)
9043
+ }
9044
+ }
9045
+ }else{
9046
+ return {
9047
+ 'firmware': frame[2],
9048
+ 'destination_address': toMac(frame.slice(12, 16)),
9049
+ 'mode': frame_data.mode,
9050
+ 'odr': frame_data.odr_1+'Hz',
9051
+ 'sampling_duration': frame_data.sampling_duration_1,
9052
+ 'filter_status': frame_data.filter_status,
9053
+ 'lpf_coeff': frame_data.lpf_coeff_1,
9054
+ 'lpf_freq': frame_data.lpf_freq_1+'Hz',
9055
+ 'hpf_coeff': frame_data.hpf_coeff_1,
9056
+ 'hpf_freq': frame_data.hpf_freq_1+'Hz',
9057
+ 'sampling_interval': frame_data.sampling_interval,
9058
+ 'on_request_timeout': frame_data.on_request_timeout,
9059
+ 'deadband': frame_data.deadband,
9060
+ 'payload_length': frame_data.payload_length,
9061
+ 'fsr': frame_data.fsr_text,
9062
+ 'rpm_compute_status': frame_data.rpm_status,
7608
9063
  'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
7609
- 'auto_raw_interval': frame[32],
9064
+ 'auto_raw_interval': frame_data.auto_raw_interval,
7610
9065
  'smart_mode_skip_count': frame[33],
7611
- 'smart_mode_acc_threshold':frame[34],
7612
- 'uptime_counter': frame.slice(35, 39),
9066
+ 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
9067
+ 'uptime_counter': frame.slice(35, 39).reduce(msbLsb)+'sec',
7613
9068
  'hardware_id': frame.slice(39, 42),
7614
9069
  'reserved': frame.slice(42, 46),
7615
- 'tx_lifetime_counter': frame.slice(46, 50)
9070
+ 'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
9071
+ 'machine_values': {
9072
+ 'firmware': frame[2],
9073
+ 'destination_address': toMac(frame.slice(12, 16), false),
9074
+ 'mode': frame[16],
9075
+ 'odr': frame[17],
9076
+ 'sampling_duration': frame[18],
9077
+ 'filter_status': frame[19],
9078
+ 'lpf_coeff': frame[20],
9079
+ 'hpf_coeff': frame[21],
9080
+ 'sampling_interval': frame[22],
9081
+ 'on_request_timeout': frame[23],
9082
+ 'deadband': frame[24],
9083
+ 'payload_length': frame[25],
9084
+ 'fsr': frame[26],
9085
+ 'rpm_compute_status': frame[27],
9086
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32), false),
9087
+ 'auto_raw_interval': frame[32],
9088
+ 'smart_mode_skip_count': frame[33],
9089
+ 'smart_mode_acc_threshold':frame[34],
9090
+ 'uptime_counter': frame.slice(35, 39),
9091
+ 'hardware_id': frame.slice(39, 42),
9092
+ 'reserved': frame.slice(42, 46),
9093
+ 'tx_lifetime_counter': frame.slice(46, 50)
9094
+ }
7616
9095
  }
7617
9096
  }
7618
9097
  }
@@ -7667,8 +9146,7 @@ function sensor_types(parent){
7667
9146
  return;
7668
9147
  } else{
7669
9148
  var mode = payload[8];
7670
- var odr = msbLsb(payload[9], payload[10])
7671
- var en_axis = payload[11] & 7;
9149
+ var odr = msbLsb(payload[9], payload[10]);
7672
9150
  var fsr = payload[11] >> 5;
7673
9151
  var device_temp = msbLsb(payload[14], payload[15])/100;
7674
9152
 
@@ -7677,7 +9155,6 @@ function sensor_types(parent){
7677
9155
  data: {},
7678
9156
  odr: odr,
7679
9157
  mo: mode,
7680
- en_axis: en_axis,
7681
9158
  fsr: fsr,
7682
9159
  hour: hour,
7683
9160
  minute: minute,
@@ -7693,8 +9170,7 @@ function sensor_types(parent){
7693
9170
  }
7694
9171
  else{
7695
9172
  var mode = payload[8];
7696
- var odr = msbLsb(payload[9], payload[10])
7697
- var en_axis = payload[11] & 7;
9173
+ var odr = msbLsb(payload[9], payload[10]);
7698
9174
  var fsr = payload[11] >> 5;
7699
9175
  var device_temp = msbLsb(payload[14], payload[15])/100;
7700
9176
 
@@ -7703,7 +9179,6 @@ function sensor_types(parent){
7703
9179
  data: {},
7704
9180
  odr: odr,
7705
9181
  mo: mode,
7706
- en_axis: en_axis,
7707
9182
  fsr: fsr,
7708
9183
  hour: hour,
7709
9184
  minute: minute,
@@ -7723,43 +9198,11 @@ function sensor_types(parent){
7723
9198
  var fft_concat = {};
7724
9199
 
7725
9200
  var en_axis_data = {};
7726
- switch (globalDevices[deviceAddr].en_axis){
7727
- case 1:
7728
- en_axis_data.x_offset = 0;
7729
- en_axis_data.increment = 2;
7730
- break;
7731
- case 2:
7732
- en_axis_data.y_offset = 0;
7733
- en_axis_data.increment = 2;
7734
- break;
7735
- case 3:
7736
- en_axis_data.x_offset = 0;
7737
- en_axis_data.y_offset = 2;
7738
- en_axis_data.increment = 4;
7739
- break;
7740
- case 4:
7741
- en_axis_data.z_offset = 0;
7742
- en_axis_data.increment = 2;
7743
- break;
7744
- case 5:
7745
- en_axis_data.x_offset = 0;
7746
- en_axis_data.z_offset = 2;
7747
- en_axis_data.increment = 4;
7748
- break;
7749
- case 6:
7750
- en_axis_data.y_offset = 0;
7751
- en_axis_data.z_offset = 2;
7752
- en_axis_data.increment = 4;
7753
- break;
7754
- case 7:
7755
- en_axis_data.x_offset = 0;
7756
- en_axis_data.y_offset = 2;
7757
- en_axis_data.z_offset = 4;
7758
- en_axis_data.increment = 6;
7759
- break;
7760
- default:
7761
- en_axis_data.increment = 0;
7762
- }
9201
+ en_axis_data.x_offset = 0;
9202
+ en_axis_data.y_offset = 2;
9203
+ en_axis_data.z_offset = 4;
9204
+ en_axis_data.increment = 6;
9205
+ fft_concat = {x: [], y: [], z: []};
7763
9206
 
7764
9207
  var fsr_mult = .00006;
7765
9208
  var fsr_text = "";
@@ -7795,16 +9238,14 @@ function sensor_types(parent){
7795
9238
  for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
7796
9239
  label++;
7797
9240
 
7798
- fft_concat[label] = {};
7799
-
7800
9241
  if('x_offset' in en_axis_data){
7801
- 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));
9242
+ fft_concat.x.push(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)));
7802
9243
  }
7803
9244
  if('y_offset' in en_axis_data){
7804
- 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));
9245
+ fft_concat.y.push(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)));
7805
9246
  }
7806
9247
  if('z_offset' in en_axis_data){
7807
- 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));
9248
+ fft_concat.z.push(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)));
7808
9249
  }
7809
9250
  }
7810
9251
 
@@ -7824,7 +9265,6 @@ function sensor_types(parent){
7824
9265
  time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
7825
9266
  probe: probe,
7826
9267
  mac_address: deviceAddr,
7827
- en_axis: globalDevices[deviceAddr].en_axis,
7828
9268
  fsr: fsr_text,
7829
9269
  odr: globalDevices[deviceAddr].odr,
7830
9270
  device_temp: globalDevices[deviceAddr].device_temp,
@@ -7845,8 +9285,7 @@ function sensor_types(parent){
7845
9285
  }
7846
9286
  }else{
7847
9287
  var mode = payload[8];
7848
- var odr = msbLsb(payload[9], payload[10])
7849
- var en_axis = payload[11] & 7;
9288
+ var odr = msbLsb(payload[9], payload[10]);
7850
9289
  var fsr = payload[11] >> 5;
7851
9290
  var device_temp = msbLsb(payload[14], payload[15])/100;
7852
9291
 
@@ -7855,7 +9294,6 @@ function sensor_types(parent){
7855
9294
  data: {},
7856
9295
  odr: odr,
7857
9296
  mo: mode,
7858
- en_axis: en_axis,
7859
9297
  fsr: fsr,
7860
9298
  hour: hour,
7861
9299
  minute: minute,
@@ -7902,7 +9340,7 @@ function sensor_types(parent){
7902
9340
  break;
7903
9341
  }
7904
9342
  var odr2;
7905
- switch(payload[54]){
9343
+ switch(payload[56]){
7906
9344
  case 6:
7907
9345
  odr2 = "50Hz"
7908
9346
  break;
@@ -7976,32 +9414,32 @@ function sensor_types(parent){
7976
9414
  rpm_1: payload.slice(54, 56).reduce(msbLsb),
7977
9415
 
7978
9416
  s2_odr: odr2,
7979
- s2_temperature: signInt(payload.slice(55, 57).reduce(msbLsb), 16) / 100,
7980
-
7981
- x2_rms_ACC_G: payload.slice(57, 59).reduce(msbLsb)/1000,
7982
- x2_max_ACC_G: payload.slice(59, 61).reduce(msbLsb)/1000,
7983
- x2_velocity_mm_sec: payload.slice(61, 63).reduce(msbLsb) / 100,
7984
- x2_displacement_mm: payload.slice(63, 65).reduce(msbLsb) / 100,
7985
- x2_peak_one_Hz: payload.slice(65, 67).reduce(msbLsb),
7986
- x2_peak_two_Hz: payload.slice(67, 69).reduce(msbLsb),
7987
- x2_peak_three_Hz: payload.slice(69, 71).reduce(msbLsb),
7988
-
7989
- y2_rms_ACC_G: payload.slice(71, 73).reduce(msbLsb)/1000,
7990
- y2_max_ACC_G: payload.slice(73, 75).reduce(msbLsb)/1000,
7991
- y2_velocity_mm_sec: payload.slice(75, 77).reduce(msbLsb) / 100,
7992
- y2_displacement_mm: payload.slice(77, 79).reduce(msbLsb) / 100,
7993
- y2_peak_one_Hz: payload.slice(79, 81).reduce(msbLsb),
7994
- y2_peak_two_Hz: payload.slice(81, 83).reduce(msbLsb),
7995
- y2_peak_three_Hz: payload.slice(83, 85).reduce(msbLsb),
7996
-
7997
- z2_rms_ACC_G: payload.slice(85, 87).reduce(msbLsb)/1000,
7998
- z2_max_ACC_G: payload.slice(87, 89).reduce(msbLsb)/1000,
7999
- z2_velocity_mm_sec: payload.slice(89, 91).reduce(msbLsb) / 100,
8000
- z2_displacement_mm: payload.slice(91, 93).reduce(msbLsb) / 100,
8001
- z2_peak_one_Hz: payload.slice(93, 95).reduce(msbLsb),
8002
- z2_peak_two_Hz: payload.slice(95, 97).reduce(msbLsb),
8003
- z2_peak_three_Hz: payload.slice(97, 99).reduce(msbLsb),
8004
- rpm_2: payload.slice(99, 101).reduce(msbLsb)
9417
+ s2_temperature: signInt(payload.slice(57, 59).reduce(msbLsb), 16) / 100,
9418
+
9419
+ x2_rms_ACC_G: payload.slice(59, 61).reduce(msbLsb)/1000,
9420
+ x2_max_ACC_G: payload.slice(61, 63).reduce(msbLsb)/1000,
9421
+ x2_velocity_mm_sec: payload.slice(63, 65).reduce(msbLsb) / 100,
9422
+ x2_displacement_mm: payload.slice(65, 67).reduce(msbLsb) / 100,
9423
+ x2_peak_one_Hz: payload.slice(67, 69).reduce(msbLsb),
9424
+ x2_peak_two_Hz: payload.slice(69, 71).reduce(msbLsb),
9425
+ x2_peak_three_Hz: payload.slice(71, 73).reduce(msbLsb),
9426
+
9427
+ y2_rms_ACC_G: payload.slice(73, 75).reduce(msbLsb)/1000,
9428
+ y2_max_ACC_G: payload.slice(75, 77).reduce(msbLsb)/1000,
9429
+ y2_velocity_mm_sec: payload.slice(77, 79).reduce(msbLsb) / 100,
9430
+ y2_displacement_mm: payload.slice(79, 81).reduce(msbLsb) / 100,
9431
+ y2_peak_one_Hz: payload.slice(81, 83).reduce(msbLsb),
9432
+ y2_peak_two_Hz: payload.slice(83, 85).reduce(msbLsb),
9433
+ y2_peak_three_Hz: payload.slice(85, 87).reduce(msbLsb),
9434
+
9435
+ z2_rms_ACC_G: payload.slice(87, 89).reduce(msbLsb)/1000,
9436
+ z2_max_ACC_G: payload.slice(89, 91).reduce(msbLsb)/1000,
9437
+ z2_velocity_mm_sec: payload.slice(91, 93).reduce(msbLsb) / 100,
9438
+ z2_displacement_mm: payload.slice(93, 95).reduce(msbLsb) / 100,
9439
+ z2_peak_one_Hz: payload.slice(95, 97).reduce(msbLsb),
9440
+ z2_peak_two_Hz: payload.slice(97, 99).reduce(msbLsb),
9441
+ z2_peak_three_Hz: payload.slice(99, 101).reduce(msbLsb),
9442
+ rpm_2: payload.slice(101, 103).reduce(msbLsb)
8005
9443
  };
8006
9444
  }
8007
9445
  // else{
@@ -8286,87 +9724,156 @@ function sensor_types(parent){
8286
9724
  frame_data.payload_length = "180 Bytes";
8287
9725
  break;
8288
9726
  }
8289
- switch(frame[30]){
8290
- case 0:
8291
- frame_data.fsr_text = "2g";
8292
- break;
8293
- case 1:
8294
- frame_data.fsr_text = "4g";
8295
- break;
8296
- case 2:
8297
- frame_data.fsr_text = "8g";
8298
- break;
8299
- case 3:
8300
- frame_data.fsr_text = "16g";
8301
- break;
8302
- }
8303
- frame_data.rpm_status = frame[31]? 'Enabled': 'Disabled';
8304
- frame_data.auto_raw_interval = frame[36] * frame_data.sampling_interval_number || 'disabled';
8305
- frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
8306
- frame_data.p1_smart_mode_threshold = frame[38] * 50;
8307
- frame_data.p2_smart_mode_threshold = frame[39] * 50;
8308
- return {
8309
- 'firmware': frame[2],
8310
- 'destination_address': toMac(frame.slice(12, 16)),
8311
- 'mode': frame_data.mode,
8312
- 'odr_1': frame_data.odr_1+'Hz',
8313
- 'odr_2': frame_data.odr_2+'Hz',
8314
- 'sampling_duration_1': frame_data.sampling_duration_1,
8315
- 'sampling_duration_2': frame_data.sampling_duration_2,
8316
- 'filter_status': frame_data.filter_status,
8317
- 'lpf_coeff_1': frame_data.lpf_coeff_1,
8318
- 'lpf_freq_1': frame_data.lpf_freq_1+'Hz',
8319
- 'lpf_coeff_2': frame_data.lpf_coeff_2,
8320
- 'lpf_freq_2': frame_data.lpf_freq_2+'Hz',
8321
- 'hpf_coeff_1': frame_data.hpf_coeff_1,
8322
- 'hpf_freq_1': frame_data.hpf_freq_1+'Hz',
8323
- 'hpf_coeff_2': frame_data.hpf_coeff_2,
8324
- 'hpf_freq_2': frame_data.hpf_freq_2+'Hz',
8325
- 'sampling_interval': frame_data.sampling_interval,
8326
- 'on_request_timeout': frame_data.on_request_timeout,
8327
- 'deadband': frame_data.deadband,
8328
- 'payload_length': frame_data.payload_length,
8329
- 'fsr': frame_data.fsr_text,
8330
- 'rpm_compute_status': frame_data.rpm_status,
8331
- 'auto_raw_destination_address': toMac(frame.slice(32 , 36)),
8332
- 'auto_raw_interval': frame_data.auto_raw_interval,
8333
- 'smart_mode_skip_count': frame[37],
8334
- 'smart_mode_acc_threshold_probe_1': frame_data.p1_smart_mode_threshold+'mg',
8335
- 'smart_mode_acc_threshold_probe_2': frame_data.p2_smart_mode_threshold+'mg',
8336
- 'uptime_counter_probe_1': frame.slice(40, 44).reduce(msbLsb),
8337
- 'uptime_counter_probe_2': frame.slice(44, 48).reduce(msbLsb),
8338
- 'hardware_id': frame.slice(48, 51),
8339
- 'reserved': frame.slice(51, 55),
8340
- 'tx_lifetime_counter': frame.slice(55, 59).reduce(msbLsb),
8341
- 'machine_values': {
9727
+ switch(frame[30]){
9728
+ case 0:
9729
+ frame_data.fsr_text = "2g";
9730
+ break;
9731
+ case 1:
9732
+ frame_data.fsr_text = "4g";
9733
+ break;
9734
+ case 2:
9735
+ frame_data.fsr_text = "8g";
9736
+ break;
9737
+ case 3:
9738
+ frame_data.fsr_text = "16g";
9739
+ break;
9740
+ }
9741
+ frame_data.rpm_status = frame[31]? 'Enabled': 'Disabled';
9742
+ frame_data.auto_raw_interval = frame[36] * frame_data.sampling_interval_number || 'disabled';
9743
+ frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
9744
+ frame_data.p1_smart_mode_threshold = frame[38] * 50;
9745
+ frame_data.p2_smart_mode_threshold = frame[39] * 50;
9746
+ if(frame[2] > 4){ // for Firmware v5 and above
9747
+ return {
8342
9748
  'firmware': frame[2],
8343
- 'destination_address': toMac(frame.slice(12, 16), false),
8344
- 'mode': frame[16],
8345
- 'odr_1': frame[17],
8346
- 'odr_2': frame[18],
8347
- 'sampling_duration_1': frame[19],
8348
- 'sampling_duration_2': frame[20],
8349
- 'filter_status': frame[21],
8350
- 'lpf_coeff_1': frame[22],
8351
- 'lpf_coeff_2': frame[23],
8352
- 'hpf_coeff_1': frame[24],
8353
- 'hpf_coeff_2': frame[25],
8354
- 'sampling_interval': frame[26],
8355
- 'on_request_timeout': frame[27],
8356
- 'deadband': frame[28],
8357
- 'payload_length': frame[29],
8358
- 'fsm': frame[30],
8359
- 'rpm_compute_status': frame[31],
9749
+ 'destination_address': toMac(frame.slice(12, 16)),
9750
+ 'mode': frame_data.mode,
9751
+ 'odr_1': frame_data.odr_1+'Hz',
9752
+ 'odr_2': frame_data.odr_2+'Hz',
9753
+ 'sampling_duration_1': frame_data.sampling_duration_1,
9754
+ 'sampling_duration_2': frame_data.sampling_duration_2,
9755
+ 'filter_status': frame_data.filter_status,
9756
+ 'lpf_coeff_1': frame_data.lpf_coeff_1,
9757
+ 'lpf_freq_1': frame_data.lpf_freq_1+'Hz',
9758
+ 'lpf_coeff_2': frame_data.lpf_coeff_2,
9759
+ 'lpf_freq_2': frame_data.lpf_freq_2+'Hz',
9760
+ 'hpf_coeff_1': frame_data.hpf_coeff_1,
9761
+ 'hpf_freq_1': frame_data.hpf_freq_1+'Hz',
9762
+ 'hpf_coeff_2': frame_data.hpf_coeff_2,
9763
+ 'hpf_freq_2': frame_data.hpf_freq_2+'Hz',
9764
+ 'sampling_interval': frame_data.sampling_interval,
9765
+ 'on_request_timeout': frame_data.on_request_timeout,
9766
+ 'deadband': frame_data.deadband,
9767
+ 'payload_length': frame_data.payload_length,
9768
+ 'fsr': frame_data.fsr_text,
9769
+ 'rpm_compute_status': frame_data.rpm_status,
9770
+ 'auto_raw_destination_address': toMac(frame.slice(32 , 36)),
9771
+ 'auto_raw_interval': frame_data.auto_raw_interval,
9772
+ 'smart_mode_skip_count': frame[37],
9773
+ 'smart_mode_acc_threshold_probe_1': frame_data.p1_smart_mode_threshold+'mg',
9774
+ 'smart_mode_acc_threshold_probe_2': frame_data.p2_smart_mode_threshold+'mg',
9775
+ 'uptime_counter_probe_1': frame.slice(40, 44).reduce(msbLsb)+'sec',
9776
+ 'uptime_counter_probe_2': frame.slice(44, 48).reduce(msbLsb)+'sec',
9777
+ 'max_tx_raw_samples': frame.slice(48, 50).reduce(msbLsb),
9778
+ 'hardware_id': frame.slice(50, 53),
9779
+ 'reserved': frame.slice(53, 57),
9780
+ 'tx_lifetime_counter': frame.slice(57, 61).reduce(msbLsb),
9781
+ 'machine_values': {
9782
+ 'firmware': frame[2],
9783
+ 'destination_address': toMac(frame.slice(12, 16), false),
9784
+ 'mode': frame[16],
9785
+ 'odr_1': frame[17],
9786
+ 'odr_2': frame[18],
9787
+ 'sampling_duration_1': frame[19],
9788
+ 'sampling_duration_2': frame[20],
9789
+ 'filter_status': frame[21],
9790
+ 'lpf_coeff_1': frame[22],
9791
+ 'lpf_coeff_2': frame[23],
9792
+ 'hpf_coeff_1': frame[24],
9793
+ 'hpf_coeff_2': frame[25],
9794
+ 'sampling_interval': frame[26],
9795
+ 'on_request_timeout': frame[27],
9796
+ 'deadband': frame[28],
9797
+ 'payload_length': frame[29],
9798
+ 'fsm': frame[30],
9799
+ 'rpm_compute_status': frame[31],
9800
+ 'auto_raw_destination_address': toMac(frame.slice(32 , 36), false),
9801
+ 'auto_raw_interval': frame[36],
9802
+ 'smart_mode_skip_count': frame[37],
9803
+ 'smart_mode_acc_threshold_probe_1':frame[38],
9804
+ 'smart_mode_acc_threshold_probe_2':frame[39],
9805
+ 'uptime_counter_probe_1': frame.slice(40, 44),
9806
+ 'uptime_counter_probe_2': frame.slice(44, 48),
9807
+ 'max_tx_raw_samples': frame.slice(48, 50),
9808
+ 'hardware_id': frame.slice(50, 53),
9809
+ 'reserved': frame.slice(53, 57),
9810
+ 'tx_lifetime_counter': frame.slice(57, 61)
9811
+ }
9812
+ }
9813
+ }else{
9814
+ return {
9815
+ 'firmware': frame[2],
9816
+ 'destination_address': toMac(frame.slice(12, 16)),
9817
+ 'mode': frame_data.mode,
9818
+ 'odr_1': frame_data.odr_1+'Hz',
9819
+ 'odr_2': frame_data.odr_2+'Hz',
9820
+ 'sampling_duration_1': frame_data.sampling_duration_1,
9821
+ 'sampling_duration_2': frame_data.sampling_duration_2,
9822
+ 'filter_status': frame_data.filter_status,
9823
+ 'lpf_coeff_1': frame_data.lpf_coeff_1,
9824
+ 'lpf_freq_1': frame_data.lpf_freq_1+'Hz',
9825
+ 'lpf_coeff_2': frame_data.lpf_coeff_2,
9826
+ 'lpf_freq_2': frame_data.lpf_freq_2+'Hz',
9827
+ 'hpf_coeff_1': frame_data.hpf_coeff_1,
9828
+ 'hpf_freq_1': frame_data.hpf_freq_1+'Hz',
9829
+ 'hpf_coeff_2': frame_data.hpf_coeff_2,
9830
+ 'hpf_freq_2': frame_data.hpf_freq_2+'Hz',
9831
+ 'sampling_interval': frame_data.sampling_interval,
9832
+ 'on_request_timeout': frame_data.on_request_timeout,
9833
+ 'deadband': frame_data.deadband,
9834
+ 'payload_length': frame_data.payload_length,
9835
+ 'fsr': frame_data.fsr_text,
9836
+ 'rpm_compute_status': frame_data.rpm_status,
8360
9837
  'auto_raw_destination_address': toMac(frame.slice(32 , 36)),
8361
- 'auto_raw_interval': frame[36],
9838
+ 'auto_raw_interval': frame_data.auto_raw_interval,
8362
9839
  'smart_mode_skip_count': frame[37],
8363
- 'smart_mode_acc_threshold_probe_1':frame[38],
8364
- 'smart_mode_acc_threshold_probe_2':frame[39],
8365
- 'uptime_counter_probe_1': frame.slice(40, 44),
8366
- 'uptime_counter_probe_2': frame.slice(44, 48),
9840
+ 'smart_mode_acc_threshold_probe_1': frame_data.p1_smart_mode_threshold+'mg',
9841
+ 'smart_mode_acc_threshold_probe_2': frame_data.p2_smart_mode_threshold+'mg',
9842
+ 'uptime_counter_probe_1': frame.slice(40, 44).reduce(msbLsb)+'sec',
9843
+ 'uptime_counter_probe_2': frame.slice(44, 48).reduce(msbLsb)+'sec',
8367
9844
  'hardware_id': frame.slice(48, 51),
8368
9845
  'reserved': frame.slice(51, 55),
8369
- 'tx_lifetime_counter': frame.slice(55, 59).reduce(msbLsb)
9846
+ 'tx_lifetime_counter': frame.slice(55, 59).reduce(msbLsb),
9847
+ 'machine_values': {
9848
+ 'firmware': frame[2],
9849
+ 'destination_address': toMac(frame.slice(12, 16), false),
9850
+ 'mode': frame[16],
9851
+ 'odr_1': frame[17],
9852
+ 'odr_2': frame[18],
9853
+ 'sampling_duration_1': frame[19],
9854
+ 'sampling_duration_2': frame[20],
9855
+ 'filter_status': frame[21],
9856
+ 'lpf_coeff_1': frame[22],
9857
+ 'lpf_coeff_2': frame[23],
9858
+ 'hpf_coeff_1': frame[24],
9859
+ 'hpf_coeff_2': frame[25],
9860
+ 'sampling_interval': frame[26],
9861
+ 'on_request_timeout': frame[27],
9862
+ 'deadband': frame[28],
9863
+ 'payload_length': frame[29],
9864
+ 'fsm': frame[30],
9865
+ 'rpm_compute_status': frame[31],
9866
+ 'auto_raw_destination_address': toMac(frame.slice(32 , 36), false),
9867
+ 'auto_raw_interval': frame[36],
9868
+ 'smart_mode_skip_count': frame[37],
9869
+ 'smart_mode_acc_threshold_probe_1':frame[38],
9870
+ 'smart_mode_acc_threshold_probe_2':frame[39],
9871
+ 'uptime_counter_probe_1': frame.slice(40, 44),
9872
+ 'uptime_counter_probe_2': frame.slice(44, 48),
9873
+ 'hardware_id': frame.slice(48, 51),
9874
+ 'reserved': frame.slice(51, 55),
9875
+ 'tx_lifetime_counter': frame.slice(55, 59)
9876
+ }
8370
9877
  }
8371
9878
  }
8372
9879
  }
@@ -8418,8 +9925,7 @@ function sensor_types(parent){
8418
9925
  } else{
8419
9926
 
8420
9927
  var mode = payload[8];
8421
- var odr = msbLsb(payload[9], payload[10])
8422
- var en_axis = payload[11] & 7;
9928
+ var odr = msbLsb(payload[9], payload[10]);
8423
9929
  var fsr = payload[11] >> 5;
8424
9930
  var device_temp = msbLsb(payload[14], payload[15])/100;
8425
9931
 
@@ -8428,7 +9934,6 @@ function sensor_types(parent){
8428
9934
  data: {},
8429
9935
  odr: odr,
8430
9936
  mo: mode,
8431
- en_axis: en_axis,
8432
9937
  fsr: fsr,
8433
9938
  hour: hour,
8434
9939
  minute: minute,
@@ -8444,8 +9949,7 @@ function sensor_types(parent){
8444
9949
  }
8445
9950
  else{
8446
9951
  var mode = payload[8];
8447
- var odr = msbLsb(payload[9], payload[10])
8448
- var en_axis = payload[11] & 7;
9952
+ var odr = msbLsb(payload[9], payload[10]);
8449
9953
  var fsr = payload[11] >> 5;
8450
9954
  var device_temp = msbLsb(payload[14], payload[15])/100;
8451
9955
 
@@ -8454,7 +9958,6 @@ function sensor_types(parent){
8454
9958
  data: {},
8455
9959
  odr: odr,
8456
9960
  mo: mode,
8457
- en_axis: en_axis,
8458
9961
  fsr: fsr,
8459
9962
  hour: hour,
8460
9963
  minute: minute,
@@ -8473,43 +9976,11 @@ function sensor_types(parent){
8473
9976
  var fft_concat = {};
8474
9977
 
8475
9978
  var en_axis_data = {};
8476
- switch (globalDevices[deviceAddr].en_axis){
8477
- case 1:
8478
- en_axis_data.x_offset = 0;
8479
- en_axis_data.increment = 2;
8480
- break;
8481
- case 2:
8482
- en_axis_data.y_offset = 0;
8483
- en_axis_data.increment = 2;
8484
- break;
8485
- case 3:
8486
- en_axis_data.x_offset = 0;
8487
- en_axis_data.y_offset = 2;
8488
- en_axis_data.increment = 4;
8489
- break;
8490
- case 4:
8491
- en_axis_data.z_offset = 0;
8492
- en_axis_data.increment = 2;
8493
- break;
8494
- case 5:
8495
- en_axis_data.x_offset = 0;
8496
- en_axis_data.z_offset = 2;
8497
- en_axis_data.increment = 4;
8498
- break;
8499
- case 6:
8500
- en_axis_data.y_offset = 0;
8501
- en_axis_data.z_offset = 2;
8502
- en_axis_data.increment = 4;
8503
- break;
8504
- case 7:
8505
- en_axis_data.x_offset = 0;
8506
- en_axis_data.y_offset = 2;
8507
- en_axis_data.z_offset = 4;
8508
- en_axis_data.increment = 6;
8509
- break;
8510
- default:
8511
- en_axis_data.increment = 0;
8512
- }
9979
+ en_axis_data.x_offset = 0;
9980
+ en_axis_data.y_offset = 2;
9981
+ en_axis_data.z_offset = 4;
9982
+ en_axis_data.increment = 6;
9983
+ fft_concat = {x: [], y: [], z: []};
8513
9984
 
8514
9985
  var fsr_mult = .00006;
8515
9986
  var fsr_text = "";
@@ -8545,16 +10016,14 @@ function sensor_types(parent){
8545
10016
  for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
8546
10017
  label++;
8547
10018
 
8548
- fft_concat[label] = {};
8549
-
8550
10019
  if('x_offset' in en_axis_data){
8551
- 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));
10020
+ fft_concat.x.push(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)));
8552
10021
  }
8553
10022
  if('y_offset' in en_axis_data){
8554
- 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));
10023
+ fft_concat.y.push(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)));
8555
10024
  }
8556
10025
  if('z_offset' in en_axis_data){
8557
- 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));
10026
+ fft_concat.z.push(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)));
8558
10027
  }
8559
10028
  }
8560
10029
  var fft_concat_obj = {
@@ -8562,7 +10031,6 @@ function sensor_types(parent){
8562
10031
  msg_type: msg_type,
8563
10032
  time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
8564
10033
  mac_address: deviceAddr,
8565
- en_axis: globalDevices[deviceAddr].en_axis,
8566
10034
  fsr: fsr_text,
8567
10035
  odr: globalDevices[deviceAddr].odr,
8568
10036
  device_temp: globalDevices[deviceAddr].device_temp,
@@ -8588,8 +10056,7 @@ function sensor_types(parent){
8588
10056
  }else{
8589
10057
 
8590
10058
  var mode = payload[8];
8591
- var odr = msbLsb(payload[9], payload[10])
8592
- var en_axis = payload[11] & 7;
10059
+ var odr = msbLsb(payload[9], payload[10]);
8593
10060
  var fsr = payload[11] >> 5;
8594
10061
  var device_temp = msbLsb(payload[14], payload[15])/100;
8595
10062
 
@@ -8598,7 +10065,6 @@ function sensor_types(parent){
8598
10065
  data: {},
8599
10066
  odr: odr,
8600
10067
  mo: mode,
8601
- en_axis: en_axis,
8602
10068
  fsr: fsr,
8603
10069
  hour: hour,
8604
10070
  minute: minute,
@@ -8879,54 +10345,109 @@ function sensor_types(parent){
8879
10345
  frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
8880
10346
  frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
8881
10347
  frame_data.smart_mode_threshold = frame[34] * 50;
8882
- return {
8883
- 'firmware': frame[2],
8884
- 'destination_address': toMac(frame.slice(12, 16)),
8885
- 'mode': frame_data.mode,
8886
- 'odr': frame_data.odr_1+'Hz',
8887
- 'sampling_duration': frame_data.sampling_duration_1,
8888
- 'filter_status': frame_data.filter_status,
8889
- 'lpf_coeff': frame_data.lpf_coeff_1,
8890
- 'lpf_freq': frame_data.lpf_freq_1+'Hz',
8891
- 'hpf_coeff': frame_data.hpf_coeff_1,
8892
- 'hpf_freq': frame_data.hpf_freq_1+'Hz',
8893
- 'sampling_interval': frame_data.sampling_interval,
8894
- 'on_request_timeout': frame_data.on_request_timeout,
8895
- 'deadband': frame_data.deadband,
8896
- 'payload_length': frame_data.payload_length,
8897
- 'fsr': frame_data.fsr_text,
8898
- 'rpm_compute_status': frame_data.rpm_status,
8899
- 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
8900
- 'auto_raw_interval': frame_data.auto_raw_interval,
8901
- 'smart_mode_skip_count': frame[33],
8902
- 'smart_mode_acc_threshold': frame_data.smart_mode_threshold+'mg',
8903
- 'uptime_counter': frame.slice(35, 39).reduce(msbLsb),
8904
- 'hardware_id': frame.slice(39, 42),
8905
- 'reserved': frame.slice(42, 46),
8906
- 'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
8907
- 'machine_values': {
10348
+ if(frame[2] > 4){ // for Firmware v5 and above
10349
+ return {
8908
10350
  'firmware': frame[2],
8909
- 'destination_address': toMac(frame.slice(12, 16), false),
8910
- 'mode': frame[16],
8911
- 'odr': frame[17],
8912
- 'sampling_duration_1': frame[18],
8913
- 'filter_status': frame[19],
8914
- 'lpf_coeff': frame[20],
8915
- 'hpf_coeff': frame[21],
8916
- 'sampling_interval': frame[22],
8917
- 'on_request_timeout': frame[23],
8918
- 'deadband': frame[24],
8919
- 'payload_length': frame[25],
8920
- 'fsm': frame[26],
8921
- 'rpm_compute_status': frame[27],
10351
+ 'destination_address': toMac(frame.slice(12, 16)),
10352
+ 'mode': frame_data.mode,
10353
+ 'odr': frame_data.odr_1+'Hz',
10354
+ 'sampling_duration': frame_data.sampling_duration_1,
10355
+ 'filter_status': frame_data.filter_status,
10356
+ 'lpf_coeff': frame_data.lpf_coeff_1,
10357
+ 'lpf_freq': frame_data.lpf_freq_1+'Hz',
10358
+ 'hpf_coeff': frame_data.hpf_coeff_1,
10359
+ 'hpf_freq': frame_data.hpf_freq_1+'Hz',
10360
+ 'sampling_interval': frame_data.sampling_interval,
10361
+ 'on_request_timeout': frame_data.on_request_timeout,
10362
+ 'deadband': frame_data.deadband,
10363
+ 'payload_length': frame_data.payload_length,
10364
+ 'fsr': frame_data.fsr_text,
10365
+ 'rpm_compute_status': frame_data.rpm_status,
10366
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
10367
+ 'auto_raw_interval': frame_data.auto_raw_interval,
10368
+ 'smart_mode_skip_count': frame[33],
10369
+ 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
10370
+ 'uptime_counter': frame.slice(35, 39).reduce(msbLsb)+'sec',
10371
+ 'max_tx_raw_samples': frame.slice(39, 41).reduce(msbLsb),
10372
+ 'hardware_id': frame.slice(41, 44),
10373
+ 'reserved': frame.slice(44, 48),
10374
+ 'tx_lifetime_counter': frame.slice(48, 52).reduce(msbLsb),
10375
+ 'machine_values': {
10376
+ 'firmware': frame[2],
10377
+ 'destination_address': toMac(frame.slice(12, 16), false),
10378
+ 'mode': frame[16],
10379
+ 'odr': frame[17],
10380
+ 'sampling_duration': frame[18],
10381
+ 'filter_status': frame[19],
10382
+ 'lpf_coeff': frame[20],
10383
+ 'hpf_coeff': frame[21],
10384
+ 'sampling_interval': frame[22],
10385
+ 'on_request_timeout': frame[23],
10386
+ 'deadband': frame[24],
10387
+ 'payload_length': frame[25],
10388
+ 'fsr': frame[26],
10389
+ 'rpm_compute_status': frame[27],
10390
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32), false),
10391
+ 'auto_raw_interval': frame[32],
10392
+ 'smart_mode_skip_count': frame[33],
10393
+ 'smart_mode_acc_threshold':frame[34],
10394
+ 'uptime_counter': frame.slice(35, 39),
10395
+ 'max_tx_raw_samples': frame.slice(39, 41),
10396
+ 'hardware_id': frame.slice(41, 44),
10397
+ 'reserved': frame.slice(44, 48),
10398
+ 'tx_lifetime_counter': frame.slice(48, 52)
10399
+ }
10400
+ }
10401
+ }else{
10402
+ return {
10403
+ 'firmware': frame[2],
10404
+ 'destination_address': toMac(frame.slice(12, 16)),
10405
+ 'mode': frame_data.mode,
10406
+ 'odr': frame_data.odr_1+'Hz',
10407
+ 'sampling_duration': frame_data.sampling_duration_1,
10408
+ 'filter_status': frame_data.filter_status,
10409
+ 'lpf_coeff': frame_data.lpf_coeff_1,
10410
+ 'lpf_freq': frame_data.lpf_freq_1+'Hz',
10411
+ 'hpf_coeff': frame_data.hpf_coeff_1,
10412
+ 'hpf_freq': frame_data.hpf_freq_1+'Hz',
10413
+ 'sampling_interval': frame_data.sampling_interval,
10414
+ 'on_request_timeout': frame_data.on_request_timeout,
10415
+ 'deadband': frame_data.deadband,
10416
+ 'payload_length': frame_data.payload_length,
10417
+ 'fsr': frame_data.fsr_text,
10418
+ 'rpm_compute_status': frame_data.rpm_status,
8922
10419
  'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
8923
- 'auto_raw_interval': frame[32],
10420
+ 'auto_raw_interval': frame_data.auto_raw_interval,
8924
10421
  'smart_mode_skip_count': frame[33],
8925
- 'smart_mode_acc_threshold':frame[34],
8926
- 'uptime_counter': frame.slice(35, 39),
10422
+ 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
10423
+ 'uptime_counter': frame.slice(35, 39).reduce(msbLsb)+'sec',
8927
10424
  'hardware_id': frame.slice(39, 42),
8928
10425
  'reserved': frame.slice(42, 46),
8929
- 'tx_lifetime_counter': frame.slice(46, 50)
10426
+ 'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
10427
+ 'machine_values': {
10428
+ 'firmware': frame[2],
10429
+ 'destination_address': toMac(frame.slice(12, 16), false),
10430
+ 'mode': frame[16],
10431
+ 'odr': frame[17],
10432
+ 'sampling_duration': frame[18],
10433
+ 'filter_status': frame[19],
10434
+ 'lpf_coeff': frame[20],
10435
+ 'hpf_coeff': frame[21],
10436
+ 'sampling_interval': frame[22],
10437
+ 'on_request_timeout': frame[23],
10438
+ 'deadband': frame[24],
10439
+ 'payload_length': frame[25],
10440
+ 'fsr': frame[26],
10441
+ 'rpm_compute_status': frame[27],
10442
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32), false),
10443
+ 'auto_raw_interval': frame[32],
10444
+ 'smart_mode_skip_count': frame[33],
10445
+ 'smart_mode_acc_threshold':frame[34],
10446
+ 'uptime_counter': frame.slice(35, 39),
10447
+ 'hardware_id': frame.slice(39, 42),
10448
+ 'reserved': frame.slice(42, 46),
10449
+ 'tx_lifetime_counter': frame.slice(46, 50)
10450
+ }
8930
10451
  }
8931
10452
  }
8932
10453
  }
@@ -8962,8 +10483,7 @@ function sensor_types(parent){
8962
10483
  delete globalDevices[deviceAddr];
8963
10484
  // create new stream
8964
10485
  var mode = payload[8];
8965
- var odr = msbLsb(payload[9], payload[10])
8966
- var en_axis = payload[11] & 7;
10486
+ var odr = msbLsb(payload[9], payload[10]);
8967
10487
  var fsr = payload[11] >> 5;
8968
10488
  var device_temp = msbLsb(payload[14], payload[15])/100;
8969
10489
 
@@ -8971,7 +10491,6 @@ function sensor_types(parent){
8971
10491
  data: {},
8972
10492
  odr: odr,
8973
10493
  mo: mode,
8974
- en_axis: en_axis,
8975
10494
  fsr: fsr,
8976
10495
  hour: hour,
8977
10496
  minute: minute,
@@ -8988,8 +10507,7 @@ function sensor_types(parent){
8988
10507
  }
8989
10508
  else{
8990
10509
  var mode = payload[8];
8991
- var odr = msbLsb(payload[9], payload[10])
8992
- var en_axis = payload[11] & 7;
10510
+ var odr = msbLsb(payload[9], payload[10]);
8993
10511
  var fsr = payload[11] >> 5;
8994
10512
  var device_temp = msbLsb(payload[14], payload[15])/100;
8995
10513
 
@@ -8997,7 +10515,6 @@ function sensor_types(parent){
8997
10515
  data: {},
8998
10516
  odr: odr,
8999
10517
  mo: mode,
9000
- en_axis: en_axis,
9001
10518
  fsr: fsr,
9002
10519
  hour: hour,
9003
10520
  minute: minute,
@@ -9009,8 +10526,7 @@ function sensor_types(parent){
9009
10526
  }
9010
10527
  else{
9011
10528
  var mode = payload[8];
9012
- var odr = msbLsb(payload[9], payload[10])
9013
- var en_axis = payload[11] & 7;
10529
+ var odr = msbLsb(payload[9], payload[10]);
9014
10530
  var fsr = payload[11] >> 5;
9015
10531
  var device_temp = msbLsb(payload[14], payload[15])/100;
9016
10532
 
@@ -9018,7 +10534,6 @@ function sensor_types(parent){
9018
10534
  data: {},
9019
10535
  odr: odr,
9020
10536
  mo: mode,
9021
- en_axis: en_axis,
9022
10537
  fsr: fsr,
9023
10538
  hour: hour,
9024
10539
  minute: minute,
@@ -9038,44 +10553,12 @@ function sensor_types(parent){
9038
10553
  var fft_concat = {};
9039
10554
 
9040
10555
  var en_axis_data = {};
9041
- switch (globalDevices[deviceAddr].en_axis){
9042
- case 1:
9043
- en_axis_data.x_offset = 0;
9044
- en_axis_data.increment = 2;
9045
- break;
9046
- case 2:
9047
- en_axis_data.y_offset = 0;
9048
- en_axis_data.increment = 2;
9049
- break;
9050
- case 3:
9051
- en_axis_data.x_offset = 0;
9052
- en_axis_data.y_offset = 2;
9053
- en_axis_data.increment = 4;
9054
- break;
9055
- case 4:
9056
- en_axis_data.z_offset = 0;
9057
- en_axis_data.increment = 2;
9058
- break;
9059
- case 5:
9060
- en_axis_data.x_offset = 0;
9061
- en_axis_data.z_offset = 2;
9062
- en_axis_data.increment = 4;
9063
- break;
9064
- case 6:
9065
- en_axis_data.y_offset = 0;
9066
- en_axis_data.z_offset = 2;
9067
- en_axis_data.increment = 4;
9068
- break;
9069
- case 7:
9070
- en_axis_data.x_offset = 0;
9071
- en_axis_data.y_offset = 2;
9072
- en_axis_data.z_offset = 4;
9073
- en_axis_data.increment = 6;
9074
- break;
9075
- default:
9076
- en_axis_data.increment = 0;
9077
- }
9078
-
10556
+ en_axis_data.x_offset = 0;
10557
+ en_axis_data.y_offset = 2;
10558
+ en_axis_data.z_offset = 4;
10559
+ en_axis_data.increment = 6;
10560
+ fft_concat = {x: [], y: [], z: []};
10561
+
9079
10562
  var fsr_mult = .00006;
9080
10563
  var fsr_text = "";
9081
10564
 
@@ -9111,16 +10594,14 @@ function sensor_types(parent){
9111
10594
  for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
9112
10595
  label++;
9113
10596
 
9114
- fft_concat[label] = {};
9115
-
9116
10597
  if('x_offset' in en_axis_data){
9117
- 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));
10598
+ fft_concat.x.push(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)));
9118
10599
  }
9119
10600
  if('y_offset' in en_axis_data){
9120
- 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));
10601
+ fft_concat.y.push(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)));
9121
10602
  }
9122
10603
  if('z_offset' in en_axis_data){
9123
- 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));
10604
+ fft_concat.z.push(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)));
9124
10605
  }
9125
10606
  }
9126
10607
  var fft_concat_obj = {
@@ -9128,12 +10609,11 @@ function sensor_types(parent){
9128
10609
  msg_type: msg_type,
9129
10610
  time_id: globalDevices[deviceAddr].hour +':'+ globalDevices[deviceAddr].minute,
9130
10611
  mac_address: deviceAddr,
9131
- en_axis: globalDevices[deviceAddr].en_axis,
9132
10612
  fsr: fsr_text,
9133
10613
  odr: globalDevices[deviceAddr].odr,
9134
10614
  device_temp: globalDevices[deviceAddr].device_temp,
9135
10615
  total_samples: label,
9136
- ft_confidence : ((globalDevices[deviceAddr].counter / expected_packets) * 100).toFixed(2) + '%',
10616
+ fft_confidence : ((Object.keys(globalDevices[deviceAddr].data).length / expected_packets) * 100).toFixed(2) + '%',
9137
10617
  data: fft_concat
9138
10618
  };
9139
10619
  sensor_data = fft_concat_obj;
@@ -9382,86 +10862,386 @@ function sensor_types(parent){
9382
10862
  frame_data.on_request_timeout = frame[23] + " Seconds";
9383
10863
  frame_data.deadband = frame[24] + "mg";
9384
10864
 
9385
- switch(frame[25]){
9386
- case 0:
9387
- frame_data.payload_length = "50 Bytes";
9388
- break;
9389
- case 1:
9390
- frame_data.payload_length = "100 Bytes";
9391
- break;
9392
- case 2:
9393
- frame_data.payload_length = "150 Bytes";
9394
- break;
9395
- case 3:
9396
- frame_data.payload_length = "180 Bytes";
9397
- break;
10865
+ switch(frame[25]){
10866
+ case 0:
10867
+ frame_data.payload_length = "50 Bytes";
10868
+ break;
10869
+ case 1:
10870
+ frame_data.payload_length = "100 Bytes";
10871
+ break;
10872
+ case 2:
10873
+ frame_data.payload_length = "150 Bytes";
10874
+ break;
10875
+ case 3:
10876
+ frame_data.payload_length = "180 Bytes";
10877
+ break;
10878
+ }
10879
+ switch(frame[26]){
10880
+ case 0:
10881
+ frame_data.fsr_text = "2g";
10882
+ break;
10883
+ case 1:
10884
+ frame_data.fsr_text = "4g";
10885
+ break;
10886
+ case 2:
10887
+ frame_data.fsr_text = "8g";
10888
+ break;
10889
+ case 3:
10890
+ frame_data.fsr_text = "16g";
10891
+ break;
10892
+ }
10893
+ frame_data.rpm_status = frame[27]? 'Enabled': 'Disabled';
10894
+ frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
10895
+ frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
10896
+ frame_data.smart_mode_threshold = frame[34] * 50;
10897
+ if(frame[2] > 4){ // for Firmware v5 and above
10898
+ return {
10899
+ 'firmware': frame[2],
10900
+ 'destination_address': toMac(frame.slice(12, 16)),
10901
+ 'mode': frame_data.mode,
10902
+ 'odr': frame_data.odr_1+'Hz',
10903
+ 'sampling_duration': frame_data.sampling_duration_1,
10904
+ 'filter_status': frame_data.filter_status,
10905
+ 'lpf_coeff': frame_data.lpf_coeff_1,
10906
+ 'lpf_freq': frame_data.lpf_freq_1+'Hz',
10907
+ 'hpf_coeff': frame_data.hpf_coeff_1,
10908
+ 'hpf_freq': frame_data.hpf_freq_1+'Hz',
10909
+ 'sampling_interval': frame_data.sampling_interval,
10910
+ 'on_request_timeout': frame_data.on_request_timeout,
10911
+ 'deadband': frame_data.deadband,
10912
+ 'payload_length': frame_data.payload_length,
10913
+ 'fsr': frame_data.fsr_text,
10914
+ 'rpm_compute_status': frame_data.rpm_status,
10915
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
10916
+ 'auto_raw_interval': frame_data.auto_raw_interval,
10917
+ 'smart_mode_skip_count': frame[33],
10918
+ 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
10919
+ 'uptime_counter': frame.slice(35, 39).reduce(msbLsb)+'sec',
10920
+ 'max_tx_raw_samples': frame.slice(39, 41).reduce(msbLsb),
10921
+ 'hardware_id': frame.slice(41, 44),
10922
+ 'reserved': frame.slice(44, 48),
10923
+ 'tx_lifetime_counter': frame.slice(48, 52).reduce(msbLsb),
10924
+ 'machine_values': {
10925
+ 'firmware': frame[2],
10926
+ 'destination_address': toMac(frame.slice(12, 16), false),
10927
+ 'mode': frame[16],
10928
+ 'odr': frame[17],
10929
+ 'sampling_duration': frame[18],
10930
+ 'filter_status': frame[19],
10931
+ 'lpf_coeff': frame[20],
10932
+ 'hpf_coeff': frame[21],
10933
+ 'sampling_interval': frame[22],
10934
+ 'on_request_timeout': frame[23],
10935
+ 'deadband': frame[24],
10936
+ 'payload_length': frame[25],
10937
+ 'fsr': frame[26],
10938
+ 'rpm_compute_status': frame[27],
10939
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32), false),
10940
+ 'auto_raw_interval': frame[32],
10941
+ 'smart_mode_skip_count': frame[33],
10942
+ 'smart_mode_acc_threshold':frame[34],
10943
+ 'uptime_counter': frame.slice(35, 39),
10944
+ 'max_tx_raw_samples': frame.slice(39, 41),
10945
+ 'hardware_id': frame.slice(41, 44),
10946
+ 'reserved': frame.slice(44, 48),
10947
+ 'tx_lifetime_counter': frame.slice(48, 52)
10948
+ }
10949
+ }
10950
+ }else{
10951
+ return {
10952
+ 'firmware': frame[2],
10953
+ 'destination_address': toMac(frame.slice(12, 16)),
10954
+ 'mode': frame_data.mode,
10955
+ 'odr': frame_data.odr_1+'Hz',
10956
+ 'sampling_duration': frame_data.sampling_duration_1,
10957
+ 'filter_status': frame_data.filter_status,
10958
+ 'lpf_coeff': frame_data.lpf_coeff_1,
10959
+ 'lpf_freq': frame_data.lpf_freq_1+'Hz',
10960
+ 'hpf_coeff': frame_data.hpf_coeff_1,
10961
+ 'hpf_freq': frame_data.hpf_freq_1+'Hz',
10962
+ 'sampling_interval': frame_data.sampling_interval,
10963
+ 'on_request_timeout': frame_data.on_request_timeout,
10964
+ 'deadband': frame_data.deadband,
10965
+ 'payload_length': frame_data.payload_length,
10966
+ 'fsr': frame_data.fsr_text,
10967
+ 'rpm_compute_status': frame_data.rpm_status,
10968
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
10969
+ 'auto_raw_interval': frame_data.auto_raw_interval,
10970
+ 'smart_mode_skip_count': frame[33],
10971
+ 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
10972
+ 'uptime_counter': frame.slice(35, 39).reduce(msbLsb)+'sec',
10973
+ 'hardware_id': frame.slice(39, 42),
10974
+ 'reserved': frame.slice(42, 46),
10975
+ 'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
10976
+ 'machine_values': {
10977
+ 'firmware': frame[2],
10978
+ 'destination_address': toMac(frame.slice(12, 16), false),
10979
+ 'mode': frame[16],
10980
+ 'odr': frame[17],
10981
+ 'sampling_duration': frame[18],
10982
+ 'filter_status': frame[19],
10983
+ 'lpf_coeff': frame[20],
10984
+ 'hpf_coeff': frame[21],
10985
+ 'sampling_interval': frame[22],
10986
+ 'on_request_timeout': frame[23],
10987
+ 'deadband': frame[24],
10988
+ 'payload_length': frame[25],
10989
+ 'fsr': frame[26],
10990
+ 'rpm_compute_status': frame[27],
10991
+ 'auto_raw_destination_address': toMac(frame.slice(28 , 32), false),
10992
+ 'auto_raw_interval': frame[32],
10993
+ 'smart_mode_skip_count': frame[33],
10994
+ 'smart_mode_acc_threshold':frame[34],
10995
+ 'uptime_counter': frame.slice(35, 39),
10996
+ 'hardware_id': frame.slice(39, 42),
10997
+ 'reserved': frame.slice(42, 46),
10998
+ 'tx_lifetime_counter': frame.slice(46, 50)
10999
+ }
11000
+ }
11001
+ }
11002
+ }
11003
+ },
11004
+ '117': {
11005
+ name: 'Custom Vibration Sensor PPV',
11006
+ parse: (payload, parsed, mac) => {
11007
+ if(payload[7] & 2){
11008
+ console.log('Error found');
11009
+ parsed.data = {error: 'Error found, Sensor Probe may be unattached'};
11010
+ return parsed;
11011
+ }
11012
+ if(payload[8] === 1){
11013
+ let mode = payload[8];
11014
+ let msg_type = '';
11015
+ switch(payload[9]){
11016
+ case 0:
11017
+ msg_type = 'Regular';
11018
+ break;
11019
+ case 1:
11020
+ msg_type = 'Cautionay';
11021
+ break;
11022
+ case 2:
11023
+ msg_type = 'Artwork';
11024
+ break;
11025
+ case 3:
11026
+ msg_type = 'Transient';
11027
+ break;
11028
+ }
11029
+ var deviceAddr = mac;
11030
+ var firmware = payload[1];
11031
+ var odr = msbLsb(payload[10], payload[11]);
11032
+ var fsr = payload[12];
11033
+ var device_temp = msbLsb(payload[13], payload[14])/100;
11034
+ var expected_packets = msbLsb(payload[15], payload[16]);
11035
+ var current_packet = msbLsb(payload[17], payload[18]);
11036
+ var sdata_start = 19;
11037
+
11038
+ if(globalDevices.hasOwnProperty(deviceAddr) || expected_packets == 1){
11039
+ if(expected_packets != 1){
11040
+ // if a packet is already stored with the same packet ID, or if packet ID is 1, or if current packet ID is not one more than last packet ID
11041
+ if(current_packet in globalDevices[deviceAddr].data || current_packet == 1 || !(((current_packet)-1) in globalDevices[deviceAddr].data)) {
11042
+ console.log('-----');
11043
+ console.log('bad packet breakdown deleting stream');
11044
+ console.log(current_packet);
11045
+ console.log(expected_packets);
11046
+ console.log(current_packet in globalDevices[deviceAddr].data);
11047
+ console.log(current_packet == 1);
11048
+ console.log(!((current_packet-1) in globalDevices[deviceAddr].data));
11049
+ if(this.hasOwnProperty('failure_no')){
11050
+ this.failure_no = this.failure_no + 1;
11051
+ }
11052
+ else{
11053
+ this.failure_no = 1;
11054
+ }
11055
+ if(this.hasOwnProperty('failure_no')){
11056
+ console.log('####falure no');
11057
+ console.log(this.failure_no);
11058
+ }
11059
+ // console.log(globalDevices[deviceAddr].data);
11060
+ delete globalDevices[deviceAddr];
11061
+ if(current_packet != 1){
11062
+ return;
11063
+ } else{
11064
+
11065
+ globalDevices[deviceAddr] = {
11066
+ // stream_size: expected_packets,
11067
+ data: {},
11068
+ odr: odr,
11069
+ mo: mode,
11070
+ fsr: fsr,
11071
+ device_temp: device_temp,
11072
+ }
11073
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
11074
+ return;
11075
+ }
11076
+ }
11077
+ else{
11078
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
11079
+ }
11080
+ }
11081
+ else{
11082
+
11083
+ globalDevices[deviceAddr] = {
11084
+ // stream_size: expected_packets,
11085
+ data: {},
11086
+ odr: odr,
11087
+ mo: mode,
11088
+ fsr: fsr,
11089
+ device_temp: device_temp,
11090
+ }
11091
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
11092
+ }
11093
+
11094
+ if(Object.keys(globalDevices[deviceAddr].data).length == expected_packets){
11095
+ var raw_data = new Array();
11096
+ for(const packet in globalDevices[deviceAddr].data){
11097
+ raw_data = raw_data.concat(globalDevices[deviceAddr].data[packet]);
11098
+ }
11099
+ var label = 0;
11100
+
11101
+ var fft = new Array();
11102
+ var fft_concat = {};
11103
+
11104
+ var en_axis_data = {};
11105
+ en_axis_data.x_offset = 0;
11106
+ en_axis_data.y_offset = 2;
11107
+ en_axis_data.z_offset = 4;
11108
+ en_axis_data.increment = 6;
11109
+ fft_concat = {x: [], y: [], z: []};
11110
+
11111
+ switch(globalDevices[deviceAddr].fsr){
11112
+ case 0:
11113
+ fsr_text = "2g";
11114
+ break;
11115
+ case 1:
11116
+ fsr_text = "4g";
11117
+ break;
11118
+ case 2:
11119
+ fsr_text = "8g";
11120
+ break;
11121
+ case 3:
11122
+ fsr_text = "16g";
11123
+ break;
11124
+ }
11125
+
11126
+ for(var i = 0; i < raw_data.length; i+=en_axis_data.increment){
11127
+ label++;
11128
+
11129
+ if('x_offset' in en_axis_data){
11130
+ fft_concat.x.push(parseFloat((signInt(((raw_data[i+en_axis_data.x_offset]<<8)+(raw_data[i+en_axis_data.x_offset+1])), 16) / 100).toFixed(2)));
11131
+ }
11132
+ if('y_offset' in en_axis_data){
11133
+ fft_concat.y.push(parseFloat((signInt(((raw_data[i+en_axis_data.y_offset]<<8)+(raw_data[i+en_axis_data.y_offset+1])), 16) / 100).toFixed(2)));
11134
+ }
11135
+ if('z_offset' in en_axis_data){
11136
+ fft_concat.z.push(parseFloat((signInt(((raw_data[i+en_axis_data.z_offset]<<8)+(raw_data[i+en_axis_data.z_offset+1])), 16) / 100).toFixed(2)));
11137
+ }
11138
+ }
11139
+ var fft_concat_obj = {
11140
+ mode: mode,
11141
+ msg_type: msg_type,
11142
+ mac_address: deviceAddr,
11143
+ fsr: fsr_text,
11144
+ odr: globalDevices[deviceAddr].odr,
11145
+ device_temp: globalDevices[deviceAddr].device_temp,
11146
+ total_samples: label,
11147
+ data: fft_concat
11148
+ };
11149
+ sensor_data = fft_concat_obj;
11150
+ delete globalDevices[deviceAddr];
11151
+ if(this.hasOwnProperty('failure_no')){
11152
+ console.log('####falure no');
11153
+ console.log(this.failure_no);
11154
+ }
11155
+
11156
+ return sensor_data;
11157
+ }
11158
+ else{
11159
+ return;
11160
+ }
11161
+ }else{
11162
+
11163
+ globalDevices[deviceAddr] = {
11164
+ // stream_size: expected_packets,
11165
+ data: {},
11166
+ odr: odr,
11167
+ mo: mode,
11168
+ fsr: fsr,
11169
+ device_temp: device_temp,
11170
+ }
11171
+ globalDevices[deviceAddr].data[current_packet] = payload.slice(sdata_start);
11172
+ return;
11173
+ }
9398
11174
  }
9399
- switch(frame[26]){
9400
- case 0:
9401
- frame_data.fsr_text = "2g";
9402
- break;
9403
- case 1:
9404
- frame_data.fsr_text = "4g";
9405
- break;
9406
- case 2:
9407
- frame_data.fsr_text = "8g";
9408
- break;
9409
- case 3:
9410
- frame_data.fsr_text = "16g";
9411
- break;
11175
+ else if(payload[8] === 0){
11176
+ // mode byte most significant bit will indicate fft data.
11177
+ // console.log(d);
11178
+ let msg_type = '';
11179
+ switch(payload[9]){
11180
+ case 0:
11181
+ msg_type = 'Regular'
11182
+ break;
11183
+ case 1:
11184
+ msg_type = 'Cautionay';
11185
+ break;
11186
+ case 2:
11187
+ msg_type = 'Artwork';
11188
+ break;
11189
+ case 3:
11190
+ msg_type = 'Transient';
11191
+ break;
11192
+ }
11193
+ return {
11194
+ mode: payload[8],
11195
+ msg_type: msg_type,
11196
+
11197
+ odr: payload.slice(10, 12).reduce(msbLsb),
11198
+ temperature: signInt(payload.slice(12, 14).reduce(msbLsb), 16) / 100,
11199
+
11200
+ x_max_acceleration: payload.slice(14, 16).reduce(msbLsb),
11201
+ x_rms_acceleration: payload.slice(16, 18).reduce(msbLsb),
11202
+ x_max_velocity: payload.slice(18, 20).reduce(msbLsb) / 100,
11203
+ x_rms_velocity:payload.slice(20, 22).reduce(msbLsb) / 100,
11204
+ x_peak_one_Hz: payload.slice(22, 24).reduce(msbLsb),
11205
+ x_peak_two_Hz: payload.slice(24, 26).reduce(msbLsb),
11206
+ x_peak_three_Hz: payload.slice(26, 28).reduce(msbLsb),
11207
+
11208
+ y_max_acceleration: payload.slice(28, 30).reduce(msbLsb),
11209
+ y_rms_acceleration: payload.slice(30, 32).reduce(msbLsb),
11210
+ y_max_velocity: payload.slice(32, 34).reduce(msbLsb) / 100,
11211
+ y_rms_velocity:payload.slice(34, 36).reduce(msbLsb) / 100,
11212
+ y_peak_one_Hz: payload.slice(36, 38).reduce(msbLsb),
11213
+ y_peak_two_Hz: payload.slice(38, 40).reduce(msbLsb),
11214
+ y_peak_three_Hz: payload.slice(40, 42).reduce(msbLsb),
11215
+
11216
+ z_max_acceleration: payload.slice(42, 44).reduce(msbLsb),
11217
+ z_rms_acceleration: payload.slice(44, 46).reduce(msbLsb),
11218
+ z_max_velocity: payload.slice(46, 48).reduce(msbLsb) / 100,
11219
+ z_rms_velocity:payload.slice(48, 50).reduce(msbLsb) / 100,
11220
+ z_peak_one_Hz: payload.slice(50, 52).reduce(msbLsb),
11221
+ z_peak_two_Hz: payload.slice(52, 54).reduce(msbLsb),
11222
+ z_peak_three_Hz: payload.slice(54, 56).reduce(msbLsb),
11223
+ };
9412
11224
  }
9413
- frame_data.rpm_status = frame[27]? 'Enabled': 'Disabled';
9414
- frame_data.auto_raw_interval = frame[32] * frame_data.sampling_interval_number || 'disabled';
9415
- frame_data.auto_raw_interval = typeof frame_data.auto_raw_interval === 'number' ? frame_data.auto_raw_interval+'min' : frame_data.auto_raw_interval;
9416
- frame_data.smart_mode_threshold = frame[34] * 50;
11225
+ // else{
11226
+ // parsed.data = {'error': 'Vibration mode error'}
11227
+ // return parsed;
11228
+ // }
11229
+ },
11230
+ 'parse_fly': (frame) => {
9417
11231
  return {
9418
- 'firmware': frame[2],
9419
- 'destination_address': toMac(frame.slice(12, 16)),
9420
- 'mode': frame_data.mode,
9421
- 'odr': frame_data.odr_1+'Hz',
9422
- 'sampling_duration': frame_data.sampling_duration_1,
9423
- 'filter_status': frame_data.filter_status,
9424
- 'lpf_coeff': frame_data.lpf_coeff_1,
9425
- 'lpf_freq': frame_data.lpf_freq_1+'Hz',
9426
- 'hpf_coeff': frame_data.hpf_coeff_1,
9427
- 'hpf_freq': frame_data.hpf_freq_1+'Hz',
9428
- 'sampling_interval': frame_data.sampling_interval,
9429
- 'on_request_timeout': frame_data.on_request_timeout,
9430
- 'deadband': frame_data.deadband,
9431
- 'payload_length': frame_data.payload_length,
9432
- 'fsr': frame_data.fsr_text,
9433
- 'rpm_compute_status': frame_data.rpm_status,
9434
- 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
9435
- 'auto_raw_interval': frame_data.auto_raw_interval,
9436
- 'smart_mode_skip_count': frame[33],
9437
- 'smart_mode_acc_threshold':frame_data.smart_mode_threshold+'mg',
9438
- 'uptime_counter': frame.slice(35, 39).reduce(msbLsb),
9439
- 'hardware_id': frame.slice(39, 42),
9440
- 'reserved': frame.slice(42, 46),
9441
- 'tx_lifetime_counter': frame.slice(46, 50).reduce(msbLsb),
11232
+ 'fly_rate': frame.slice(12, 14).reduce(msbLsb) + " Min.",
11233
+ 'fsr': frame[14],
11234
+ 'deadband': frame[15],
11235
+ 'hardware_id': frame.slice(16, 19),
11236
+ 'report_rate': frame.slice(19, 23).reduce(msbLsb) + " Sec.",
11237
+ 'tx_lifetime_counter': frame.slice(23, 27).reduce(msbLsb),
9442
11238
  'machine_values': {
9443
- 'firmware': frame[2],
9444
- 'destination_address': toMac(frame.slice(12, 16), false),
9445
- 'mode': frame[16],
9446
- 'odr': frame[17],
9447
- 'sampling_duration': frame[18],
9448
- 'filter_status': frame[19],
9449
- 'lpf_coeff': frame[20],
9450
- 'hpf_coeff': frame[21],
9451
- 'sampling_interval': frame[22],
9452
- 'on_request_timeout': frame[23],
9453
- 'deadband': frame[24],
9454
- 'payload_length': frame[25],
9455
- 'fsr': frame[26],
9456
- 'rpm_compute_status': frame[27],
9457
- 'auto_raw_destination_address': toMac(frame.slice(28 , 32)),
9458
- 'auto_raw_interval': frame[32],
9459
- 'smart_mode_skip_count': frame[33],
9460
- 'smart_mode_acc_threshold':frame[34],
9461
- 'uptime_counter': frame.slice(35, 39),
9462
- 'hardware_id': frame.slice(39, 42),
9463
- 'reserved': frame.slice(42, 46),
9464
- 'tx_lifetime_counter': frame.slice(46, 50)
11239
+ 'fly_rate': frame.slice(12, 14),
11240
+ 'fsr':frame[14],
11241
+ 'deadband': frame[15],
11242
+ 'hardware_id': frame.slice(16, 19),
11243
+ 'report_rate': frame.slice(19, 23),
11244
+ 'tx_lifetime_counter': frame.slice(23, 27)
9465
11245
  }
9466
11246
  }
9467
11247
  }
@@ -9577,6 +11357,98 @@ function sensor_types(parent){
9577
11357
  }
9578
11358
  }
9579
11359
  },
11360
+ '121':{
11361
+ name: 'Wireless Wood Moisture Sensor',
11362
+ parse: (d) => {
11363
+ return {
11364
+ wood_type: d[0],
11365
+ temperature: signInt(d.slice(1, 3).reduce(msbLsb), 16) / 100,
11366
+ humidity: d.slice(3, 5).reduce(msbLsb) / 100,
11367
+ wood_moisture: d.slice(5, 7).reduce(msbLsb) / 100,
11368
+ wood_resistance: (d.slice(7, 15)).reduce(msbLsb) / 100
11369
+ };
11370
+ },
11371
+ 'parse_fly': (frame) => {
11372
+ return {
11373
+ 'hardware_id': frame.slice(12, 15),
11374
+ 'sample_rate': frame.slice(15, 19).reduce(msbLsb) + " Sec.",
11375
+ 'tx_life_counter': frame.slice(19, 23).reduce(msbLsb),
11376
+ 'machine_values': {
11377
+ 'hardware_id': frame.slice(12, 15),
11378
+ 'sample_rate': frame.slice(15, 19),
11379
+ 'tx_life_counter': frame.slice(19, 23)
11380
+ }
11381
+ }
11382
+ }
11383
+ },
11384
+ '122': {
11385
+ name: 'Wireless 4-20mA Current Splitter',
11386
+ parse: (d) => {
11387
+ // This parser may be outdated if a customer has an issue check with Engineering
11388
+ var adc1 = signInt(d.slice(0, 2).reduce(msbLsb));
11389
+ var adc2 = signInt(d.slice(2, 4).reduce(msbLsb));
11390
+ return {
11391
+ adc1: adc1,
11392
+ adc2: adc2,
11393
+ mA1: signInt(d.slice(4, 6).reduce(msbLsb))/100,
11394
+ mA2: signInt(d.slice(6, 8).reduce(msbLsb))/100
11395
+ };
11396
+ },
11397
+ 'parse_fly': (frame) => {
11398
+ let frame_data = {};
11399
+ switch(frame[16]){
11400
+ case 0:
11401
+ frame_data.fsr = "+-0.256 V";
11402
+ break;
11403
+ case 1:
11404
+ frame_data.fsr = "+-0.512 V";
11405
+ break;
11406
+ case 2:
11407
+ frame_data.fsr = "+-1.024 V";
11408
+ break;
11409
+ case 3:
11410
+ frame_data.fsr = "+-2.048 V";
11411
+ break;
11412
+ case 4:
11413
+ frame_data.fsr = "+-4.096 V";
11414
+ break;
11415
+ case 5:
11416
+ frame_data.fsr = "+-6.144 V";
11417
+ break;
11418
+ }
11419
+ if(frame[2]>12){
11420
+ return {
11421
+ 'firmware': frame[2],
11422
+ 'report_rate': frame.slice(12, 16).reduce(msbLsb),
11423
+ 'fsr':frame_data.fsr,
11424
+ 'boot_up_time': frame[17],
11425
+ 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
11426
+ 'machine_values': {
11427
+ 'firmware': frame[2],
11428
+ 'report_rate': frame.slice(12, 16),
11429
+ 'fsr':frame[16],
11430
+ 'boot_up_time': frame[17],
11431
+ 'adc_pin_reading': frame.slice(18, 20),
11432
+ 'frame': frame
11433
+ }
11434
+ }
11435
+ }else{
11436
+ return {
11437
+ 'firmware': frame[2],
11438
+ 'report_rate': frame.slice(12, 16).reduce(msbLsb),
11439
+ 'fsr':frame_data.fsr,
11440
+ 'boot_up_time': frame[17],
11441
+ 'machine_values': {
11442
+ 'firmware': frame[2],
11443
+ 'report_rate': frame.slice(12, 16),
11444
+ 'fsr':frame[16],
11445
+ 'boot_up_time': frame[17],
11446
+ 'frame': frame
11447
+ }
11448
+ }
11449
+ }
11450
+ }
11451
+ },
9580
11452
  '180': {
9581
11453
  name: 'C1D2 One Channel Vibration Plus',
9582
11454
  parse: (payload, parsed, mac) => {
@@ -10015,7 +11887,6 @@ function sensor_types(parent){
10015
11887
  data: {},
10016
11888
  odr: odr,
10017
11889
  mo: mode,
10018
- en_axis: en_axis,
10019
11890
  fsr: fsr,
10020
11891
  hour: hour,
10021
11892
  minute: minute,
@@ -11996,6 +13867,57 @@ function sensor_types(parent){
11996
13867
  ma: d.slice(2, 4).reduce(msbLsb) / 100,
11997
13868
  flow_ltr_min: d.slice(4, 8).reduce(msbLsb) / 100
11998
13869
  };
13870
+ },
13871
+ 'parse_fly': (frame) => {
13872
+ let firmware = frame[2];
13873
+ if(firmware > 13){ // firmware 14 and above
13874
+ let frame_data = {};
13875
+ frame_data.always_on = frame[24]?"Enabled":"Disabled";
13876
+ switch(frame[16]){
13877
+ case 0:
13878
+ frame_data.fsr = "+-0.256 V";
13879
+ break;
13880
+ case 1:
13881
+ frame_data.fsr = "+-0.512 V";
13882
+ break;
13883
+ case 2:
13884
+ frame_data.fsr = "+-1.024 V";
13885
+ break;
13886
+ case 3:
13887
+ frame_data.fsr = "+-2.048 V";
13888
+ break;
13889
+ case 4:
13890
+ frame_data.fsr = "+-4.096 V";
13891
+ break;
13892
+ case 5:
13893
+ frame_data.fsr = "+-6.144 V";
13894
+ break;
13895
+ }
13896
+ return {
13897
+ 'firmware': frame[2],
13898
+ 'fsr': frame_data.fsr,
13899
+ 'boot_time': frame[17] + " sec",
13900
+ 'power_adc': frame.slice(18, 20).reduce(msbLsb),
13901
+ 'auto_check_interval': frame.slice(20, 22).reduce(msbLsb) + " sec",
13902
+ 'auto_check_percentage': frame.slice(22, 24).reduce(msbLsb),
13903
+ 'always_on': frame_data.always_on,
13904
+ 'hardware_id': frame.slice(25, 28),
13905
+ 'report_rate': frame.slice(28, 32).reduce(msbLsb) + " sec",
13906
+ 'tx_life_counter': frame.slice(32, 36).reduce(msbLsb),
13907
+ 'machine_values': {
13908
+ 'firmware': frame[2],
13909
+ 'fsr': frame[16],
13910
+ 'boot_time': frame[17],
13911
+ 'power_adc': frame.slice(18, 20),
13912
+ 'auto_check_interval': frame.slice(20, 22),
13913
+ 'auto_check_percentage': frame.slice(22, 24),
13914
+ 'always_on': frame[24],
13915
+ 'hardware_id': frame.slice(25, 28),
13916
+ 'report_rate': frame.slice(28, 32),
13917
+ 'tx_life_counter': frame.slice(32, 36)
13918
+ }
13919
+ }
13920
+ }
11999
13921
  }
12000
13922
  },
12001
13923
  '1010': {