Komodo / komodo-modem-sms

Download as
Browse Code ยป

Commit afe1003d11755d5bd5e56e70b6875daa77456ef7

Authored by Adhidarma Hadiwinoto
1 parent ad489775d2
Exists in master

Using modemCommands.writeToPortAndWaitForOkOrError

Showing 2 changed files with 19 additions and 4 deletions Inline Diff

lib/modem-commands.js
Diff comments   View file @ afe1003
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', { bytesWritten, data: data.toString() }); 19 logger.verbose('OUTGOING', { bytesWritten, data: data.toString() });
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 return new Promise(async (resolve) => { 26 return new Promise(async (resolve) => {
27 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER }); 27 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER });
28 parser.on('data', (data) => { 28 parser.on('data', (data) => {
29 logger.verbose('INCOMING', { parser: 'customParserReadLine', data: `${data.toString()}${parsers.PARSER_READLINE_DELIMITER}` }); 29 port.unpipe(parser);
30 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
31 resolve(data);
32 });
33
34 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
35 port.pipe(parser);
36 await writeToPort(cmd);
37 });
38 };
39
40 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) {
41 return new Promise(async (resolve) => {
42 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
43 parser.on('data', (data) => {
44 logger.verbose('INCOMING', { parser: 'customParserWaitForOkOrError', data: data.toString() });
30 port.unpipe(parser); 45 port.unpipe(parser);
31 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 46 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
32 resolve(data); 47 resolve(data);
33 }); 48 });
34 49
35 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 50 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
36 port.pipe(parser); 51 port.pipe(parser);
37 await writeToPort(cmd); 52 await writeToPort(cmd);
38 }); 53 });
39 }; 54 };
40 55
41 exports.sleep = function sleep(ms) { 56 exports.sleep = function sleep(ms) {
42 return new Promise((resolve) => { 57 return new Promise((resolve) => {
43 setTimeout(() => { 58 setTimeout(() => {
44 resolve(); 59 resolve();
45 }, ms || 0); 60 }, ms || 0);
46 }); 61 });
47 }; 62 };
48 63
49 64
50 exports.setPort = function setPort(val) { 65 exports.setPort = function setPort(val) {
51 port = val; 66 port = val;
52 }; 67 };
53 68
54 exports.querySignalQuality = function querySignalQuality() { 69 exports.querySignalQuality = function querySignalQuality() {
55 return new Promise(async (resolve) => { 70 return new Promise(async (resolve) => {
56 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) { 71 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) {
57 resolve(false); 72 resolve(false);
58 return; 73 return;
59 } 74 }
60 75
61 await writeToPort('AT+CSQ\r'); 76 await writeToPort('AT+CSQ\r');
62 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality'); 77 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality');
63 resolve(true); 78 resolve(true);
64 }); 79 });
65 }; 80 };
66 81
67 exports.queryCOPS = function querySignalQuality() { 82 exports.queryCOPS = function querySignalQuality() {
68 return new Promise(async (resolve) => { 83 return new Promise(async (resolve) => {
69 await mutex.lock(MUTEX_COMMAND, 'queryCOPS'); 84 await mutex.lock(MUTEX_COMMAND, 'queryCOPS');
70 await writeToPort('AT+COPS?\r'); 85 await writeToPort('AT+COPS?\r');
71 mutex.unlock(MUTEX_COMMAND, 'queryCOPS'); 86 mutex.unlock(MUTEX_COMMAND, 'queryCOPS');
72 resolve(true); 87 resolve(true);
73 }); 88 });
74 }; 89 };
75 90
76 exports.queryIMEI = function queryIMEI() { 91 exports.queryIMEI = function queryIMEI() {
77 return new Promise(async (resolve) => { 92 return new Promise(async (resolve) => {
78 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 93 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
79 parser.on('data', (data) => { 94 parser.on('data', (data) => {
80 logger.verbose('INCOMING', { parser: 'parserIMEI', data: data.toString() }); 95 logger.verbose('INCOMING', { parser: 'parserIMEI', data: data.toString() });
81 port.unpipe(parser); 96 port.unpipe(parser);
82 mutex.unlock(MUTEX_COMMAND, 'queryIMEI'); 97 mutex.unlock(MUTEX_COMMAND, 'queryIMEI');
83 modemInfo.imei = data.toString().trim(); 98 modemInfo.imei = data.toString().trim();
84 resolve(modemInfo.imei); 99 resolve(modemInfo.imei);
85 }); 100 });
86 101
87 await mutex.lock(MUTEX_COMMAND, 'queryIMEI'); 102 await mutex.lock(MUTEX_COMMAND, 'queryIMEI');
88 103
89 port.pipe(parser); 104 port.pipe(parser);
90 await writeToPort('AT+CGSN\r'); 105 await writeToPort('AT+CGSN\r');
91 }); 106 });
92 }; 107 };
93 108
94 exports.queryIMSI = function queryIMSI() { 109 exports.queryIMSI = function queryIMSI() {
95 return new Promise(async (resolve) => { 110 return new Promise(async (resolve) => {
96 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 111 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
97 parser.on('data', (data) => { 112 parser.on('data', (data) => {
98 logger.verbose('INCOMING', { parser: 'parserIMSI', data: data.toString() }); 113 logger.verbose('INCOMING', { parser: 'parserIMSI', data: data.toString() });
99 port.unpipe(parser); 114 port.unpipe(parser);
100 mutex.unlock(MUTEX_COMMAND, 'queryIMSI'); 115 mutex.unlock(MUTEX_COMMAND, 'queryIMSI');
101 modemInfo.imsi = data.toString().trim(); 116 modemInfo.imsi = data.toString().trim();
102 resolve(modemInfo.imsi); 117 resolve(modemInfo.imsi);
103 }); 118 });
104 119
105 await mutex.lock(MUTEX_COMMAND, 'queryIMSI'); 120 await mutex.lock(MUTEX_COMMAND, 'queryIMSI');
106 121
107 port.pipe(parser); 122 port.pipe(parser);
108 await writeToPort('AT+CIMI\r'); 123 await writeToPort('AT+CIMI\r');
109 }); 124 });
110 }; 125 };
111 126
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 let port; 17 let port;
18 18
19 function sleep(ms) { 19 function sleep(ms) {
20 return new Promise((resolve) => { 20 return new Promise((resolve) => {
21 setTimeout(() => { 21 setTimeout(() => {
22 resolve(); 22 resolve();
23 }, ms || 0); 23 }, ms || 0);
24 }); 24 });
25 } 25 }
26 26
27 function writeToPort(data) { 27 function writeToPort(data) {
28 return new Promise((resolve) => { 28 return new Promise((resolve) => {
29 port.write(data, (err, bytesWritten) => { 29 port.write(data, (err, bytesWritten) => {
30 if (err) logger.warn(`ERROR: ${err.toString()}`); 30 if (err) logger.warn(`ERROR: ${err.toString()}`);
31 31
32 logger.verbose('OUTGOING', { bytesWritten, data: data.toString() }); 32 logger.verbose('OUTGOING', { bytesWritten, data: data.toString() });
33 resolve(bytesWritten); 33 resolve(bytesWritten);
34 }); 34 });
35 }); 35 });
36 } 36 }
37 37
38 async function writeToPortDelayed(data, ms) { 38 async function writeToPortDelayed(data, ms) {
39 await sleep(ms || 500); 39 await sleep(ms || 500);
40 const result = writeToPort(data); 40 const result = writeToPort(data);
41 return result; 41 return result;
42 } 42 }
43 43
44 port = new SerialPort(config.modem.device, { baudRate: 115200 }, async (err) => { 44 port = new SerialPort(config.modem.device, { baudRate: 115200 }, async (err) => {
45 if (err) { 45 if (err) {
46 logger.warn(`Error opening modem. ${err}. Terminating modem ${config.modem.device}.`); 46 logger.warn(`Error opening modem. ${err}. Terminating modem ${config.modem.device}.`);
47 process.exit(1); 47 process.exit(1);
48 } 48 }
49 49
50 await writeToPortDelayed('AT\r'); 50 await writeToPortDelayed('AT\r');
51 51
52 await modemCommands.writeToPortAndWaitForReadline('AT&FE0\r'); 52 await modemCommands.writeToPortAndWaitForOkOrError('AT&FE0\r');
53 await modemCommands.writeToPortAndWaitForReadline('AT+CMGF=0\r'); 53 await modemCommands.writeToPortAndWaitForOkOrError('AT+CMGF=0\r');
54 await modemCommands.writeToPortAndWaitForReadline('AT+CNMI=1,2,0,1,0\r'); 54 await modemCommands.writeToPortAndWaitForOkOrError('AT+CNMI=1,2,0,1,0\r');
55 55
56 const imei = await modemCommands.queryIMEI(); 56 const imei = await modemCommands.queryIMEI();
57 logger.info(`**** IMEI: ${imei}`); 57 logger.info(`**** IMEI: ${imei}`);
58 58
59 const imsi = await modemCommands.queryIMSI(); 59 const imsi = await modemCommands.queryIMSI();
60 logger.info(`**** IMSI: ${imsi}`); 60 logger.info(`**** IMSI: ${imsi}`);
61 61
62 const cops = await modemCommands.queryCOPS(); 62 const cops = await modemCommands.queryCOPS();
63 logger.info(`**** COPS: ${cops}`); 63 logger.info(`**** COPS: ${cops}`);
64 64
65 const signalQuality = await modemCommands.querySignalQuality(); 65 const signalQuality = await modemCommands.querySignalQuality();
66 logger.info(`**** Signal Quality: ${signalQuality}`); 66 logger.info(`**** Signal Quality: ${signalQuality}`);
67 67
68 setInterval(() => { 68 setInterval(() => {
69 modemCommands.querySignalQuality(); 69 modemCommands.querySignalQuality();
70 }, (config && config.interval_beetwen_signal_strength_ms) || 30000); 70 }, (config && config.interval_beetwen_signal_strength_ms) || 30000);
71 }); 71 });
72 72
73 parsers.setPort(port); 73 parsers.setPort(port);
74 modemCommands.setPort(port); 74 modemCommands.setPort(port);
75 75
76 if (config && config.modem_tester && config.modem_tester.parser === 'regex') { 76 if (config && config.modem_tester && config.modem_tester.parser === 'regex') {
77 logger.info('Using parserWaitForOkOrError'); 77 logger.info('Using parserWaitForOkOrError');
78 port.pipe(parsers.parserWaitForOkOrError); 78 port.pipe(parsers.parserWaitForOkOrError);
79 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') { 79 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') {
80 logger.info('Using parserInterByteTimeout'); 80 logger.info('Using parserInterByteTimeout');
81 port.pipe(parserInterByteTimeout); 81 port.pipe(parserInterByteTimeout);
82 } else { 82 } else {
83 logger.info('Using parserReadline'); 83 logger.info('Using parserReadline');
84 port.pipe(parsers.parserReadline); 84 port.pipe(parsers.parserReadline);
85 } 85 }
86 86