@ncd-io/node-red-enterprise-sensors 1.4.0 → 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.
- package/lib/WirelessGateway.js +1211 -164
- package/package.json +1 -1
- package/wireless.html +68 -12
- package/wireless.js +153 -12
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
|
-
|
|
141
|
-
|
|
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]];
|
|
@@ -756,7 +756,7 @@ module.exports = class WirelessSensor{
|
|
|
756
756
|
data: payload.slice(8)
|
|
757
757
|
};
|
|
758
758
|
// #OTF
|
|
759
|
-
}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 == 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){
|
|
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){
|
|
760
760
|
parsed.sensor_data = this.sensor_types[parsed.sensor_type].parse(payload, parsed, frame.mac);
|
|
761
761
|
if(!parsed.sensor_data){
|
|
762
762
|
return;
|
|
@@ -796,7 +796,7 @@ module.exports = class WirelessSensor{
|
|
|
796
796
|
console.log('firmware_send_manifest_v13');
|
|
797
797
|
// sensor_mac = "00:00:00:00:00:00:ff:ff";
|
|
798
798
|
let packet = [245, 58, 0, 0, 0].concat(Array.prototype.slice.call(manifest));
|
|
799
|
-
return this.firmware_send_v13(sensor_mac, packet, {}, 7000,
|
|
799
|
+
return this.firmware_send_v13(sensor_mac, packet, {}, 7000, 140, true);
|
|
800
800
|
}
|
|
801
801
|
firmware_send_chunk(sensor_mac, offset, chunk){
|
|
802
802
|
console.log('firmware_send_chunk');
|
|
@@ -1887,7 +1887,7 @@ module.exports = class WirelessSensor{
|
|
|
1887
1887
|
}
|
|
1888
1888
|
config_set_pressure_sensor_fs_ch2_118(sensor_mac, value){
|
|
1889
1889
|
console.log('config_set_pressure_sensor_fs_ch2_118');
|
|
1890
|
-
var packet = [244,
|
|
1890
|
+
var packet = [244, 72, 0, 0, 118, value];
|
|
1891
1891
|
console.log(packet);
|
|
1892
1892
|
return this.config_send(sensor_mac, packet);
|
|
1893
1893
|
}
|
|
@@ -1947,6 +1947,12 @@ module.exports = class WirelessSensor{
|
|
|
1947
1947
|
}
|
|
1948
1948
|
config_set_pressure_sensor_type_21(sensor_mac, value){
|
|
1949
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');
|
|
1950
1956
|
var packet = [244, 64, 0, 0, 21, value]
|
|
1951
1957
|
console.log(packet);
|
|
1952
1958
|
return this.config_send(sensor_mac, packet);
|
|
@@ -2286,14 +2292,14 @@ module.exports = class WirelessSensor{
|
|
|
2286
2292
|
this.queue = new Queue(1);
|
|
2287
2293
|
}
|
|
2288
2294
|
firmware_send_chunk_v13(sensor_mac, offset, chunk){
|
|
2289
|
-
console.log('firmware_send_chunk');
|
|
2295
|
+
// console.log('firmware_send_chunk');
|
|
2290
2296
|
// sensor_mac = "00:00:00:00:00:00:ff:ff";
|
|
2291
2297
|
let packet = [245, 59, 0, 0, 0].concat(offset, Array.prototype.slice.call(chunk));
|
|
2292
2298
|
// console.log(packet);
|
|
2293
2299
|
return this.firmware_send_v13(sensor_mac, packet);
|
|
2294
2300
|
}
|
|
2295
2301
|
firmware_read_last_chunk_segment(sensor_mac){
|
|
2296
|
-
console.log('firmware_read_last_chunk_segment');
|
|
2302
|
+
// console.log('firmware_read_last_chunk_segment');
|
|
2297
2303
|
let packet = [245, 61, 0, 0, 0];
|
|
2298
2304
|
return this.config_send(sensor_mac, packet);
|
|
2299
2305
|
}
|
|
@@ -2484,92 +2490,6 @@ module.exports = class WirelessSensor{
|
|
|
2484
2490
|
});
|
|
2485
2491
|
});
|
|
2486
2492
|
});
|
|
2487
|
-
}
|
|
2488
|
-
queue_bridge_query(sensor_mac, data, meta = null, opts){
|
|
2489
|
-
var that = this;
|
|
2490
|
-
if(!globalDevices.hasOwnProperty(sensor_mac)){
|
|
2491
|
-
globalDevices[sensor_mac] = {bridge: true, command_queue: []};
|
|
2492
|
-
}
|
|
2493
|
-
// if(!Object.hasOwn(node._gateway_node.sensor_list[msg.payload.address], 'command_queue')){
|
|
2494
|
-
// if(!globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2495
|
-
// globalDevices[sensor_mac].command_queue = [{'command': data, 'meta': meta}];
|
|
2496
|
-
// }else{
|
|
2497
|
-
globalDevices[sensor_mac].command_queue.push({'command': data, 'meta': meta});
|
|
2498
|
-
// }
|
|
2499
|
-
|
|
2500
|
-
return new Promise((fulfill, reject) => {
|
|
2501
|
-
that.queue.add(() => {
|
|
2502
|
-
return new Promise((f, r) => {
|
|
2503
|
-
var tout;
|
|
2504
|
-
function fail(response){
|
|
2505
|
-
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
2506
|
-
clearTimeout(tout);
|
|
2507
|
-
|
|
2508
|
-
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2509
|
-
globalDevices[sensor_mac].command_queue.shift();
|
|
2510
|
-
}
|
|
2511
|
-
reject({
|
|
2512
|
-
err: response,
|
|
2513
|
-
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2514
|
-
});
|
|
2515
|
-
f();
|
|
2516
|
-
}
|
|
2517
|
-
function pass(response){
|
|
2518
|
-
clearTimeout(tout);
|
|
2519
|
-
|
|
2520
|
-
that._emitter.emit('converter_response', response);
|
|
2521
|
-
that._emitter.emit('converter_response-'+sensor_mac, response);
|
|
2522
|
-
|
|
2523
|
-
|
|
2524
|
-
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2525
|
-
globalDevices[sensor_mac].command_queue.shift();
|
|
2526
|
-
}
|
|
2527
|
-
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2528
|
-
fulfill(response);
|
|
2529
|
-
f();
|
|
2530
|
-
// that._emitter.
|
|
2531
|
-
};
|
|
2532
|
-
|
|
2533
|
-
that._emitter.once('converter_ack-'+sensor_mac, pass);
|
|
2534
|
-
that._emitter.once('converter_error-'+sensor_mac, fail);
|
|
2535
|
-
tout = setTimeout(() => {
|
|
2536
|
-
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2537
|
-
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
2538
|
-
|
|
2539
|
-
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2540
|
-
globalDevices[sensor_mac].command_queue.shift();
|
|
2541
|
-
};
|
|
2542
|
-
if(sensor_mac == '00:00:00:00:00:00:FF:FF'){
|
|
2543
|
-
reject({
|
|
2544
|
-
res: 'Broadcast mode, no target device',
|
|
2545
|
-
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2546
|
-
});
|
|
2547
|
-
}else{
|
|
2548
|
-
reject({
|
|
2549
|
-
err: 'Wireless Converter did not respond',
|
|
2550
|
-
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2551
|
-
});
|
|
2552
|
-
};
|
|
2553
|
-
|
|
2554
|
-
f();
|
|
2555
|
-
}, 1500);
|
|
2556
|
-
that.send.transmit_request(mac2bytes(sensor_mac), data, opts).then().catch((err) => {
|
|
2557
|
-
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2558
|
-
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
2559
|
-
reject({
|
|
2560
|
-
err: err,
|
|
2561
|
-
sent: [mac2bytes(sensor_mac), data, opts]
|
|
2562
|
-
});
|
|
2563
|
-
f();
|
|
2564
|
-
}).then();
|
|
2565
|
-
});
|
|
2566
|
-
});
|
|
2567
|
-
this.queue.add(() => {
|
|
2568
|
-
return new Promise((f, r) => {
|
|
2569
|
-
setTimeout(f, 500);
|
|
2570
|
-
});
|
|
2571
|
-
});
|
|
2572
|
-
});
|
|
2573
2493
|
};
|
|
2574
2494
|
prepare_bridge_query(sensor_mac, commands){
|
|
2575
2495
|
commands.forEach((command) => {
|
|
@@ -2580,7 +2500,9 @@ module.exports = class WirelessSensor{
|
|
|
2580
2500
|
}
|
|
2581
2501
|
});
|
|
2582
2502
|
}
|
|
2583
|
-
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);
|
|
2584
2506
|
var that = this;
|
|
2585
2507
|
if(!globalDevices.hasOwnProperty(sensor_mac)){
|
|
2586
2508
|
globalDevices[sensor_mac] = {bridge: true, command_queue: []};
|
|
@@ -2602,7 +2524,10 @@ module.exports = class WirelessSensor{
|
|
|
2602
2524
|
|
|
2603
2525
|
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2604
2526
|
globalDevices[sensor_mac].command_queue.shift();
|
|
2605
|
-
}
|
|
2527
|
+
};
|
|
2528
|
+
// if(globalDevices[sensor_mac].command_queue.length == 0 && globalDevices[sensor_mac].hasOwnProperty('bridge')){
|
|
2529
|
+
// delete globalDevices[sensor_mac].bridge;
|
|
2530
|
+
// }
|
|
2606
2531
|
reject({
|
|
2607
2532
|
err: response,
|
|
2608
2533
|
sent: [mac2bytes(sensor_mac), data, opts]
|
|
@@ -2619,6 +2544,9 @@ module.exports = class WirelessSensor{
|
|
|
2619
2544
|
if(globalDevices[sensor_mac].hasOwnProperty('command_queue')){
|
|
2620
2545
|
globalDevices[sensor_mac].command_queue.shift();
|
|
2621
2546
|
}
|
|
2547
|
+
// if(globalDevices[sensor_mac].command_queue.length == 0 && globalDevices[sensor_mac].hasOwnProperty('bridge')){
|
|
2548
|
+
// delete globalDevices[sensor_mac].bridge;
|
|
2549
|
+
// }
|
|
2622
2550
|
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2623
2551
|
fulfill(response);
|
|
2624
2552
|
f();
|
|
@@ -2647,7 +2575,7 @@ module.exports = class WirelessSensor{
|
|
|
2647
2575
|
};
|
|
2648
2576
|
|
|
2649
2577
|
f();
|
|
2650
|
-
},
|
|
2578
|
+
}, command_timeout);
|
|
2651
2579
|
that.send.transmit_request(mac2bytes(sensor_mac), data, opts).then().catch((err) => {
|
|
2652
2580
|
that._emitter.removeListener('converter_error-'+sensor_mac, fail);
|
|
2653
2581
|
that._emitter.removeListener('converter_ack-'+sensor_mac, pass);
|
|
@@ -2666,15 +2594,15 @@ module.exports = class WirelessSensor{
|
|
|
2666
2594
|
});
|
|
2667
2595
|
});
|
|
2668
2596
|
};
|
|
2669
|
-
prepare_bridge_query(sensor_mac, commands){
|
|
2597
|
+
prepare_bridge_query(sensor_mac, commands, timeout){
|
|
2670
2598
|
commands.forEach((command) => {
|
|
2671
2599
|
if(command.hasOwnProperty('meta')){
|
|
2672
|
-
this.queue_bridge_query(sensor_mac, command.command, command.meta);
|
|
2600
|
+
this.queue_bridge_query(sensor_mac, command.command, command.meta, timeout);
|
|
2673
2601
|
}else{
|
|
2674
|
-
this.queue_bridge_query(sensor_mac, command.command);
|
|
2675
|
-
}
|
|
2602
|
+
this.queue_bridge_query(sensor_mac, command.command, null, timeout);
|
|
2603
|
+
};
|
|
2676
2604
|
});
|
|
2677
|
-
}
|
|
2605
|
+
};
|
|
2678
2606
|
build_102_data(payload, deviceAddr, hour, minute, sdata_start, current_packet, firmware){
|
|
2679
2607
|
if(current_packet != 1){
|
|
2680
2608
|
console.log('bad packet cleanup');
|
|
@@ -3202,6 +3130,57 @@ function sensor_types(parent){
|
|
|
3202
3130
|
adc: adc,
|
|
3203
3131
|
voltage: adc * 0.00322265625
|
|
3204
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
|
+
}
|
|
3205
3184
|
}
|
|
3206
3185
|
},
|
|
3207
3186
|
'16': {
|
|
@@ -3255,11 +3234,204 @@ function sensor_types(parent){
|
|
|
3255
3234
|
},
|
|
3256
3235
|
'21': {
|
|
3257
3236
|
name: 'Differential Bidirectional Pressure Sensor',
|
|
3258
|
-
parse: (
|
|
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
|
+
}
|
|
3259
3419
|
return {
|
|
3260
|
-
|
|
3261
|
-
|
|
3262
|
-
|
|
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
|
+
}
|
|
3263
3435
|
}
|
|
3264
3436
|
},
|
|
3265
3437
|
'22': {
|
|
@@ -3514,6 +3686,57 @@ function sensor_types(parent){
|
|
|
3514
3686
|
adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
|
|
3515
3687
|
mA: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
|
|
3516
3688
|
};
|
|
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
|
+
}
|
|
3517
3740
|
}
|
|
3518
3741
|
},
|
|
3519
3742
|
'46': {
|
|
@@ -3540,6 +3763,57 @@ function sensor_types(parent){
|
|
|
3540
3763
|
adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
|
|
3541
3764
|
mA: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
|
|
3542
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
|
+
}
|
|
3543
3817
|
}
|
|
3544
3818
|
},
|
|
3545
3819
|
'49': {
|
|
@@ -3619,6 +3893,7 @@ function sensor_types(parent){
|
|
|
3619
3893
|
};
|
|
3620
3894
|
},
|
|
3621
3895
|
'parse_fly': (frame) => {
|
|
3896
|
+
let firmware = frame[2];
|
|
3622
3897
|
let frame_data = {};
|
|
3623
3898
|
switch(frame[16]){
|
|
3624
3899
|
case 0:
|
|
@@ -3640,7 +3915,34 @@ function sensor_types(parent){
|
|
|
3640
3915
|
frame_data.fsr = "+-6.144 V";
|
|
3641
3916
|
break;
|
|
3642
3917
|
}
|
|
3643
|
-
if(
|
|
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){
|
|
3644
3946
|
return {
|
|
3645
3947
|
'firmware': frame[2],
|
|
3646
3948
|
'report_rate': frame.slice(12, 16).reduce(msbLsb),
|
|
@@ -3715,6 +4017,57 @@ function sensor_types(parent){
|
|
|
3715
4017
|
VDC1: parseFloat((adc1 * 0.00034122).toFixed(2)),
|
|
3716
4018
|
VDC2: parseFloat((adc2 * 0.00034122).toFixed(2))
|
|
3717
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
|
+
}
|
|
3718
4071
|
}
|
|
3719
4072
|
},
|
|
3720
4073
|
'58': {
|
|
@@ -3948,6 +4301,57 @@ function sensor_types(parent){
|
|
|
3948
4301
|
mA: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100,
|
|
3949
4302
|
Velocity: signInt(d.slice(4, 8).reduce(msbLsb), 32) / 100
|
|
3950
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
|
+
}
|
|
3951
4355
|
}
|
|
3952
4356
|
},
|
|
3953
4357
|
'76': {
|
|
@@ -3958,6 +4362,57 @@ function sensor_types(parent){
|
|
|
3958
4362
|
temperature: signInt((msbLsb(d[2], d[3])), 16)/100,
|
|
3959
4363
|
co_ppm: msbLsb(d[4], d[5])
|
|
3960
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
|
+
}
|
|
3961
4416
|
}
|
|
3962
4417
|
},
|
|
3963
4418
|
'77': {
|
|
@@ -6437,6 +6892,7 @@ function sensor_types(parent){
|
|
|
6437
6892
|
};
|
|
6438
6893
|
},
|
|
6439
6894
|
'parse_fly': (frame) => {
|
|
6895
|
+
let firmware = frame[2];
|
|
6440
6896
|
let frame_data = {};
|
|
6441
6897
|
switch(frame[16]){
|
|
6442
6898
|
case 0:
|
|
@@ -6458,19 +6914,47 @@ function sensor_types(parent){
|
|
|
6458
6914
|
frame_data.fsr = "+-6.144 V";
|
|
6459
6915
|
break;
|
|
6460
6916
|
}
|
|
6461
|
-
|
|
6462
|
-
|
|
6463
|
-
|
|
6464
|
-
'fsr':frame_data.fsr,
|
|
6465
|
-
'boot_up_time': frame[17],
|
|
6466
|
-
// 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
|
|
6467
|
-
'machine_values': {
|
|
6917
|
+
if(firmware > 13){ // firmware 14 and above
|
|
6918
|
+
frame_data.always_on = frame[24]?"Enabled":"Disabled";
|
|
6919
|
+
return {
|
|
6468
6920
|
'firmware': frame[2],
|
|
6469
|
-
'
|
|
6470
|
-
'
|
|
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 {
|
|
6945
|
+
'firmware': frame[2],
|
|
6946
|
+
'report_rate': frame.slice(12, 16).reduce(msbLsb),
|
|
6947
|
+
'fsr':frame_data.fsr,
|
|
6471
6948
|
'boot_up_time': frame[17],
|
|
6472
|
-
// 'adc_pin_reading': frame.slice(18, 20),
|
|
6473
|
-
'
|
|
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
|
+
}
|
|
6474
6958
|
}
|
|
6475
6959
|
}
|
|
6476
6960
|
}
|
|
@@ -6488,6 +6972,7 @@ function sensor_types(parent){
|
|
|
6488
6972
|
};
|
|
6489
6973
|
},
|
|
6490
6974
|
'parse_fly': (frame) => {
|
|
6975
|
+
let firmware = frame[2];
|
|
6491
6976
|
let frame_data = {};
|
|
6492
6977
|
switch(frame[16]){
|
|
6493
6978
|
case 0:
|
|
@@ -6509,19 +6994,47 @@ function sensor_types(parent){
|
|
|
6509
6994
|
frame_data.fsr = "+-6.144 V";
|
|
6510
6995
|
break;
|
|
6511
6996
|
}
|
|
6512
|
-
|
|
6513
|
-
|
|
6514
|
-
|
|
6515
|
-
'fsr':frame_data.fsr,
|
|
6516
|
-
'boot_up_time': frame[17],
|
|
6517
|
-
// 'adc_pin_reading': frame.slice(18, 20).reduce(msbLsb),
|
|
6518
|
-
'machine_values': {
|
|
6997
|
+
if(firmware > 13){ // firmware 14 and above
|
|
6998
|
+
frame_data.always_on = frame[24]?"Enabled":"Disabled";
|
|
6999
|
+
return {
|
|
6519
7000
|
'firmware': frame[2],
|
|
6520
|
-
'
|
|
6521
|
-
'
|
|
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 {
|
|
7025
|
+
'firmware': frame[2],
|
|
7026
|
+
'report_rate': frame.slice(12, 16).reduce(msbLsb),
|
|
7027
|
+
'fsr':frame_data.fsr,
|
|
6522
7028
|
'boot_up_time': frame[17],
|
|
6523
|
-
// 'adc_pin_reading': frame.slice(18, 20),
|
|
6524
|
-
'
|
|
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
|
+
}
|
|
6525
7038
|
}
|
|
6526
7039
|
}
|
|
6527
7040
|
}
|
|
@@ -6533,6 +7046,57 @@ function sensor_types(parent){
|
|
|
6533
7046
|
raw_adc: d.slice(0, 2).reduce(msbLsb),
|
|
6534
7047
|
amps: d.slice(2, 6).reduce(msbLsb) / 10,
|
|
6535
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
|
+
}
|
|
6536
7100
|
}
|
|
6537
7101
|
},
|
|
6538
7102
|
'91': {
|
|
@@ -6558,6 +7122,57 @@ function sensor_types(parent){
|
|
|
6558
7122
|
adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
|
|
6559
7123
|
vdc: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
|
|
6560
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
|
+
}
|
|
6561
7176
|
}
|
|
6562
7177
|
},
|
|
6563
7178
|
'96': {
|
|
@@ -6567,6 +7182,57 @@ function sensor_types(parent){
|
|
|
6567
7182
|
adc: signInt(d.slice(0, 2).reduce(msbLsb), 16),
|
|
6568
7183
|
vdc: signInt(d.slice(2, 4).reduce(msbLsb), 16)/100
|
|
6569
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
|
+
}
|
|
6570
7236
|
}
|
|
6571
7237
|
},
|
|
6572
7238
|
'97': {
|
|
@@ -7215,22 +7881,73 @@ function sensor_types(parent){
|
|
|
7215
7881
|
device_temp: device_temp,
|
|
7216
7882
|
external_temp: external_temperature
|
|
7217
7883
|
}
|
|
7218
|
-
globalDevices[deviceAddr].data[current_packet] = payload.slice(data_start);
|
|
7219
|
-
return;
|
|
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
|
+
}
|
|
7220
7947
|
}
|
|
7221
7948
|
}
|
|
7222
7949
|
}
|
|
7223
7950
|
},
|
|
7224
|
-
'105': {
|
|
7225
|
-
name: '1 Channel Automatic Luber With Ultrasound Vibration Sensor',
|
|
7226
|
-
parse: (d) => {
|
|
7227
|
-
return {
|
|
7228
|
-
raw_adc: d.slice(0, 2).reduce(msbLsb),
|
|
7229
|
-
ma: d.slice(2, 4).reduce(msbLsb) / 100,
|
|
7230
|
-
db: d.slice(4, 6).reduce(msbLsb) / 100
|
|
7231
|
-
};
|
|
7232
|
-
}
|
|
7233
|
-
},
|
|
7234
7951
|
'106': {
|
|
7235
7952
|
name: '2 Channel Automatic Luber With Ultrasound Vibration Sensor',
|
|
7236
7953
|
parse: (d) => {
|
|
@@ -7242,6 +7959,57 @@ function sensor_types(parent){
|
|
|
7242
7959
|
c2_ma: d.slice(8, 10).reduce(msbLsb) / 100,
|
|
7243
7960
|
c2_db: d.slice(10, 12).reduce(msbLsb) / 100
|
|
7244
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
|
+
}
|
|
7245
8013
|
}
|
|
7246
8014
|
},
|
|
7247
8015
|
'107': {
|
|
@@ -7265,6 +8033,57 @@ function sensor_types(parent){
|
|
|
7265
8033
|
ma3: ma3,
|
|
7266
8034
|
ma4: ma4
|
|
7267
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
|
+
}
|
|
7268
8087
|
}
|
|
7269
8088
|
},
|
|
7270
8089
|
'108': {
|
|
@@ -7493,6 +8312,172 @@ function sensor_types(parent){
|
|
|
7493
8312
|
}
|
|
7494
8313
|
}
|
|
7495
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
|
+
}
|
|
8478
|
+
}
|
|
8479
|
+
}
|
|
8480
|
+
},
|
|
7496
8481
|
'109': {
|
|
7497
8482
|
name: 'Wireless Custom Solar Sensor',
|
|
7498
8483
|
parse: (d) => {
|
|
@@ -10211,21 +11196,30 @@ function sensor_types(parent){
|
|
|
10211
11196
|
|
|
10212
11197
|
odr: payload.slice(10, 12).reduce(msbLsb),
|
|
10213
11198
|
temperature: signInt(payload.slice(12, 14).reduce(msbLsb), 16) / 100,
|
|
10214
|
-
|
|
10215
|
-
|
|
10216
|
-
|
|
10217
|
-
|
|
10218
|
-
|
|
10219
|
-
|
|
10220
|
-
|
|
10221
|
-
|
|
10222
|
-
|
|
10223
|
-
|
|
10224
|
-
|
|
10225
|
-
|
|
10226
|
-
|
|
10227
|
-
|
|
10228
|
-
|
|
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),
|
|
10229
11223
|
};
|
|
10230
11224
|
}
|
|
10231
11225
|
// else{
|
|
@@ -10235,17 +11229,19 @@ function sensor_types(parent){
|
|
|
10235
11229
|
},
|
|
10236
11230
|
'parse_fly': (frame) => {
|
|
10237
11231
|
return {
|
|
10238
|
-
'fly_rate': frame.slice(12,
|
|
11232
|
+
'fly_rate': frame.slice(12, 14).reduce(msbLsb) + " Min.",
|
|
10239
11233
|
'fsr': frame[14],
|
|
10240
|
-
'
|
|
10241
|
-
'
|
|
10242
|
-
'
|
|
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),
|
|
10243
11238
|
'machine_values': {
|
|
10244
|
-
'fly_rate': frame.slice(12,
|
|
11239
|
+
'fly_rate': frame.slice(12, 14),
|
|
10245
11240
|
'fsr':frame[14],
|
|
10246
|
-
'
|
|
10247
|
-
'
|
|
10248
|
-
'
|
|
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)
|
|
10249
11245
|
}
|
|
10250
11246
|
}
|
|
10251
11247
|
}
|
|
@@ -12871,6 +13867,57 @@ function sensor_types(parent){
|
|
|
12871
13867
|
ma: d.slice(2, 4).reduce(msbLsb) / 100,
|
|
12872
13868
|
flow_ltr_min: d.slice(4, 8).reduce(msbLsb) / 100
|
|
12873
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
|
+
}
|
|
12874
13921
|
}
|
|
12875
13922
|
},
|
|
12876
13923
|
'1010': {
|