Komodo / komodo-modem-sms

Download as
Browse Code ยป

Commit 47910cce60174f617789aad87a054a56a7131227

Authored by Adhidarma Hadiwinoto
1 parent 4d1b592447
Exists in master

queryCOPSAndSignalQuality

Showing 2 changed files with 27 additions and 6 deletions Inline Diff

lib/modem-commands.js
Diff comments   View file @ 47910cc
1 const MUTEX_COMMAND = 'COMMAND'; 1 const MUTEX_COMMAND = 'COMMAND';
2 // const MUTEX_SUBCOMMAND = 'SUBCOMMAND'; 2 const MUTEX_SUBCOMMAND = 'SUBCOMMAND';
3 3
4 const ParserReadline = require('@serialport/parser-readline'); 4 const ParserReadline = require('@serialport/parser-readline');
5 const ParserRegex = require('@serialport/parser-regex'); 5 const ParserRegex = require('@serialport/parser-regex');
6 6
7 const logger = require('komodo-sdk/logger'); 7 const logger = require('komodo-sdk/logger');
8 const mutex = require('./mutex-common'); 8 const mutex = require('./mutex-common');
9 const parsers = require('./serialport-parsers'); 9 const parsers = require('./serialport-parsers');
10 const modemInfo = require('./modem-info'); 10 const modemInfo = require('./modem-info');
11 11
12 let port; 12 let port;
13 13
14 function writeToPort(data) { 14 function writeToPort(data) {
15 return new Promise((resolve) => { 15 return new Promise((resolve) => {
16 port.write(data, (err, bytesWritten) => { 16 port.write(data, (err, bytesWritten) => {
17 if (err) logger.warn(`ERROR: ${err.toString()}`); 17 if (err) logger.warn(`ERROR: ${err.toString()}`);
18 18
19 logger.verbose('OUTGOING', { data: data.toString(), bytesWritten, err }); 19 logger.verbose('OUTGOING', { data: data.toString(), bytesWritten, err });
20 resolve(bytesWritten); 20 resolve(bytesWritten);
21 }); 21 });
22 }); 22 });
23 } 23 }
24 24
25 exports.writeToPortAndWaitForReadline = function writeToPortAndWaitForReadline(cmd, lockName) { 25 exports.writeToPortAndWaitForReadline = function writeToPortAndWaitForReadline(cmd, lockName) {
26 let resolved = false;
27
26 return new Promise(async (resolve) => { 28 return new Promise(async (resolve) => {
27 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER }); 29 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER });
28 parser.on('data', (data) => { 30 parser.on('data', (data) => {
29 port.unpipe(parser); 31 port.unpipe(parser);
30 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 32 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
31 resolve(data); 33 if (!resolved) {
34 resolved = true;
35 resolve(data);
36 }
32 }); 37 });
33 38
34 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 39 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
35 port.pipe(parser); 40 port.pipe(parser);
36 await writeToPort(cmd); 41 await writeToPort(cmd);
37 }); 42 });
38 }; 43 };
39 44
40 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) { 45 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) {
41 return new Promise(async (resolve) => { 46 return new Promise(async (resolve) => {
42 const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ }); 47 const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ });
43 parser.on('data', (data) => { 48 parser.on('data', (data) => {
44 port.unpipe(parser); 49 port.unpipe(parser);
45 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 50 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
46 resolve(data); 51 resolve(data);
47 }); 52 });
48 53
49 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 54 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
50 port.pipe(parser); 55 port.pipe(parser);
51 await writeToPort(cmd); 56 await writeToPort(cmd);
52 }); 57 });
53 }; 58 };
54 59
55 exports.sleep = function sleep(ms) { 60 exports.sleep = function sleep(ms) {
56 return new Promise((resolve) => { 61 return new Promise((resolve) => {
57 setTimeout(() => { 62 setTimeout(() => {
58 resolve(); 63 resolve();
59 }, ms || 0); 64 }, ms || 0);
60 }); 65 });
61 }; 66 };
62 67
63 68
64 exports.setPort = function setPort(val) { 69 exports.setPort = function setPort(val) {
65 port = val; 70 port = val;
66 }; 71 };
67 72
68 exports.querySignalQuality = function querySignalQuality() { 73 exports.querySignalQuality = function querySignalQuality() {
69 return new Promise(async (resolve) => { 74 return new Promise(async (resolve) => {
70 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) { 75 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) {
71 resolve(false); 76 resolve(false);
72 return; 77 return;
73 } 78 }
74 79
75 await writeToPort('AT+CSQ\r'); 80 await writeToPort('AT+CSQ\r');
76 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality'); 81 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality');
77 resolve(true); 82 resolve(true);
78 }); 83 });
79 }; 84 };
80 85
81 exports.queryCOPS = function queryCOPS() { 86 exports.queryCOPS = function queryCOPS(lockName) {
82 return new Promise(async (resolve) => { 87 return new Promise(async (resolve) => {
83 await mutex.lock(MUTEX_COMMAND, 'queryCOPS'); 88 await mutex.lock(lockName || MUTEX_COMMAND, 'queryCOPS');
84 await writeToPort('AT+COPS?\r'); 89 await writeToPort('AT+COPS?\r');
85 mutex.unlock(MUTEX_COMMAND, 'queryCOPS'); 90 mutex.unlock(lockName || MUTEX_COMMAND, 'queryCOPS');
91 resolve(true);
92 });
93 };
94
95 exports.queryCOPSAndSignalQuality = function queryCOPSAndSignalQuality() {
96 return new Promise(async (resolve) => {
97 if (!mutex.tryLock(MUTEX_COMMAND, 'queryCOPSAndSignalQuality')) {
98 resolve(false);
99 return;
100 }
101
102 await this.writeToPortAndWaitForReadline('AT+COPS?\r', MUTEX_SUBCOMMAND);
103 await this.writeToPortAndWaitForReadline('AT+CSQ\r', MUTEX_SUBCOMMAND);
104
105 mutex.unlock(MUTEX_COMMAND, 'queryCopsAndSignalQuality');
86 resolve(true); 106 resolve(true);
87 }); 107 });
88 }; 108 };
89 109
90 exports.queryIMEI = function queryIMEI() { 110 exports.queryIMEI = function queryIMEI() {
91 return new Promise(async (resolve) => { 111 return new Promise(async (resolve) => {
92 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 112 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
93 parser.on('data', (data) => { 113 parser.on('data', (data) => {
94 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' }); 114 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' });
95 port.unpipe(parser); 115 port.unpipe(parser);
96 mutex.unlock(MUTEX_COMMAND, 'queryIMEI'); 116 mutex.unlock(MUTEX_COMMAND, 'queryIMEI');
97 modemInfo.imei = data.toString().trim(); 117 modemInfo.imei = data.toString().trim();
98 resolve(modemInfo.imei); 118 resolve(modemInfo.imei);
99 }); 119 });
100 120
101 await mutex.lock(MUTEX_COMMAND, 'queryIMEI'); 121 await mutex.lock(MUTEX_COMMAND, 'queryIMEI');
102 122
103 port.pipe(parser); 123 port.pipe(parser);
104 await writeToPort('AT+CGSN\r'); 124 await writeToPort('AT+CGSN\r');
105 }); 125 });
106 }; 126 };
107 127
108 exports.queryIMSI = function queryIMSI() { 128 exports.queryIMSI = function queryIMSI() {
109 return new Promise(async (resolve) => { 129 return new Promise(async (resolve) => {
110 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 130 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
111 parser.on('data', (data) => { 131 parser.on('data', (data) => {
112 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' }); 132 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' });
113 port.unpipe(parser); 133 port.unpipe(parser);
114 mutex.unlock(MUTEX_COMMAND, 'queryIMSI'); 134 mutex.unlock(MUTEX_COMMAND, 'queryIMSI');
115 modemInfo.imsi = data.toString().trim(); 135 modemInfo.imsi = data.toString().trim();
116 resolve(modemInfo.imsi); 136 resolve(modemInfo.imsi);
117 }); 137 });
118 138
119 await mutex.lock(MUTEX_COMMAND, 'queryIMSI'); 139 await mutex.lock(MUTEX_COMMAND, 'queryIMSI');
120 140
121 port.pipe(parser); 141 port.pipe(parser);
122 await writeToPort('AT+CIMI\r'); 142 await writeToPort('AT+CIMI\r');
123 }); 143 });
124 }; 144 };
125 145
1 const SerialPort = require('serialport'); 1 const SerialPort = require('serialport');
2 2
3 const config = require('komodo-sdk/config'); 3 const config = require('komodo-sdk/config');
4 const logger = require('komodo-sdk/logger'); 4 const logger = require('komodo-sdk/logger');
5 5
6 6
7 const ParserInterByteTimeout = require('@serialport/parser-inter-byte-timeout'); 7 const ParserInterByteTimeout = require('@serialport/parser-inter-byte-timeout');
8 8
9 const parsers = require('./lib/serialport-parsers'); 9 const parsers = require('./lib/serialport-parsers');
10 const modemCommands = require('./lib/modem-commands'); 10 const modemCommands = require('./lib/modem-commands');
11 11
12 const parserInterByteTimeout = new ParserInterByteTimeout({ interval: 1000 }); 12 const parserInterByteTimeout = new ParserInterByteTimeout({ interval: 1000 });
13 parserInterByteTimeout.on('data', (data) => { 13 parserInterByteTimeout.on('data', (data) => {
14 logger.verbose('INCOMING', { parser: 'parserInterByteTimeout', data: data.toString() }); 14 logger.verbose('INCOMING', { parser: 'parserInterByteTimeout', data: data.toString() });
15 }); 15 });
16 16
17 const port = new SerialPort(config.modem.device, { baudRate: 115200 }, async (err) => { 17 const port = new SerialPort(config.modem.device, { baudRate: 115200 }, async (err) => {
18 if (err) { 18 if (err) {
19 logger.warn(`Error opening modem. ${err}. Terminating modem ${config.modem.device}.`); 19 logger.warn(`Error opening modem. ${err}. Terminating modem ${config.modem.device}.`);
20 process.exit(1); 20 process.exit(1);
21 } 21 }
22 22
23 await modemCommands.writeToPortAndWaitForOkOrError('AT\r'); 23 await modemCommands.writeToPortAndWaitForOkOrError('AT\r');
24 await modemCommands.writeToPortAndWaitForOkOrError('AT&FE0\r'); 24 await modemCommands.writeToPortAndWaitForOkOrError('AT&FE0\r');
25 await modemCommands.writeToPortAndWaitForOkOrError('AT+CMGF=0\r'); 25 await modemCommands.writeToPortAndWaitForOkOrError('AT+CMGF=0\r');
26 await modemCommands.writeToPortAndWaitForOkOrError('AT+CNMI=1,2,0,1,0\r'); 26 await modemCommands.writeToPortAndWaitForOkOrError('AT+CNMI=1,2,0,1,0\r');
27 27
28 const imei = await modemCommands.queryIMEI(); 28 const imei = await modemCommands.queryIMEI();
29 logger.info(`**** IMEI: ${imei}`); 29 logger.info(`**** IMEI: ${imei}`);
30 30
31 const imsi = await modemCommands.queryIMSI(); 31 const imsi = await modemCommands.queryIMSI();
32 logger.info(`**** IMSI: ${imsi}`); 32 logger.info(`**** IMSI: ${imsi}`);
33 33
34 const cops = await modemCommands.queryCOPS(); 34 const cops = await modemCommands.queryCOPS();
35 logger.info(`**** COPS: ${cops}`); 35 logger.info(`**** COPS: ${cops}`);
36 36
37 const signalQuality = await modemCommands.querySignalQuality(); 37 const signalQuality = await modemCommands.querySignalQuality();
38 logger.info(`**** Signal Quality: ${signalQuality}`); 38 logger.info(`**** Signal Quality: ${signalQuality}`);
39 39
40 setInterval(() => { 40 setInterval(() => {
41 modemCommands.querySignalQuality(); 41 // modemCommands.querySignalQuality();
42 modemCommands.queryCOPSAndSignalQuality();
42 }, (config && config.interval_beetwen_signal_strength_ms) || 30000); 43 }, (config && config.interval_beetwen_signal_strength_ms) || 30000);
43 }); 44 });
44 45
45 parsers.setPort(port); 46 parsers.setPort(port);
46 modemCommands.setPort(port); 47 modemCommands.setPort(port);
47 48
48 if (config && config.modem_tester && config.modem_tester.parser === 'regex') { 49 if (config && config.modem_tester && config.modem_tester.parser === 'regex') {
49 logger.info('Using parserWaitForOkOrError'); 50 logger.info('Using parserWaitForOkOrError');
50 port.pipe(parsers.parserWaitForOkOrError); 51 port.pipe(parsers.parserWaitForOkOrError);
51 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') { 52 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') {
52 logger.info('Using parserInterByteTimeout'); 53 logger.info('Using parserInterByteTimeout');
53 port.pipe(parserInterByteTimeout); 54 port.pipe(parserInterByteTimeout);
54 } else { 55 } else {
55 logger.info('Using parserReadline'); 56 logger.info('Using parserReadline');
56 port.pipe(parsers.parserReadline); 57 port.pipe(parsers.parserReadline);
57 } 58 }
58 59