@ncd-io/node-red-enterprise-sensors 0.1.5 → 0.1.7

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 +74 -3
  2. package/package.json +1 -1
  3. package/wireless.html +134 -87
  4. package/wireless.js +963 -877
package/wireless.js CHANGED
@@ -182,902 +182,988 @@ module.exports = function(RED) {
182
182
 
183
183
 
184
184
  function NcdWirelessNode(config){
185
- RED.nodes.createNode(this,config);
186
- this.gateway_node = RED.nodes.getNode(config.connection);
187
- this.gateway_node.open_comms();
188
- this.gateway = this.gateway_node.gateway;
189
- var dedicated_config = false;
190
- this.config_gateway = this.gateway;
185
+ RED.nodes.createNode(this,config);
186
+ this.gateway_node = RED.nodes.getNode(config.connection);
187
+ this.gateway_node.open_comms();
188
+ this.gateway = this.gateway_node.gateway;
189
+ var dedicated_config = false;
190
+ this.config_gateway = this.gateway;
191
191
 
192
- if(config.config_comm){
193
- this.config_gateway_node = RED.nodes.getNode(config.config_comm);
194
- this.config_gateway_node.open_comms();
195
- this.config_gateway = this.config_gateway_node.gateway;
196
- dedicated_config = true;
197
- }
198
- this.queue = new Queue(1);
199
- var node = this;
200
- var modes = {
201
- PGM: {fill:"red",shape:"dot",text:"Config Mode"},
202
- PGM_NOW: {fill:"red",shape:"dot",text:"Configuring..."},
203
- READY: {fill: "green", shape: "ring", text:"Config Complete"},
204
- PGM_ERR: {fill:"red", shape:"ring", text:"Config Error"},
205
- RUN: {fill:"green",shape:"dot",text:"Running"},
206
- PUM: {fill:"yellow",shape:"ring",text:"Module was factory reset"},
207
- ACK: {fill:"green",shape:"ring",text:"Configuration Acknowledged"},
208
- // FLY: {fill:"yellow",shape:"ring",text:"FLY notification received"},
209
- // OTN: {fill:"yellow",shape:"ring",text:"OTN Received, OTF Configuration Initiated"},
210
- // OFF: {fill:"green",shape:"dot",text:"OFF Recieved, OTF Configuration Completed"}
211
- FLY: {fill:"yellow",shape:"ring",text:"FLY"},
212
- OTN: {fill:"yellow",shape:"ring",text:"OTN Received, Config Entered"},
213
- OTF: {fill:"green",shape:"dot",text:"OTF Received, Config Complete"}
214
- };
215
- var events = {};
216
- var pgm_events = {};
217
- this.gtw_on = (event, cb) => {
218
- events[event] = cb;
219
- this.gateway.on(event, cb);
220
- };
221
- this.pgm_on = (event, cb) => {
222
- events[event] = cb;
223
- this.config_gateway.on(event, cb);
224
- };
225
- function _send_otn_request(sensor){
226
- return new Promise((top_fulfill, top_reject) => {
227
- var msg = {};
228
- setTimeout(() => {
229
- var tout = setTimeout(() => {
230
- node.status(modes.PGM_ERR);
231
- node.send({topic: 'OTN Request Results', payload: msg, time: Date.now()});
232
- }, 10000);
192
+ if(config.config_comm){
193
+ this.config_gateway_node = RED.nodes.getNode(config.config_comm);
194
+ this.config_gateway_node.open_comms();
195
+ this.config_gateway = this.config_gateway_node.gateway;
196
+ dedicated_config = true;
197
+ }
198
+ this.queue = new Queue(1);
199
+ var node = this;
200
+ var modes = {
201
+ PGM: {fill:"red",shape:"dot",text:"Config Mode"},
202
+ PGM_NOW: {fill:"red",shape:"dot",text:"Configuring..."},
203
+ READY: {fill: "green", shape: "ring", text:"Config Complete"},
204
+ PGM_ERR: {fill:"red", shape:"ring", text:"Config Error"},
205
+ RUN: {fill:"green",shape:"dot",text:"Running"},
206
+ PUM: {fill:"yellow",shape:"ring",text:"Module was factory reset"},
207
+ ACK: {fill:"green",shape:"ring",text:"Configuration Acknowledged"},
208
+ // FLY: {fill:"yellow",shape:"ring",text:"FLY notification received"},
209
+ // OTN: {fill:"yellow",shape:"ring",text:"OTN Received, OTF Configuration Initiated"},
210
+ // OFF: {fill:"green",shape:"dot",text:"OFF Recieved, OTF Configuration Completed"}
211
+ FLY: {fill:"yellow",shape:"ring",text:"FLY"},
212
+ OTN: {fill:"yellow",shape:"ring",text:"OTN Received, Config Entered"},
213
+ OTF: {fill:"green",shape:"dot",text:"OTF Received, Config Complete"}
214
+ };
215
+ var events = {};
216
+ var pgm_events = {};
217
+ this.gtw_on = (event, cb) => {
218
+ events[event] = cb;
219
+ this.gateway.on(event, cb);
220
+ };
221
+ this.pgm_on = (event, cb) => {
222
+ events[event] = cb;
223
+ this.config_gateway.on(event, cb);
224
+ };
225
+ function _send_otn_request(sensor){
226
+ return new Promise((top_fulfill, top_reject) => {
227
+ var msg = {};
228
+ setTimeout(() => {
229
+ var tout = setTimeout(() => {
230
+ node.status(modes.PGM_ERR);
231
+ node.send({topic: 'OTN Request Results', payload: msg, time: Date.now()});
232
+ }, 10000);
233
233
 
234
- var promises = {};
235
- // This command is used for OTF on types 53, 80,81,82,83,84, 101, 102 , 518,519
236
- let original_otf_devices = [53, 80, 81, 82, 83, 84, 101, 102 , 518, 519, 520];
237
- if(original_otf_devices.includes(sensor.type)){
238
- // This command is used for OTF on types 53, 80,81,82,83,84, 101, 102 , 518,519
239
- promises.config_enter_otn_mode = node.config_gateway.config_enter_otn_mode(sensor.mac);
240
- }else{
241
- // This command is used for OTF on types not 53, 80,81,82,83,84, 101, 102 , 518,519
242
- promises.config_enter_otn_mode = node.config_gateway.config_enter_otn_mode_common(sensor.mac);
243
- }
244
- promises.finish = new Promise((fulfill, reject) => {
245
- node.config_gateway.queue.add(() => {
246
- return new Promise((f, r) => {
247
- clearTimeout(tout);
248
- node.status(modes.FLY);
249
- fulfill();
250
- f();
251
- });
252
- });
253
- });
254
- for(var i in promises){
255
- (function(name){
256
- promises[name].then((f) => {
257
- if(name != 'finish') msg[name] = true;
258
- else{
259
- // #OTF
260
- node.send({topic: 'OTN Request Results', payload: msg, time: Date.now()});
261
- top_fulfill(msg);
262
- }
263
- }).catch((err) => {
264
- msg[name] = err;
265
- });
266
- })(i);
267
- }
268
- });
269
- });
270
- };
271
- function _broadcast_rtc(sensor){
272
- return new Promise((top_fulfill, top_reject) => {
273
- var msg = {};
274
- setTimeout(() => {
275
- var tout = setTimeout(() => {
276
- node.status(modes.PGM_ERR);
277
- node.send({topic: 'RTC Broadcast', payload: msg, time: Date.now()});
278
- }, 10000);
234
+ var promises = {};
235
+ // This command is used for OTF on types 53, 80,81,82,83,84, 101, 102 , 518,519
236
+ let original_otf_devices = [53, 80, 81, 82, 83, 84, 101, 102 , 518, 519, 520];
237
+ if(original_otf_devices.includes(sensor.type)){
238
+ // This command is used for OTF on types 53, 80,81,82,83,84, 101, 102 , 518,519
239
+ promises.config_enter_otn_mode = node.config_gateway.config_enter_otn_mode(sensor.mac);
240
+ }else{
241
+ // This command is used for OTF on types not 53, 80,81,82,83,84, 101, 102 , 518,519
242
+ promises.config_enter_otn_mode = node.config_gateway.config_enter_otn_mode_common(sensor.mac);
243
+ }
244
+ promises.finish = new Promise((fulfill, reject) => {
245
+ node.config_gateway.queue.add(() => {
246
+ return new Promise((f, r) => {
247
+ clearTimeout(tout);
248
+ node.status(modes.FLY);
249
+ fulfill();
250
+ f();
251
+ });
252
+ });
253
+ });
254
+ for(var i in promises){
255
+ (function(name){
256
+ promises[name].then((f) => {
257
+ if(name != 'finish') msg[name] = true;
258
+ else{
259
+ // #OTF
260
+ node.send({topic: 'OTN Request Results', payload: msg, time: Date.now()});
261
+ top_fulfill(msg);
262
+ }
263
+ }).catch((err) => {
264
+ msg[name] = err;
265
+ });
266
+ })(i);
267
+ }
268
+ });
269
+ });
270
+ };
271
+ function _broadcast_rtc(sensor){
272
+ return new Promise((top_fulfill, top_reject) => {
273
+ var msg = {};
274
+ setTimeout(() => {
275
+ var tout = setTimeout(() => {
276
+ node.status(modes.PGM_ERR);
277
+ node.send({topic: 'RTC Broadcast', payload: msg, time: Date.now()});
278
+ }, 10000);
279
279
 
280
- var promises = {};
280
+ var promises = {};
281
281
 
282
- promises.broadcast_rtc = node.config_gateway.config_set_rtc_101('00:00:00:00:00:00:FF:FF');
282
+ promises.broadcast_rtc = node.config_gateway.config_set_rtc_101('00:00:00:00:00:00:FF:FF');
283
283
 
284
- promises.finish = new Promise((fulfill, reject) => {
285
- node.config_gateway.queue.add(() => {
286
- return new Promise((f, r) => {
287
- clearTimeout(tout);
288
- node.status(modes.FLY);
289
- fulfill();
290
- f();
291
- });
292
- });
293
- });
294
- for(var i in promises){
295
- (function(name){
296
- promises[name].then((f) => {
297
- if(name != 'finish') msg[name] = true;
298
- else{
299
- // #OTF
300
- this.gateway.fly_101_in_progress = false;
301
- node.send({topic: 'RTC Broadcast', payload: msg, time: Date.now()});
302
- top_fulfill(msg);
303
- }
304
- }).catch((err) => {
305
- msg[name] = err;
306
- });
307
- })(i);
308
- }
309
- });
310
- });
311
- }
312
- function _config(sensor, otf = false){
313
- return new Promise((top_fulfill, top_reject) => {
314
- var success = {};
315
- setTimeout(() => {
316
- var tout = setTimeout(() => {
317
- node.status(modes.PGM_ERR);
318
- node.send({topic: 'Config Results', payload: success, time: Date.now()});
319
- }, 60000);
320
- node.status(modes.PGM_NOW);
321
- if(parseInt(config.sensor_type) >= 10000){
322
- if(sensor) return;
323
- var dest = parseInt(config.destination, 16);
324
- if(dest == 65535){
325
- dest = [0,0,0,0,0,0,255,255];
326
- }else{
327
- dest = [0, 0x13, 0xa2, 0, ...int2Bytes(dest, 4)];
328
- }
329
- var promises = {
330
- destination: node.gateway.config_powered_device(config.addr, 'destination', ...dest),
331
- network_id: node.gateway.config_powered_device(config.addr, 'network_id', ...int2Bytes(parseInt(config.pan_id, 16), 2)),
332
- power: node.gateway.config_powered_device(config.addr, 'power', parseInt(config.power)),
333
- retries: node.gateway.config_powered_device(config.addr, 'retries', parseInt(config.retries)),
334
- node_id: node.gateway.config_powered_device(config.addr, 'node_id', parseInt(config.node_id)),
335
- delay: node.gateway.config_powered_device(config.addr, 'delay', ...int2Bytes(parseInt(config.delay), 2))
336
- };
337
- }else{
338
- var mac = sensor.mac;
339
- var promises = {};
340
- var reboot = false;
341
- if(config.form_network){
342
- promises.establish_config_network_1 = node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF');
343
- promises.establish_config_network_2 = node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF');
344
- promises.establish_config_network_3 = node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF');
345
- }
346
- if(config.destination_active){
347
- promises.destination = node.config_gateway.config_set_destination(mac, parseInt(config.destination, 16));
348
- }
349
- if(config.pan_id_active){
350
- reboot = true;
351
- promises.network_id = node.config_gateway.config_set_pan_id(mac, parseInt(config.pan_id, 16));
352
- }
353
- // var promises = {
354
- // // NOTE: establish_config_network_x commands added to force XBee network to form before sending commands.
355
- // establish_config_network_1: node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF'),
356
- // establish_config_network_2: node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF'),
357
- // establish_config_network_3: node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF'),
358
- //
359
- // destination: node.config_gateway.config_set_destination(mac, parseInt(config.destination, 16)),
360
- // network_id: node.config_gateway.config_set_pan_id(mac, parseInt(config.pan_id, 16))
361
- // };
362
- if(config.node_id_delay_active){
363
- promises.id_and_delay = node.config_gateway.config_set_id_delay(mac, parseInt(config.node_id), parseInt(config.delay));
364
- }
365
- if(config.power_active){
366
- promises.power = node.config_gateway.config_set_power(mac, parseInt(config.power));
367
- }
368
- if(config.retries_active){
369
- promises.retries = node.config_gateway.config_set_retries(mac, parseInt(config.retries));
370
- }
371
- var change_detection = [13, 10, 3];
372
- if(change_detection.indexOf(sensor.type) > -1){
373
- promises.change_detection = node.config_gateway.config_set_change_detection(mac, config.change_enabled ? 1 : 0, parseInt(config.change_pr), parseInt(config.change_interval));
374
- }
375
- switch(sensor.type){
376
- case 5:
377
- promises.acceleration_range = node.config_gateway.config_set_amgt_accel(mac, parseInt(config.amgt_accel));
378
- promises.magnetometer_gain = node.config_gateway.config_set_amgt_magnet(mac, parseInt(config.amgt_mag));
379
- promises.gyroscope_scale = node.config_gateway.config_set_amgt_gyro(mac, parseInt(config.amgt_gyro));
380
- break;
381
- case 6:
382
- promises.altitude = node.config_gateway.config_set_bp_altitude(mac, parseInt(config.bp_altitude));
383
- promises.pressure = node.config_gateway.config_set_bp_pressure(mac, parseInt(config.bp_pressure));
384
- promises.temp_precision = node.config_gateway.config_set_bp_temp_precision(mac, parseInt(config.bp_temp_prec));
385
- promises.pressure_precision = node.config_gateway.config_set_bp_press_precision(mac, parseInt(config.bp_press_prec));
386
- break;
387
- case 7:
388
- promises.acceleration_range = node.config_gateway.config_set_impact_accel(mac, parseInt(config.impact_accel));
389
- promises.data_rate = node.config_gateway.config_set_impact_data_rate(mac, parseInt(config.impact_data_rate));
390
- promises.impact_threshold = node.config_gateway.config_set_impact_threshold(mac, parseInt(config.impact_threshold));
391
- promises.impact_duration = node.config_gateway.config_set_impact_duration(mac, parseInt(config.impact_duration));
392
- break;
393
- case 13:
394
- var cali = parseFloat(config.cm_calibration);
395
- if(cali == 0) break;
396
- promises.calibration = node.config_gateway.config_set_cm_calibration(mac, cali);
397
- break;
398
- case 14:
399
- if(config.sensor_boot_time_420ma_active){
400
- promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
401
- }
402
- break;
403
- case 24:
404
- var interr = parseInt(config.activ_interr_x) | parseInt(config.activ_interr_y) | parseInt(config.activ_interr_z) | parseInt(config.activ_interr_op);
405
- promises.activity_interrupt = node.config_gateway.config_set_activ_interr(mac, interr);
406
- case 35:
407
- if(config.counter_threshold_35_active){
408
- promises.config_set_counter_threshold_35 = node.config_gateway.config_set_counter_threshold_35(mac, parseInt(config.counter_threshold_35));
409
- }
410
- break;
411
- case 36:
412
- if(config.counter_threshold_35_active){
413
- promises.config_set_counter_threshold_35 = node.config_gateway.config_set_counter_threshold_35(mac, parseInt(config.counter_threshold_35));
414
- }
415
- break;
416
- case 40:
417
- promises.filtering = node.config_gateway.config_set_filtering(mac, parseInt(config.filtering));
418
- promises.data_rate = node.config_gateway.config_set_data_rate(mac, parseInt(config.data_rate));
419
- promises.time_series = node.config_gateway.config_set_time_series(mac, parseInt(config.time_series));
420
- promises.reading_type = node.config_gateway.config_set_reading_type(mac, parseInt(config.reading_type));
421
- break;
422
- case 44:
423
- if(config.force_calibration_co2_auto_config){
424
- promises.sensor_forced_calibration = node.config_gateway.config_set_sensor_forced_calibration(mac, parseInt(config.force_calibration_co2));
425
- }
426
- break;
427
- case 45:
428
- if(config.sensor_boot_time_420ma_active){
429
- promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
430
- }
431
- break;
284
+ promises.finish = new Promise((fulfill, reject) => {
285
+ node.config_gateway.queue.add(() => {
286
+ return new Promise((f, r) => {
287
+ clearTimeout(tout);
288
+ node.status(modes.FLY);
289
+ fulfill();
290
+ f();
291
+ });
292
+ });
293
+ });
294
+ for(var i in promises){
295
+ (function(name){
296
+ promises[name].then((f) => {
297
+ if(name != 'finish') msg[name] = true;
298
+ else{
299
+ // #OTF
300
+ this.gateway.fly_101_in_progress = false;
301
+ node.send({topic: 'RTC Broadcast', payload: msg, time: Date.now()});
302
+ top_fulfill(msg);
303
+ }
304
+ }).catch((err) => {
305
+ msg[name] = err;
306
+ });
307
+ })(i);
308
+ }
309
+ });
310
+ });
311
+ }
312
+ function _config(sensor, otf = false){
313
+ return new Promise((top_fulfill, top_reject) => {
314
+ var success = {};
315
+ setTimeout(() => {
316
+ var tout = setTimeout(() => {
317
+ node.status(modes.PGM_ERR);
318
+ node.send({topic: 'Config Results', payload: success, time: Date.now()});
319
+ }, 60000);
320
+ node.status(modes.PGM_NOW);
321
+ if(parseInt(config.sensor_type) >= 10000){
322
+ if(sensor) return;
323
+ var dest = parseInt(config.destination, 16);
324
+ if(dest == 65535){
325
+ dest = [0,0,0,0,0,0,255,255];
326
+ }else{
327
+ dest = [0, 0x13, 0xa2, 0, ...int2Bytes(dest, 4)];
328
+ }
329
+ var promises = {
330
+ destination: node.gateway.config_powered_device(config.addr, 'destination', ...dest),
331
+ network_id: node.gateway.config_powered_device(config.addr, 'network_id', ...int2Bytes(parseInt(config.pan_id, 16), 2)),
332
+ power: node.gateway.config_powered_device(config.addr, 'power', parseInt(config.power)),
333
+ retries: node.gateway.config_powered_device(config.addr, 'retries', parseInt(config.retries)),
334
+ node_id: node.gateway.config_powered_device(config.addr, 'node_id', parseInt(config.node_id)),
335
+ delay: node.gateway.config_powered_device(config.addr, 'delay', ...int2Bytes(parseInt(config.delay), 2))
336
+ };
337
+ }else{
338
+ var mac = sensor.mac;
339
+ var promises = {};
340
+ var reboot = false;
341
+ if(config.form_network){
342
+ promises.establish_config_network_1 = node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF');
343
+ promises.establish_config_network_2 = node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF');
344
+ promises.establish_config_network_3 = node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF');
345
+ }
346
+ if(config.destination_active){
347
+ promises.destination = node.config_gateway.config_set_destination(mac, parseInt(config.destination, 16));
348
+ }
349
+ if(config.pan_id_active){
350
+ reboot = true;
351
+ promises.network_id = node.config_gateway.config_set_pan_id(mac, parseInt(config.pan_id, 16));
352
+ }
353
+ // var promises = {
354
+ // // NOTE: establish_config_network_x commands added to force XBee network to form before sending commands.
355
+ // establish_config_network_1: node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF'),
356
+ // establish_config_network_2: node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF'),
357
+ // establish_config_network_3: node.config_gateway.config_get_pan_id('00:00:00:00:00:00:FF:FF'),
358
+ //
359
+ // destination: node.config_gateway.config_set_destination(mac, parseInt(config.destination, 16)),
360
+ // network_id: node.config_gateway.config_set_pan_id(mac, parseInt(config.pan_id, 16))
361
+ // };
362
+ if(config.node_id_delay_active){
363
+ promises.id_and_delay = node.config_gateway.config_set_id_delay(mac, parseInt(config.node_id), parseInt(config.delay));
364
+ }
365
+ if(config.power_active){
366
+ promises.power = node.config_gateway.config_set_power(mac, parseInt(config.power));
367
+ }
368
+ if(config.retries_active){
369
+ promises.retries = node.config_gateway.config_set_retries(mac, parseInt(config.retries));
370
+ }
371
+ var change_detection = [13, 10, 3];
372
+ if(change_detection.indexOf(sensor.type) > -1){
373
+ promises.change_detection = node.config_gateway.config_set_change_detection(mac, config.change_enabled ? 1 : 0, parseInt(config.change_pr), parseInt(config.change_interval));
374
+ }
375
+ switch(sensor.type){
376
+ case 3:
377
+ if(config.low_calibration_420ma_active){
378
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
379
+ }
380
+ if(config.mid_calibration_420ma_active){
381
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
382
+ }
383
+ if(config.high_calibration_420ma_active){
384
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
385
+ }
386
+ break;
387
+ case 5:
388
+ promises.acceleration_range = node.config_gateway.config_set_amgt_accel(mac, parseInt(config.amgt_accel));
389
+ promises.magnetometer_gain = node.config_gateway.config_set_amgt_magnet(mac, parseInt(config.amgt_mag));
390
+ promises.gyroscope_scale = node.config_gateway.config_set_amgt_gyro(mac, parseInt(config.amgt_gyro));
391
+ break;
392
+ case 6:
393
+ promises.altitude = node.config_gateway.config_set_bp_altitude(mac, parseInt(config.bp_altitude));
394
+ promises.pressure = node.config_gateway.config_set_bp_pressure(mac, parseInt(config.bp_pressure));
395
+ promises.temp_precision = node.config_gateway.config_set_bp_temp_precision(mac, parseInt(config.bp_temp_prec));
396
+ promises.pressure_precision = node.config_gateway.config_set_bp_press_precision(mac, parseInt(config.bp_press_prec));
397
+ break;
398
+ case 7:
399
+ promises.acceleration_range = node.config_gateway.config_set_impact_accel(mac, parseInt(config.impact_accel));
400
+ promises.data_rate = node.config_gateway.config_set_impact_data_rate(mac, parseInt(config.impact_data_rate));
401
+ promises.impact_threshold = node.config_gateway.config_set_impact_threshold(mac, parseInt(config.impact_threshold));
402
+ promises.impact_duration = node.config_gateway.config_set_impact_duration(mac, parseInt(config.impact_duration));
403
+ break;
404
+ case 13:
405
+ var cali = parseFloat(config.cm_calibration);
406
+ if(cali == 0) break;
407
+ promises.calibration = node.config_gateway.config_set_cm_calibration(mac, cali);
408
+ break;
409
+ case 14:
410
+ if(config.sensor_boot_time_420ma_active){
411
+ promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
412
+ }
413
+ if(config.low_calibration_420ma_active){
414
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
415
+ }
416
+ if(config.mid_calibration_420ma_active){
417
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
418
+ }
419
+ if(config.high_calibration_420ma_active){
420
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
421
+ }
422
+ break;
423
+ case 24:
424
+ var interr = parseInt(config.activ_interr_x) | parseInt(config.activ_interr_y) | parseInt(config.activ_interr_z) | parseInt(config.activ_interr_op);
425
+ promises.activity_interrupt = node.config_gateway.config_set_activ_interr(mac, interr);
426
+ case 35:
427
+ if(config.counter_threshold_35_active){
428
+ promises.config_set_counter_threshold_35 = node.config_gateway.config_set_counter_threshold_35(mac, parseInt(config.counter_threshold_35));
429
+ }
430
+ break;
431
+ case 36:
432
+ if(config.counter_threshold_35_active){
433
+ promises.config_set_counter_threshold_35 = node.config_gateway.config_set_counter_threshold_35(mac, parseInt(config.counter_threshold_35));
434
+ }
435
+ break;
436
+ case 40:
437
+ promises.filtering = node.config_gateway.config_set_filtering(mac, parseInt(config.filtering));
438
+ promises.data_rate = node.config_gateway.config_set_data_rate(mac, parseInt(config.data_rate));
439
+ promises.time_series = node.config_gateway.config_set_time_series(mac, parseInt(config.time_series));
440
+ promises.reading_type = node.config_gateway.config_set_reading_type(mac, parseInt(config.reading_type));
441
+ break;
442
+ case 44:
443
+ if(config.force_calibration_co2_auto_config){
444
+ promises.sensor_forced_calibration = node.config_gateway.config_set_sensor_forced_calibration(mac, parseInt(config.force_calibration_co2));
445
+ }
446
+ break;
447
+ case 45:
448
+ if(config.sensor_boot_time_420ma_active){
449
+ promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
450
+ }
451
+ if(config.low_calibration_420ma_active){
452
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
453
+ }
454
+ if(config.mid_calibration_420ma_active){
455
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
456
+ }
457
+ if(config.high_calibration_420ma_active){
458
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
459
+ }
460
+ break;
432
461
  case 46:
433
462
  if(config.motion_threshold_46_active){
434
463
  promises.motion_threshold_46 = node.config_gateway.config_set_motion_threshold_46(mac, parseInt(config.motion_threshold_46));
435
464
  }
436
465
  break;
437
- case 47:
438
- if(config.roll_angle_threshold_47_active){
439
- promises.roll_angle_threshold_47 = node.config_gateway.config_set_roll_threshold_47(mac, parseInt(config.roll_angle_threshold_47));
440
- }
441
- if(config.pitch_angle_threshold_47_active){
442
- promises.pitch_angle_threshold_47 = node.config_gateway.config_set_pitch_threshold_47(mac, parseInt(config.pitch_angle_threshold_47));
443
- }
444
- break;
445
- case 48:
446
- if(config.sensor_boot_time_420ma_active){
447
- promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
448
- }
449
- break;
450
- case 52:
451
- if(config.sensor_boot_time_420ma_active){
452
- promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
453
- }
454
- break;
455
- case 80:
456
- if(config.current_calibration_c1_80_active){
457
- promises.current_calibration_c1_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
458
- }
459
- if(config.output_data_rate_101_active){
460
- promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
461
- }
462
- if(config.sampling_duration_101_active){
463
- promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
464
- }
465
- if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
466
- promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
467
- }
468
- if(config.sampling_interval_101_active){
469
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
470
- }
471
- if(config.full_scale_range_101_active){
472
- promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
473
- }
474
- if(config.mode_80_active){
475
- promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
476
- }
477
- if(config.filter_80_active){
478
- promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
479
- }
480
- if(config.low_pass_filter_80_active){
481
- promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
482
- }
483
- if(config.high_pass_filter_80_active){
484
- promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
485
- }
486
- if(config.measurement_mode_80_active){
487
- promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
488
- }
489
- if(config.on_request_timeout_80_active){
490
- promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
491
- }
492
- if(config.deadband_80_active){
493
- promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
494
- }
495
- if(config.payload_length_80_active){
496
- promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
497
- }
498
- if(config.set_rtc_101){
499
- promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
500
- }
501
- break;
502
- case 81:
503
- if(config.current_calibration_c1_80_active){
504
- promises.current_calibration_c1_80_active = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
505
- }
506
- if(config.current_calibration_c2_80_active){
507
- promises.current_calibration_c2_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c2_80), 3);
508
- }
509
- if(config.output_data_rate_p1_81_active){
510
- promises.output_data_rate_p1_81 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_p1_81));
511
- }
512
- if(config.output_data_rate_p2_81_active){
513
- promises.output_data_rate_p2_81 = node.config_gateway.config_set_output_data_rate_p2_81(mac, parseInt(config.output_data_rate_p2_81));
514
- }
515
- if(config.sampling_duration_p1_81_active){
516
- promises.sampling_duration_p1_81 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_p1_81));
517
- }
518
- if(config.sampling_duration_p2_81_active){
519
- promises.sampling_duration_p2_81 = node.config_gateway.config_set_sampling_duration_p2_81(mac, parseInt(config.sampling_duration_p2_81));
520
- }
521
- if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
522
- promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
523
- }
524
- if(config.sampling_interval_101_active){
525
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
526
- }
527
- if(config.full_scale_range_101_active){
528
- promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
529
- }
530
- if(config.mode_80_active){
531
- promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
532
- }
533
- if(config.filter_80_active){
534
- promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
535
- }
536
- if(config.low_pass_filter_80_active){
537
- promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
538
- }
539
- if(config.high_pass_filter_80_active){
540
- promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
541
- }
542
- if(config.low_pass_filter_81_p2_active){
543
- promises.low_pass_filter_p2 = node.config_gateway.config_set_low_pass_filter_81_p2(mac, parseInt(config.low_pass_filter_81_p2));
544
- }
545
- if(config.high_pass_filter_81_p2_active){
546
- promises.high_pass_filter_p2 = node.config_gateway.config_set_high_pass_filter_81_p2(mac, parseInt(config.high_pass_filter_81_p2));
547
- }
548
- if(config.measurement_mode_80_active){
549
- promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
550
- }
551
- if(config.on_request_timeout_80_active){
552
- promises.on_request_timeout = node.config_gateway.config_set_on_request_timeout_80(mac, parseInt(config.on_request_timeout_80));
553
- }
554
- if(config.deadband_80_active){
555
- promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
556
- }
557
- if(config.payload_length_80_active){
558
- promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
559
- }
560
- if(config.set_rtc_101){
561
- promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
562
- }
563
- break;
564
- case 82:
565
- if(config.current_calibration_82_active){
566
- promises.current_calibration_82 = node.config_gateway.config_set_current_calibration_82(mac, parseInt(config.current_calibration_82));
567
- }
568
- if(config.output_data_rate_101_active){
569
- promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
570
- }
571
- if(config.sampling_duration_101_active){
572
- promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
573
- }
574
- if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
575
- promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
576
- }
577
- if(config.sampling_interval_101_active){
578
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
579
- }
580
- if(config.full_scale_range_101_active){
581
- promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
582
- }
583
- if(config.mode_80_active){
584
- promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
585
- }
586
- if(config.filter_80_active){
587
- promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
588
- }
589
- if(config.low_pass_filter_80_active){
590
- promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
591
- }
592
- if(config.high_pass_filter_80_active){
593
- promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
594
- }
595
- if(config.measurement_mode_80_active){
596
- promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
597
- }
598
- if(config.on_request_timeout_80_active){
599
- promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
600
- }
601
- if(config.deadband_80_active){
602
- promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
603
- }
604
- if(config.payload_length_80_active){
605
- promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
606
- }
607
- if(config.set_rtc_101){
608
- promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
609
- }
610
- break;
611
- case 84:
612
- if(config.output_data_rate_101_active){
613
- promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
614
- }
615
- if(config.sampling_duration_101_active){
616
- promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
617
- }
618
- if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
619
- promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
620
- }
621
- if(config.sampling_interval_101_active){
622
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
623
- }
624
- if(config.full_scale_range_101_active){
625
- promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
626
- }
627
- if(config.mode_80_active){
628
- promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
629
- }
630
- if(config.filter_80_active){
631
- promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
632
- }
633
- if(config.low_pass_filter_80_active){
634
- promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
635
- }
636
- if(config.high_pass_filter_80_active){
637
- promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
638
- }
639
- if(config.measurement_mode_80_active){
640
- promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
641
- }
642
- if(config.on_request_timeout_80_active){
643
- promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
644
- }
645
- if(config.deadband_80_active){
646
- promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
647
- }
648
- if(config.led_alert_mode_84_active){
649
- promises.led_alert_mode_84 = node.config_gateway.config_set_led_alert_mode_84(mac, parseInt(config.led_alert_mode_84));
650
- }
651
- if(config.led_accelerometer_threshold_84_active){
652
- promises.led_accelerometer_threshold_84 = node.config_gateway.config_set_led_accelerometer_threshold_84(mac, parseInt(config.led_accelerometer_threshold_84));
653
- }
654
- if(config.led_velocity_threshold_84_active){
655
- promises.led_velocity_threshold_84 = node.config_gateway.config_set_led_velocity_threshold_84(mac, parseInt(config.led_velocity_threshold_84));
656
- }
657
- if(config.acceleration_interrupt_threshold_84_active){
658
- promises.acceleration_interrupt_threshold_84 = node.config_gateway.config_set_acceleration_interrupt_threshold_84(mac, parseInt(config.acceleration_interrupt_threshold_84));
659
- }
660
- if(config.payload_length_80_active){
661
- promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
662
- }
663
- if(config.set_rtc_101){
664
- promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
665
- }
666
- break;
667
- case 101:
668
- if(config.output_data_rate_101_m2_active){
669
- promises.output_data_rate_101_m2 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101_m2));
670
- }
671
- if(config.sampling_duration_101_active){
672
- promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
673
- }
674
- if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
675
- promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
676
- }
677
- if(config.sampling_interval_101_active){
678
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
679
- }
680
- if(config.full_scale_range_101_m2_active){
681
- promises.full_scale_range_101_m2 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101_m2));
682
- }
683
- // promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
684
- break;
685
- case 102:
686
- if(config.output_data_rate_101_active){
687
- promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
688
- }
689
- if(config.sampling_duration_101_active){
690
- promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
691
- }
466
+ case 47:
467
+ if(config.roll_angle_threshold_47_active){
468
+ promises.roll_angle_threshold_47 = node.config_gateway.config_set_roll_threshold_47(mac, parseInt(config.roll_angle_threshold_47));
469
+ }
470
+ if(config.pitch_angle_threshold_47_active){
471
+ promises.pitch_angle_threshold_47 = node.config_gateway.config_set_pitch_threshold_47(mac, parseInt(config.pitch_angle_threshold_47));
472
+ }
473
+ break;
474
+ case 48:
475
+ if(config.sensor_boot_time_420ma_active){
476
+ promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
477
+ }
478
+ if(config.low_calibration_420ma_active){
479
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
480
+ }
481
+ if(config.mid_calibration_420ma_active){
482
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
483
+ }
484
+ if(config.high_calibration_420ma_active){
485
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
486
+ }
487
+ break;
488
+ case 52:
489
+ if(config.sensor_boot_time_420ma_active){
490
+ promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
491
+ }
492
+ if(config.low_calibration_420ma_active){
493
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
494
+ }
495
+ if(config.mid_calibration_420ma_active){
496
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
497
+ }
498
+ if(config.high_calibration_420ma_active){
499
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
500
+ }
501
+ break;
502
+ case 80:
503
+ if(config.current_calibration_c1_80_active){
504
+ promises.current_calibration_c1_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
505
+ }
506
+ if(config.output_data_rate_101_active){
507
+ promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
508
+ }
509
+ if(config.sampling_duration_101_active){
510
+ promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
511
+ }
512
+ if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
513
+ promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
514
+ }
515
+ if(config.sampling_interval_101_active){
516
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
517
+ }
518
+ if(config.full_scale_range_101_active){
519
+ promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
520
+ }
521
+ if(config.mode_80_active){
522
+ promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
523
+ }
524
+ if(config.filter_80_active){
525
+ promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
526
+ }
527
+ if(config.low_pass_filter_80_active){
528
+ promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
529
+ }
530
+ if(config.high_pass_filter_80_active){
531
+ promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
532
+ }
533
+ if(config.measurement_mode_80_active){
534
+ promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
535
+ }
536
+ if(config.on_request_timeout_80_active){
537
+ promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
538
+ }
539
+ if(config.deadband_80_active){
540
+ promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
541
+ }
542
+ if(config.payload_length_80_active){
543
+ promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
544
+ }
545
+ if(config.set_rtc_101){
546
+ promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
547
+ }
548
+ break;
549
+ case 81:
550
+ if(config.current_calibration_c1_80_active){
551
+ promises.current_calibration_c1_80_active = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
552
+ }
553
+ if(config.current_calibration_c2_80_active){
554
+ promises.current_calibration_c2_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c2_80), 3);
555
+ }
556
+ if(config.output_data_rate_p1_81_active){
557
+ promises.output_data_rate_p1_81 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_p1_81));
558
+ }
559
+ if(config.output_data_rate_p2_81_active){
560
+ promises.output_data_rate_p2_81 = node.config_gateway.config_set_output_data_rate_p2_81(mac, parseInt(config.output_data_rate_p2_81));
561
+ }
562
+ if(config.sampling_duration_p1_81_active){
563
+ promises.sampling_duration_p1_81 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_p1_81));
564
+ }
565
+ if(config.sampling_duration_p2_81_active){
566
+ promises.sampling_duration_p2_81 = node.config_gateway.config_set_sampling_duration_p2_81(mac, parseInt(config.sampling_duration_p2_81));
567
+ }
568
+ if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
569
+ promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
570
+ }
571
+ if(config.sampling_interval_101_active){
572
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
573
+ }
574
+ if(config.full_scale_range_101_active){
575
+ promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
576
+ }
577
+ if(config.mode_80_active){
578
+ promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
579
+ }
580
+ if(config.filter_80_active){
581
+ promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
582
+ }
583
+ if(config.low_pass_filter_80_active){
584
+ promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
585
+ }
586
+ if(config.high_pass_filter_80_active){
587
+ promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
588
+ }
589
+ if(config.low_pass_filter_81_p2_active){
590
+ promises.low_pass_filter_p2 = node.config_gateway.config_set_low_pass_filter_81_p2(mac, parseInt(config.low_pass_filter_81_p2));
591
+ }
592
+ if(config.high_pass_filter_81_p2_active){
593
+ promises.high_pass_filter_p2 = node.config_gateway.config_set_high_pass_filter_81_p2(mac, parseInt(config.high_pass_filter_81_p2));
594
+ }
595
+ if(config.measurement_mode_80_active){
596
+ promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
597
+ }
598
+ if(config.on_request_timeout_80_active){
599
+ promises.on_request_timeout = node.config_gateway.config_set_on_request_timeout_80(mac, parseInt(config.on_request_timeout_80));
600
+ }
601
+ if(config.deadband_80_active){
602
+ promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
603
+ }
604
+ if(config.payload_length_80_active){
605
+ promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
606
+ }
607
+ if(config.set_rtc_101){
608
+ promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
609
+ }
610
+ break;
611
+ case 82:
612
+ if(config.current_calibration_82_active){
613
+ promises.current_calibration_82 = node.config_gateway.config_set_current_calibration_82(mac, parseInt(config.current_calibration_82));
614
+ }
615
+ if(config.output_data_rate_101_active){
616
+ promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
617
+ }
618
+ if(config.sampling_duration_101_active){
619
+ promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
620
+ }
621
+ if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
622
+ promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
623
+ }
624
+ if(config.sampling_interval_101_active){
625
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
626
+ }
627
+ if(config.full_scale_range_101_active){
628
+ promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
629
+ }
630
+ if(config.mode_80_active){
631
+ promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
632
+ }
633
+ if(config.filter_80_active){
634
+ promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
635
+ }
636
+ if(config.low_pass_filter_80_active){
637
+ promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
638
+ }
639
+ if(config.high_pass_filter_80_active){
640
+ promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
641
+ }
642
+ if(config.measurement_mode_80_active){
643
+ promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
644
+ }
645
+ if(config.on_request_timeout_80_active){
646
+ promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
647
+ }
648
+ if(config.deadband_80_active){
649
+ promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
650
+ }
651
+ if(config.payload_length_80_active){
652
+ promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
653
+ }
654
+ if(config.set_rtc_101){
655
+ promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
656
+ }
657
+ break;
658
+ case 84:
659
+ if(config.output_data_rate_101_active){
660
+ promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
661
+ }
662
+ if(config.sampling_duration_101_active){
663
+ promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
664
+ }
665
+ if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
666
+ promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
667
+ }
668
+ if(config.sampling_interval_101_active){
669
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
670
+ }
671
+ if(config.full_scale_range_101_active){
672
+ promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
673
+ }
674
+ if(config.mode_80_active){
675
+ promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
676
+ }
677
+ if(config.filter_80_active){
678
+ promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
679
+ }
680
+ if(config.low_pass_filter_80_active){
681
+ promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
682
+ }
683
+ if(config.high_pass_filter_80_active){
684
+ promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
685
+ }
686
+ if(config.measurement_mode_80_active){
687
+ promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
688
+ }
689
+ if(config.on_request_timeout_80_active){
690
+ promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
691
+ }
692
+ if(config.deadband_80_active){
693
+ promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
694
+ }
695
+ if(config.led_alert_mode_84_active){
696
+ promises.led_alert_mode_84 = node.config_gateway.config_set_led_alert_mode_84(mac, parseInt(config.led_alert_mode_84));
697
+ }
698
+ if(config.led_accelerometer_threshold_84_active){
699
+ promises.led_accelerometer_threshold_84 = node.config_gateway.config_set_led_accelerometer_threshold_84(mac, parseInt(config.led_accelerometer_threshold_84));
700
+ }
701
+ if(config.led_velocity_threshold_84_active){
702
+ promises.led_velocity_threshold_84 = node.config_gateway.config_set_led_velocity_threshold_84(mac, parseInt(config.led_velocity_threshold_84));
703
+ }
704
+ if(config.acceleration_interrupt_threshold_84_active){
705
+ promises.acceleration_interrupt_threshold_84 = node.config_gateway.config_set_acceleration_interrupt_threshold_84(mac, parseInt(config.acceleration_interrupt_threshold_84));
706
+ }
707
+ if(config.payload_length_80_active){
708
+ promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
709
+ }
710
+ if(config.set_rtc_101){
711
+ promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
712
+ }
713
+ break;
714
+ case 88:
715
+ if(config.sensor_boot_time_420ma_active){
716
+ promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
717
+ }
718
+ if(config.low_calibration_420ma_active){
719
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
720
+ }
721
+ if(config.mid_calibration_420ma_active){
722
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
723
+ }
724
+ if(config.high_calibration_420ma_active){
725
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
726
+ }
727
+ break;
728
+ case 89:
729
+ if(config.sensor_boot_time_420ma_active){
730
+ promises.sensor_boot_time_420ma = node.config_gateway.config_set_sensor_boot_time_420ma(mac, parseInt(config.sensor_boot_time_420ma));
731
+ }
732
+ if(config.low_calibration_420ma_active){
733
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
734
+ }
735
+ if(config.mid_calibration_420ma_active){
736
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
737
+ }
738
+ if(config.high_calibration_420ma_active){
739
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
740
+ }
741
+ break;
742
+ case 101:
743
+ if(config.output_data_rate_101_m2_active){
744
+ promises.output_data_rate_101_m2 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101_m2));
745
+ }
746
+ if(config.sampling_duration_101_active){
747
+ promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
748
+ }
749
+ if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
750
+ promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
751
+ }
752
+ if(config.sampling_interval_101_active){
753
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
754
+ }
755
+ if(config.full_scale_range_101_m2_active){
756
+ promises.full_scale_range_101_m2 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101_m2));
757
+ }
758
+ // promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
759
+ break;
760
+ case 102:
761
+ if(config.output_data_rate_101_active){
762
+ promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
763
+ }
764
+ if(config.sampling_duration_101_active){
765
+ promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
766
+ }
692
767
 
693
- // promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
694
- if(config.sampling_interval_101_active){
695
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
696
- }
697
- // if(config.full_scale_range_101_active){
698
- // promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
699
- // }
700
- // promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
701
- break;
702
- case 505:
703
- if(config.current_calibration_c1_80_active){
704
- promises.current_calibration_c1_80_active = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
705
- }
706
- break;
707
- case 506:
708
- if(config.current_calibration_c1_80_active){
709
- promises.current_calibration_c1_80_active = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
710
- }
711
- if(config.current_calibration_c2_80_active){
712
- promises.current_calibration_c2_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c2_80), 3);
713
- }
714
- if(config.current_calibration_c3_80_active){
715
- promises.current_calibration_c3_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c3_80), 5);
716
- }
717
- break;
718
- case 519:
719
- if(config.output_data_rate_101_active){
720
- promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
721
- }
722
- if(config.sampling_duration_101_active){
723
- promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
724
- }
725
- if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
726
- promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
727
- }
728
- if(config.sampling_interval_101_active){
729
- promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
730
- }
731
- if(config.full_scale_range_101_active){
732
- promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
733
- }
734
- if(config.mode_80_active){
735
- promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
736
- }
737
- if(config.filter_80_active){
738
- promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
739
- }
740
- if(config.low_pass_filter_80_active){
741
- promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
742
- }
743
- if(config.high_pass_filter_80_active){
744
- promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
745
- }
746
- if(config.measurement_mode_80_active){
747
- promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
748
- }
749
- if(config.on_request_timeout_80_active){
750
- promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
751
- }
752
- if(config.deadband_80_active){
753
- promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
754
- }
755
- if(config.led_alert_mode_84_active){
756
- promises.led_alert_mode_84 = node.config_gateway.config_set_led_alert_mode_84(mac, parseInt(config.led_alert_mode_84));
757
- }
758
- if(config.led_accelerometer_threshold_84_active){
759
- promises.led_accelerometer_threshold_84 = node.config_gateway.config_set_led_accelerometer_threshold_84(mac, parseInt(config.led_accelerometer_threshold_84));
760
- }
761
- if(config.led_velocity_threshold_84_active){
762
- promises.led_velocity_threshold_84 = node.config_gateway.config_set_led_velocity_threshold_84(mac, parseInt(config.led_velocity_threshold_84));
763
- }
764
- if(config.acceleration_interrupt_threshold_84_active){
765
- promises.acceleration_interrupt_threshold_84 = node.config_gateway.config_set_acceleration_interrupt_threshold_84(mac, parseInt(config.acceleration_interrupt_threshold_84));
766
- }
767
- if(config.payload_length_80_active){
768
- promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
769
- }
770
- if(config.set_rtc_101){
771
- promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
772
- }
773
- break;
774
- }
775
- }
776
- // These sensors listed in original_otf_devices use a different OTF code.
777
- let original_otf_devices = [53, 80, 81, 82, 83, 84, 101, 102 , 518, 519, 520];
778
- // If we changed the network ID reboot the sensor to take effect.
779
- // TODO if we add the encryption key command to node-red we need to reboot for it as well.
780
- if(reboot){
781
- promises.reboot_sensor = node.config_gateway.config_reboot_sensor(mac);
782
- } else if(otf){
783
- if(original_otf_devices.includes(sensor.type)){
784
- promises.exit_otn_mode = node.config_gateway.config_exit_otn_mode(mac);
785
- }else{
786
- promises.config_exit_otn_mode_common = node.config_gateway.config_exit_otn_mode_common(mac);
787
- }
788
- }
789
- promises.finish = new Promise((fulfill, reject) => {
790
- node.config_gateway.queue.add(() => {
791
- return new Promise((f, r) => {
792
- clearTimeout(tout);
793
- node.status(modes.READY);
794
- fulfill();
795
- f();
796
- });
797
- });
798
- });
799
- for(var i in promises){
800
- (function(name){
801
- promises[name].then((f) => {
802
- if(name != 'finish') success[name] = true;
803
- else{
804
- // #OTF
805
- node.send({topic: 'Config Results', payload: success, time: Date.now()});
806
- top_fulfill(success);
807
- }
808
- }).catch((err) => {
809
- success[name] = err;
810
- });
811
- })(i);
812
- }
813
- }, 1000);
814
- });
815
- }
816
- node._sensor_config = _config;
817
- if(config.addr){
818
- config.addr = config.addr.toLowerCase();
768
+ // promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
769
+ if(config.sampling_interval_101_active){
770
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
771
+ }
772
+ // if(config.full_scale_range_101_active){
773
+ // promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
774
+ // }
775
+ // promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
776
+ break;
777
+ case 200:
778
+ if(config.low_calibration_420ma_active){
779
+ promises.low_calibration_420ma = node.config_gateway.config_set_low_calibration_420ma(mac, parseInt(config.low_calibration_420ma));
780
+ }
781
+ if(config.mid_calibration_420ma_active){
782
+ promises.mid_calibration_420ma = node.config_gateway.config_set_mid_calibration_420ma(mac, parseInt(config.mid_calibration_420ma));
783
+ }
784
+ if(config.high_calibration_420ma_active){
785
+ promises.high_calibration_420ma = node.config_gateway.config_set_high_calibration_420ma(mac, parseInt(config.high_calibration_420ma));
786
+ }
787
+ break;
788
+ case 505:
789
+ if(config.current_calibration_c1_80_active){
790
+ promises.current_calibration_c1_80_active = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
791
+ }
792
+ break;
793
+ case 506:
794
+ if(config.current_calibration_c1_80_active){
795
+ promises.current_calibration_c1_80_active = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c1_80), 1);
796
+ }
797
+ if(config.current_calibration_c2_80_active){
798
+ promises.current_calibration_c2_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c2_80), 3);
799
+ }
800
+ if(config.current_calibration_c3_80_active){
801
+ promises.current_calibration_c3_80 = node.config_gateway.config_set_current_calibration_individual_80(mac, parseInt(config.current_calibration_c3_80), 5);
802
+ }
803
+ break;
804
+ case 519:
805
+ if(config.output_data_rate_101_active){
806
+ promises.output_data_rate_101 = node.config_gateway.config_set_output_data_rate_101(mac, parseInt(config.output_data_rate_101));
807
+ }
808
+ if(config.sampling_duration_101_active){
809
+ promises.sampling_duration_101 = node.config_gateway.config_set_sampling_duration_101(mac, parseInt(config.sampling_duration_101));
810
+ }
811
+ if(config.x_axis_101 || config.y_axis_101 || config.z_axis_101){
812
+ promises.axis_enabled_101 = node.config_gateway.config_set_axis_enabled_101(mac, config.x_axis_101, config.y_axis_101, config.z_axis_101);
813
+ }
814
+ if(config.sampling_interval_101_active){
815
+ promises.sampling_interval_101 = node.config_gateway.config_set_sampling_interval_101(mac, parseInt(config.sampling_interval_101));
816
+ }
817
+ if(config.full_scale_range_101_active){
818
+ promises.full_scale_range_101 = node.config_gateway.config_set_full_scale_range_101(mac, parseInt(config.full_scale_range_101));
819
+ }
820
+ if(config.mode_80_active){
821
+ promises.mode = node.config_gateway.config_set_operation_mode_80(mac, parseInt(config.mode_80));
822
+ }
823
+ if(config.filter_80_active){
824
+ promises.filter = node.config_gateway.config_set_filters_80(mac, parseInt(config.filter_80));
825
+ }
826
+ if(config.low_pass_filter_80_active){
827
+ promises.low_pass_filter = node.config_gateway.config_set_low_pass_filter_80(mac, parseInt(config.low_pass_filter_80));
828
+ }
829
+ if(config.high_pass_filter_80_active){
830
+ promises.high_pass_filter = node.config_gateway.config_set_high_pass_filter_80(mac, parseInt(config.high_pass_filter_80));
831
+ }
832
+ if(config.measurement_mode_80_active){
833
+ promises.measurement_mode = node.config_gateway.config_set_measurement_mode_80(mac, parseInt(config.measurement_mode_80));
834
+ }
835
+ if(config.on_request_timeout_80_active){
836
+ promises.on_request_timeout = node.config_gateway.config_set_filters_80(mac, parseInt(config.on_request_timeout_80));
837
+ }
838
+ if(config.deadband_80_active){
839
+ promises.deadband = node.config_gateway.config_set_deadband_80(mac, parseInt(config.deadband_80));
840
+ }
841
+ if(config.led_alert_mode_84_active){
842
+ promises.led_alert_mode_84 = node.config_gateway.config_set_led_alert_mode_84(mac, parseInt(config.led_alert_mode_84));
843
+ }
844
+ if(config.led_accelerometer_threshold_84_active){
845
+ promises.led_accelerometer_threshold_84 = node.config_gateway.config_set_led_accelerometer_threshold_84(mac, parseInt(config.led_accelerometer_threshold_84));
846
+ }
847
+ if(config.led_velocity_threshold_84_active){
848
+ promises.led_velocity_threshold_84 = node.config_gateway.config_set_led_velocity_threshold_84(mac, parseInt(config.led_velocity_threshold_84));
849
+ }
850
+ if(config.acceleration_interrupt_threshold_84_active){
851
+ promises.acceleration_interrupt_threshold_84 = node.config_gateway.config_set_acceleration_interrupt_threshold_84(mac, parseInt(config.acceleration_interrupt_threshold_84));
852
+ }
853
+ if(config.payload_length_80_active){
854
+ promises.payload_length_80 = node.config_gateway.config_set_payload_length_80(mac, parseInt(config.payload_length_80));
855
+ }
856
+ if(config.set_rtc_101){
857
+ promises.set_rtc_101 = node.config_gateway.config_set_rtc_101(mac);
858
+ }
859
+ break;
860
+ }
861
+ }
862
+ // These sensors listed in original_otf_devices use a different OTF code.
863
+ let original_otf_devices = [53, 80, 81, 82, 83, 84, 101, 102 , 518, 519, 520];
864
+ // If we changed the network ID reboot the sensor to take effect.
865
+ // TODO if we add the encryption key command to node-red we need to reboot for it as well.
866
+ if(reboot){
867
+ promises.reboot_sensor = node.config_gateway.config_reboot_sensor(mac);
868
+ } else if(otf){
869
+ if(original_otf_devices.includes(sensor.type)){
870
+ promises.exit_otn_mode = node.config_gateway.config_exit_otn_mode(mac);
871
+ }else{
872
+ promises.config_exit_otn_mode_common = node.config_gateway.config_exit_otn_mode_common(mac);
873
+ }
874
+ }
875
+ promises.finish = new Promise((fulfill, reject) => {
876
+ node.config_gateway.queue.add(() => {
877
+ return new Promise((f, r) => {
878
+ clearTimeout(tout);
879
+ node.status(modes.READY);
880
+ fulfill();
881
+ f();
882
+ });
883
+ });
884
+ });
885
+ for(var i in promises){
886
+ (function(name){
887
+ promises[name].then((f) => {
888
+ if(name != 'finish') success[name] = true;
889
+ else{
890
+ // #OTF
891
+ node.send({topic: 'Config Results', payload: success, time: Date.now()});
892
+ top_fulfill(success);
893
+ }
894
+ }).catch((err) => {
895
+ success[name] = err;
896
+ });
897
+ })(i);
898
+ }
899
+ }, 1000);
900
+ });
901
+ }
902
+ node._sensor_config = _config;
903
+ if(config.addr){
904
+ config.addr = config.addr.toLowerCase();
819
905
 
820
- RED.nodes.getNode(config.connection).sensor_pool.push(config.addr);
821
- this.gtw_on('sensor_data-'+config.addr, (data) => {
822
- node.status(modes.RUN);
823
- data.modem_mac = this.gateway.modem_mac;
824
- node.send({
825
- topic: 'sensor_data',
826
- data: data,
827
- payload: data.sensor_data,
828
- time: Date.now()
829
- });
830
- });
831
- this.gtw_on('set_destination_address'+config.addr, (d) => {
832
- if(config.auto_config){
833
- node.warn('Setting destination address');
834
- return new Promise((top_fulfill, top_reject) => {
835
- var msg = {};
836
- setTimeout(() => {
837
- var tout = setTimeout(() => {
838
- node.status(modes.PGM_ERR);
839
- node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
840
- }, 10000);
906
+ RED.nodes.getNode(config.connection).sensor_pool.push(config.addr);
907
+ this.gtw_on('sensor_data-'+config.addr, (data) => {
908
+ node.status(modes.RUN);
909
+ data.modem_mac = this.gateway.modem_mac;
910
+ node.send({
911
+ topic: 'sensor_data',
912
+ data: data,
913
+ payload: data.sensor_data,
914
+ time: Date.now()
915
+ });
916
+ });
917
+ this.gtw_on('set_destination_address'+config.addr, (d) => {
918
+ if(config.auto_config){
919
+ node.warn('Setting destination address');
920
+ return new Promise((top_fulfill, top_reject) => {
921
+ var msg = {};
922
+ setTimeout(() => {
923
+ var tout = setTimeout(() => {
924
+ node.status(modes.PGM_ERR);
925
+ node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
926
+ }, 10000);
841
927
 
842
- var promises = {};
928
+ var promises = {};
843
929
 
844
- promises.config_dest_address_fly = node.config_gateway.config_set_destination(d, parseInt(config.destination, 16));
930
+ promises.config_dest_address_fly = node.config_gateway.config_set_destination(d, parseInt(config.destination, 16));
845
931
 
846
- promises.finish = new Promise((fulfill, reject) => {
847
- node.config_gateway.queue.add(() => {
848
- return new Promise((f, r) => {
849
- clearTimeout(tout);
850
- fulfill();
851
- f();
852
- });
853
- });
854
- });
855
- for(var i in promises){
856
- (function(name){
857
- promises[name].then((f) => {
858
- if(name != 'finish') msg[name] = true;
859
- else{
860
- node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
861
- top_fulfill(msg);
862
- }
863
- }).catch((err) => {
864
- msg[name] = err;
865
- });
866
- })(i);
867
- }
868
- });
869
- });
870
- }
871
- });
872
- this.pgm_on('sensor_mode-'+config.addr, (sensor) => {
873
- if(sensor.mode in modes){
874
- node.status(modes[sensor.mode]);
875
- }
876
- else{
877
- console.log('Error: unrecognized sensor mode packet');
878
- }
879
- if(config.auto_config && sensor.mode == "PGM"){
880
- _config(sensor);
881
- }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "FLY"){
882
- // _send_otn_request(sensor);
883
- // Sensors having issues seeing OTN request sent too quickly
884
- // Added timeout to fix issue
885
- var tout = setTimeout(() => {
886
- _send_otn_request(sensor);
887
- }, 100);
888
- }else if(sensor.mode == "FLY" && config.sensor_type == 101 || sensor.mode == "FLY" && config.sensor_type == 102){
889
- // send broadcast rtc to 101 and 102 regardless of settings
890
- if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
891
- var broadcast_tout = setTimeout(() => {
892
- _send_otn_request(sensor);
893
- }, 100);
894
- }
895
- }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "OTN"){
896
- if(config.sensor_type == 101 || config.sensor_type == 102){
897
- if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
898
- this.gateway.fly_101_in_progress = true;
899
- node.warn('start timer 2 ' + Date.now());
900
- var broadcast_tout = setTimeout(() => {
901
- node.warn('broadcast timer expired ' + Date.now());
902
- _broadcast_rtc(sensor);
903
- }, 2000);
904
- }else{
905
- node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
906
- }
907
- if(config.auto_config && config.on_the_fly_enable){
908
- var tout = setTimeout(() => {
909
- node.warn('config timer expired' + Date.now());
910
- _config(sensor, true);
911
- }, 3500);
912
- }
913
- }else{
914
- _config(sensor, true);
915
- }
916
- } else if(config.sensor_type == 101 && sensor.mode == "OTN" || config.sensor_type == 102 && sensor.mode == "OTN"){
917
- if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
918
- this.gateway.fly_101_in_progress = true;
919
- node.warn('start timer 2 ' + Date.now());
920
- var broadcast_tout = setTimeout(() => {
921
- node.warn('broadcast timer expired ' + Date.now());
922
- _broadcast_rtc(sensor);
923
- var otf_timeout = setTimeout(() => {
924
- node.warn('Sending OTF request ' + Date.now());
925
- this.config_gateway.config_exit_otn_mode(sensor.mac);
926
- }, 1000);
927
- }, 2000);
928
- }else{
929
- node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
930
- var otf_timeout = setTimeout(() => {
931
- node.warn('Sending OTF request ' + Date.now());
932
- this.config_gateway.config_exit_otn_mode(sensor.mac);
933
- }, 3000);
934
- }
935
- }
936
- });
937
- }else if(config.sensor_type){
938
- this.gtw_on('sensor_data-'+config.sensor_type, (data) => {
939
- node.status(modes.RUN);
940
- data.modem_mac = this.gateway.modem_mac;
941
- node.send({
942
- topic: 'sensor_data',
943
- data: data,
944
- payload: data.sensor_data,
945
- time: Date.now()
946
- });
947
- });
948
- this.gtw_on('set_destination_address'+config.sensor_type, (d) => {
949
- if(config.auto_config){
950
- node.warn('Setting destination address');
951
- return new Promise((top_fulfill, top_reject) => {
952
- var msg = {};
953
- setTimeout(() => {
954
- var tout = setTimeout(() => {
955
- node.status(modes.PGM_ERR);
956
- node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
957
- }, 10000);
932
+ promises.finish = new Promise((fulfill, reject) => {
933
+ node.config_gateway.queue.add(() => {
934
+ return new Promise((f, r) => {
935
+ clearTimeout(tout);
936
+ fulfill();
937
+ f();
938
+ });
939
+ });
940
+ });
941
+ for(var i in promises){
942
+ (function(name){
943
+ promises[name].then((f) => {
944
+ if(name != 'finish') msg[name] = true;
945
+ else{
946
+ node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
947
+ top_fulfill(msg);
948
+ }
949
+ }).catch((err) => {
950
+ msg[name] = err;
951
+ });
952
+ })(i);
953
+ }
954
+ });
955
+ });
956
+ }
957
+ });
958
+ this.pgm_on('sensor_mode-'+config.addr, (sensor) => {
959
+ if(sensor.mode in modes){
960
+ node.status(modes[sensor.mode]);
961
+ }
962
+ else{
963
+ console.log('Error: unrecognized sensor mode packet');
964
+ }
965
+ if(config.auto_config && sensor.mode == "PGM"){
966
+ _config(sensor);
967
+ }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "FLY"){
968
+ // _send_otn_request(sensor);
969
+ // Sensors having issues seeing OTN request sent too quickly
970
+ // Added timeout to fix issue
971
+ var tout = setTimeout(() => {
972
+ _send_otn_request(sensor);
973
+ }, 100);
974
+ }else if(sensor.mode == "FLY" && config.sensor_type == 101 || sensor.mode == "FLY" && config.sensor_type == 102){
975
+ // send broadcast rtc to 101 and 102 regardless of settings
976
+ if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
977
+ var broadcast_tout = setTimeout(() => {
978
+ _send_otn_request(sensor);
979
+ }, 100);
980
+ }
981
+ }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "OTN"){
982
+ if(config.sensor_type == 101 || config.sensor_type == 102){
983
+ if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
984
+ this.gateway.fly_101_in_progress = true;
985
+ node.warn('start timer 2 ' + Date.now());
986
+ var broadcast_tout = setTimeout(() => {
987
+ node.warn('broadcast timer expired ' + Date.now());
988
+ _broadcast_rtc(sensor);
989
+ }, 2000);
990
+ }else{
991
+ node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
992
+ }
993
+ if(config.auto_config && config.on_the_fly_enable){
994
+ var tout = setTimeout(() => {
995
+ node.warn('config timer expired' + Date.now());
996
+ _config(sensor, true);
997
+ }, 3500);
998
+ }
999
+ }else{
1000
+ _config(sensor, true);
1001
+ }
1002
+ } else if(config.sensor_type == 101 && sensor.mode == "OTN" || config.sensor_type == 102 && sensor.mode == "OTN"){
1003
+ if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1004
+ this.gateway.fly_101_in_progress = true;
1005
+ node.warn('start timer 2 ' + Date.now());
1006
+ var broadcast_tout = setTimeout(() => {
1007
+ node.warn('broadcast timer expired ' + Date.now());
1008
+ _broadcast_rtc(sensor);
1009
+ var otf_timeout = setTimeout(() => {
1010
+ node.warn('Sending OTF request ' + Date.now());
1011
+ this.config_gateway.config_exit_otn_mode(sensor.mac);
1012
+ }, 1000);
1013
+ }, 2000);
1014
+ }else{
1015
+ node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
1016
+ var otf_timeout = setTimeout(() => {
1017
+ node.warn('Sending OTF request ' + Date.now());
1018
+ this.config_gateway.config_exit_otn_mode(sensor.mac);
1019
+ }, 3000);
1020
+ }
1021
+ }
1022
+ });
1023
+ }else if(config.sensor_type){
1024
+ this.gtw_on('sensor_data-'+config.sensor_type, (data) => {
1025
+ node.status(modes.RUN);
1026
+ data.modem_mac = this.gateway.modem_mac;
1027
+ node.send({
1028
+ topic: 'sensor_data',
1029
+ data: data,
1030
+ payload: data.sensor_data,
1031
+ time: Date.now()
1032
+ });
1033
+ });
1034
+ this.gtw_on('set_destination_address'+config.sensor_type, (d) => {
1035
+ if(config.auto_config){
1036
+ node.warn('Setting destination address');
1037
+ return new Promise((top_fulfill, top_reject) => {
1038
+ var msg = {};
1039
+ setTimeout(() => {
1040
+ var tout = setTimeout(() => {
1041
+ node.status(modes.PGM_ERR);
1042
+ node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
1043
+ }, 10000);
958
1044
 
959
- var promises = {};
1045
+ var promises = {};
960
1046
 
961
- promises.config_dest_address_fly = node.config_gateway.config_set_destination(d, parseInt(config.destination, 16));
1047
+ promises.config_dest_address_fly = node.config_gateway.config_set_destination(d, parseInt(config.destination, 16));
962
1048
 
963
- promises.finish = new Promise((fulfill, reject) => {
964
- node.config_gateway.queue.add(() => {
965
- return new Promise((f, r) => {
966
- clearTimeout(tout);
967
- fulfill();
968
- f();
969
- });
970
- });
971
- });
972
- for(var i in promises){
973
- (function(name){
974
- promises[name].then((f) => {
975
- if(name != 'finish') msg[name] = true;
976
- else{
977
- node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
978
- top_fulfill(msg);
979
- }
980
- }).catch((err) => {
981
- msg[name] = err;
982
- });
983
- })(i);
984
- }
985
- });
986
- });
987
- }
988
- });
989
- this.pgm_on('sensor_mode', (sensor) => {
990
- if(sensor.type == config.sensor_type){
991
- if(sensor.mode in modes){
992
- node.status(modes[sensor.mode]);
993
- }
994
- else{
995
- console.log('Error: unrecognized sensor mode packet');
996
- }
997
- if(config.auto_config && sensor.mode == 'PGM'){
998
- _config(sensor);
999
- }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "FLY"){
1000
- // _send_otn_request(sensor);
1001
- // Sensors having issues seeing OTN request sent too quickly
1002
- // Added timeout to fix issue
1003
- var tout = setTimeout(() => {
1004
- _send_otn_request(sensor);
1005
- }, 100);
1006
- }else if(sensor.mode == "FLY" && config.sensor_type == 101 || sensor.mode == "FLY" && config.sensor_type == 102){
1007
- // send broadcast rtc to 101 and 102 regardless of settings
1008
- if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1009
- var broadcast_tout = setTimeout(() => {
1010
- _send_otn_request(sensor);
1011
- }, 100);
1012
- }
1013
- }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "OTN"){
1014
- if(config.sensor_type == 101 || config.sensor_type == 102){
1015
- if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1016
- this.gateway.fly_101_in_progress = true;
1017
- node.warn('start timer 2 ' + Date.now());
1018
- var broadcast_tout = setTimeout(() => {
1019
- node.warn('broadcast timer expired ' + Date.now());
1020
- _broadcast_rtc(sensor);
1021
- }, 2000);
1022
- }else{
1023
- node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
1024
- }
1025
- if(config.auto_config && config.on_the_fly_enable){
1026
- var tout = setTimeout(() => {
1027
- node.warn('config timer expired' + Date.now());
1028
- _config(sensor, true);
1029
- }, 3500);
1030
- }
1031
- }else{
1032
- _config(sensor, true);
1033
- }
1049
+ promises.finish = new Promise((fulfill, reject) => {
1050
+ node.config_gateway.queue.add(() => {
1051
+ return new Promise((f, r) => {
1052
+ clearTimeout(tout);
1053
+ fulfill();
1054
+ f();
1055
+ });
1056
+ });
1057
+ });
1058
+ for(var i in promises){
1059
+ (function(name){
1060
+ promises[name].then((f) => {
1061
+ if(name != 'finish') msg[name] = true;
1062
+ else{
1063
+ node.send({topic: 'FLY Set Destination Address', payload: msg, time: Date.now()});
1064
+ top_fulfill(msg);
1065
+ }
1066
+ }).catch((err) => {
1067
+ msg[name] = err;
1068
+ });
1069
+ })(i);
1070
+ }
1071
+ });
1072
+ });
1073
+ }
1074
+ });
1075
+ this.pgm_on('sensor_mode', (sensor) => {
1076
+ if(sensor.type == config.sensor_type){
1077
+ if(sensor.mode in modes){
1078
+ node.status(modes[sensor.mode]);
1079
+ }
1080
+ else{
1081
+ console.log('Error: unrecognized sensor mode packet');
1082
+ }
1083
+ if(config.auto_config && sensor.mode == 'PGM'){
1084
+ _config(sensor);
1085
+ }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "FLY"){
1086
+ // _send_otn_request(sensor);
1087
+ // Sensors having issues seeing OTN request sent too quickly
1088
+ // Added timeout to fix issue
1089
+ var tout = setTimeout(() => {
1090
+ _send_otn_request(sensor);
1091
+ }, 100);
1092
+ }else if(sensor.mode == "FLY" && config.sensor_type == 101 || sensor.mode == "FLY" && config.sensor_type == 102){
1093
+ // send broadcast rtc to 101 and 102 regardless of settings
1094
+ if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1095
+ var broadcast_tout = setTimeout(() => {
1096
+ _send_otn_request(sensor);
1097
+ }, 100);
1098
+ }
1099
+ }else if(config.auto_config && config.on_the_fly_enable && sensor.mode == "OTN"){
1100
+ if(config.sensor_type == 101 || config.sensor_type == 102){
1101
+ if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1102
+ this.gateway.fly_101_in_progress = true;
1103
+ node.warn('start timer 2 ' + Date.now());
1104
+ var broadcast_tout = setTimeout(() => {
1105
+ node.warn('broadcast timer expired ' + Date.now());
1106
+ _broadcast_rtc(sensor);
1107
+ }, 2000);
1108
+ }else{
1109
+ node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
1110
+ }
1111
+ if(config.auto_config && config.on_the_fly_enable){
1112
+ var tout = setTimeout(() => {
1113
+ node.warn('config timer expired' + Date.now());
1114
+ _config(sensor, true);
1115
+ }, 3500);
1116
+ }
1117
+ }else{
1118
+ _config(sensor, true);
1119
+ }
1034
1120
 
1035
- }else if(config.sensor_type == 101 && sensor.mode == "OTN" || config.sensor_type == 102 && sensor.mode == "OTN"){
1036
- if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1037
- this.gateway.fly_101_in_progress = true;
1038
- node.warn('start timer 2 ' + Date.now());
1039
- var broadcast_tout = setTimeout(() => {
1040
- node.warn('broadcast timer expired ' + Date.now());
1041
- _broadcast_rtc(sensor);
1042
- var otf_timeout = setTimeout(() => {
1043
- node.warn('Sending OTF request ' + Date.now());
1044
- this.config_gateway.config_exit_otn_mode(sensor.mac);
1045
- }, 1000);
1046
- }, 2000);
1047
- }else{
1048
- node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
1049
- var otf_timeout = setTimeout(() => {
1050
- node.warn('Sending OTF request ' + Date.now());
1051
- this.config_gateway.config_exit_otn_mode(sensor.mac);
1052
- }, 3000);
1053
- }
1054
- }
1055
- }
1056
- });
1057
- }
1058
- this.on('input', (msg) => {
1059
- if(msg.topic == 'config'){
1060
- _config();
1061
- }else{
1062
- node.gateway.send_arbitrary(config.addr, msg).then((m) => {
1063
- console.log("complete");
1064
- }).catch((err) => {
1065
- console.log("error", err);
1066
- });
1067
- }
1068
- });
1069
- this.on('close', () => {
1070
- for(var e in events){
1071
- node.gateway._emitter.removeAllListeners(e);
1072
- }
1073
- for(var p in pgm_events){
1074
- node.config_gateway._emitter.removeAllListeners(p);
1075
- }
1076
- node.gateway_node.close_comms();
1077
- if(typeof node.config_gateway_node != 'undefined'){
1078
- node.config_gateway_node.close_comms();
1079
- }
1080
- });
1121
+ }else if(config.sensor_type == 101 && sensor.mode == "OTN" || config.sensor_type == 102 && sensor.mode == "OTN"){
1122
+ if(this.gateway.hasOwnProperty('fly_101_in_progress') && this.gateway.fly_101_in_progress == false || !this.gateway.hasOwnProperty('fly_101_in_progress')){
1123
+ this.gateway.fly_101_in_progress = true;
1124
+ node.warn('start timer 2 ' + Date.now());
1125
+ var broadcast_tout = setTimeout(() => {
1126
+ node.warn('broadcast timer expired ' + Date.now());
1127
+ _broadcast_rtc(sensor);
1128
+ var otf_timeout = setTimeout(() => {
1129
+ node.warn('Sending OTF request ' + Date.now());
1130
+ this.config_gateway.config_exit_otn_mode(sensor.mac);
1131
+ }, 1000);
1132
+ }, 2000);
1133
+ }else{
1134
+ node.warn('Attempted to start a new rtc broadcast, but denied rightly at ' + Date.now());
1135
+ var otf_timeout = setTimeout(() => {
1136
+ node.warn('Sending OTF request ' + Date.now());
1137
+ this.config_gateway.config_exit_otn_mode(sensor.mac);
1138
+ }, 3000);
1139
+ }
1140
+ }
1141
+ }
1142
+ });
1143
+ }
1144
+ this.on('input', (msg) => {
1145
+ if(msg.topic == 'config'){
1146
+ _config();
1147
+ }else{
1148
+ node.gateway.send_arbitrary(config.addr, msg).then((m) => {
1149
+ console.log("complete");
1150
+ }).catch((err) => {
1151
+ console.log("error", err);
1152
+ });
1153
+ }
1154
+ });
1155
+ this.on('close', () => {
1156
+ for(var e in events){
1157
+ node.gateway._emitter.removeAllListeners(e);
1158
+ }
1159
+ for(var p in pgm_events){
1160
+ node.config_gateway._emitter.removeAllListeners(p);
1161
+ }
1162
+ node.gateway_node.close_comms();
1163
+ if(typeof node.config_gateway_node != 'undefined'){
1164
+ node.config_gateway_node.close_comms();
1165
+ }
1166
+ });
1081
1167
  }
1082
1168
  RED.nodes.registerType("ncd-wireless-node", NcdWirelessNode);
1083
1169