Komodo / komodo-modem-sms

Download as
Browse Code ยป

Commit fad8552593ea413b7330012ef4266eeb9ab816ce

Authored by Adhidarma Hadiwinoto
1 parent 3522ae5bc9
Exists in master

Perbaikan waitForOkOrError

Showing 3 changed files with 17 additions and 5 deletions Inline Diff

lib/modem-commands.js
Diff comments   View file @ fad8552
1 const MUTEX_COMMAND = 'COMMAND'; 1 const MUTEX_COMMAND = 'COMMAND';
2 exports.MUTEX_COMMAND = MUTEX_COMMAND;
3
2 const MUTEX_SUBCOMMAND = 'SUBCOMMAND'; 4 const MUTEX_SUBCOMMAND = 'SUBCOMMAND';
5 exports.MUTEX_SUBCOMMAND = MUTEX_SUBCOMMAND;
3 6
4 const ParserReadline = require('@serialport/parser-readline'); 7 const ParserReadline = require('@serialport/parser-readline');
5 const ParserRegex = require('@serialport/parser-regex'); 8 const ParserRegex = require('@serialport/parser-regex');
6 9
7 const logger = require('komodo-sdk/logger'); 10 const logger = require('komodo-sdk/logger');
8 const mutex = require('./mutex-common'); 11 const mutex = require('./mutex-common');
9 const parsers = require('./serialport-parsers'); 12 const parsers = require('./serialport-parsers');
10 const modemInfo = require('./modem-info'); 13 const modemInfo = require('./modem-info');
11 14
12 let port; 15 let port;
13 16
14 function writeToPort(data) { 17 function writeToPort(data) {
15 return new Promise((resolve) => { 18 return new Promise((resolve) => {
16 modemInfo.lastWriteTs = new Date(); 19 modemInfo.lastWriteTs = new Date();
17 port.write(data, (err, bytesWritten) => { 20 port.write(data, (err, bytesWritten) => {
18 if (err) logger.warn(`ERROR: ${err.toString()}`); 21 if (err) logger.warn(`ERROR: ${err.toString()}`);
19 22
20 logger.verbose('OUTGOING', { data: data.toString(), bytesWritten, err }); 23 logger.verbose('OUTGOING', { data: data.toString(), bytesWritten, err });
21 resolve(bytesWritten); 24 resolve(bytesWritten);
22 }); 25 });
23 }); 26 });
24 } 27 }
25 28
26 exports.writeToPortAndWaitForReadline = function writeToPortAndWaitForReadline(cmd, lockName) { 29 exports.writeToPortAndWaitForReadline = function writeToPortAndWaitForReadline(cmd, lockName) {
27 let resolved = false; 30 let resolved = false;
28 31
29 return new Promise(async (resolve) => { 32 return new Promise(async (resolve) => {
30 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER }); 33 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER });
31 parser.on('data', (data) => { 34 parser.on('data', (data) => {
32 port.unpipe(parser); 35 port.unpipe(parser);
33 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 36 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
34 if (!resolved) { 37 if (!resolved) {
35 resolved = true; 38 resolved = true;
36 resolve(data); 39 resolve(data);
37 } 40 }
38 }); 41 });
39 42
40 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 43 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
41 port.pipe(parser); 44 port.pipe(parser);
42 await writeToPort(cmd); 45 await writeToPort(cmd);
43 }); 46 });
44 }; 47 };
45 48
46 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) { 49 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) {
47 return new Promise(async (resolve) => { 50 return new Promise(async (resolve) => {
48 const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ }); 51 const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ });
49 parser.on('data', (data) => { 52 parser.on('data', (data) => {
50 port.unpipe(parser); 53 port.unpipe(parser);
51 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 54 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
52 resolve(data); 55 resolve(data);
53 }); 56 });
54 57
55 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 58 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
56 port.pipe(parser); 59 port.pipe(parser);
57 await writeToPort(cmd); 60 await writeToPort(cmd);
58 }); 61 });
59 }; 62 };
60 63
61 exports.sleep = function sleep(ms) { 64 exports.sleep = function sleep(ms) {
62 return new Promise((resolve) => { 65 return new Promise((resolve) => {
63 setTimeout(() => { 66 setTimeout(() => {
64 resolve(); 67 resolve();
65 }, ms || 0); 68 }, ms || 0);
66 }); 69 });
67 }; 70 };
68 71
69 72
70 exports.setPort = function setPort(val) { 73 exports.setPort = function setPort(val) {
71 port = val; 74 port = val;
72 }; 75 };
73 76
74 exports.querySignalQuality = function querySignalQuality() { 77 exports.querySignalQuality = function querySignalQuality() {
75 return new Promise(async (resolve) => { 78 return new Promise(async (resolve) => {
76 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) { 79 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) {
77 resolve(false); 80 resolve(false);
78 return; 81 return;
79 } 82 }
80 83
81 await writeToPort('AT+CSQ\r'); 84 await writeToPort('AT+CSQ\r');
82 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality'); 85 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality');
83 resolve(true); 86 resolve(true);
84 }); 87 });
85 }; 88 };
86 89
87 exports.queryCOPS = function queryCOPS(lockName) { 90 exports.queryCOPS = function queryCOPS(lockName) {
88 return new Promise(async (resolve) => { 91 return new Promise(async (resolve) => {
89 await mutex.lock(lockName || MUTEX_COMMAND, 'queryCOPS'); 92 await mutex.lock(lockName || MUTEX_COMMAND, 'queryCOPS');
90 await writeToPort('AT+COPS?\r'); 93 await writeToPort('AT+COPS?\r');
91 mutex.unlock(lockName || MUTEX_COMMAND, 'queryCOPS'); 94 mutex.unlock(lockName || MUTEX_COMMAND, 'queryCOPS');
92 resolve(true); 95 resolve(true);
93 }); 96 });
94 }; 97 };
95 98
96 exports.queryCOPSAndSignalQuality = function queryCOPSAndSignalQuality(skipOnLocked) { 99 exports.queryCOPSAndSignalQuality = function queryCOPSAndSignalQuality(skipOnLocked) {
97 return new Promise(async (resolve) => { 100 return new Promise(async (resolve) => {
98 if (!skipOnLocked) { 101 if (!skipOnLocked) {
99 await mutex.lock(MUTEX_COMMAND); 102 await mutex.lock(MUTEX_COMMAND);
100 } else if (!mutex.tryLock(MUTEX_COMMAND, 'queryCOPSAndSignalQuality')) { 103 } else if (!mutex.tryLock(MUTEX_COMMAND, 'queryCOPSAndSignalQuality')) {
101 resolve(false); 104 resolve(false);
102 return; 105 return;
103 } 106 }
104 107
105 await this.writeToPortAndWaitForOkOrError('AT+COPS?\r', MUTEX_SUBCOMMAND); 108 await this.writeToPortAndWaitForOkOrError('AT+COPS?\r', MUTEX_SUBCOMMAND);
106 await this.writeToPortAndWaitForOkOrError('AT+CSQ\r', MUTEX_SUBCOMMAND); 109 await this.writeToPortAndWaitForOkOrError('AT+CSQ\r', MUTEX_SUBCOMMAND);
107 110
108 mutex.unlock(MUTEX_COMMAND, 'queryCopsAndSignalQuality'); 111 mutex.unlock(MUTEX_COMMAND, 'queryCopsAndSignalQuality');
109 resolve(true); 112 resolve(true);
110 }); 113 });
111 }; 114 };
112 115
113 exports.queryIMEI = function queryIMEI(lockName) { 116 exports.queryIMEI = function queryIMEI(lockName) {
114 return new Promise(async (resolve) => { 117 return new Promise(async (resolve) => {
115 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 118 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
116 parser.on('data', (data) => { 119 parser.on('data', (data) => {
117 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' }); 120 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' });
118 port.unpipe(parser); 121 port.unpipe(parser);
119 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMEI'); 122 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMEI');
120 modemInfo.imei = data.toString().trim(); 123 modemInfo.imei = data.toString().trim() || null;
121 logger.info('IMEI extracted', { imei: modemInfo.imei }); 124 logger.info('IMEI extracted', { imei: modemInfo.imei });
122 resolve(modemInfo.imei); 125 resolve(modemInfo.imei);
123 }); 126 });
124 127
125 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMEI'); 128 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMEI');
126 129
127 port.pipe(parser); 130 port.pipe(parser);
128 await writeToPort('AT+CGSN\r'); 131 await writeToPort('AT+CGSN\r');
129 }); 132 });
130 }; 133 };
131 134
132 exports.queryIMSI = function queryIMSI(lockName) { 135 exports.queryIMSI = function queryIMSI(lockName) {
133 return new Promise(async (resolve) => { 136 return new Promise(async (resolve) => {
134 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 137 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
135 parser.on('data', (data) => { 138 parser.on('data', (data) => {
136 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' }); 139 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' });
137 port.unpipe(parser); 140 port.unpipe(parser);
138 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMSI'); 141 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMSI');
139 modemInfo.imsi = data.toString().trim(); 142 modemInfo.imsi = data.toString().trim() || null;
140 logger.info('IMSI extracted', { imsi: modemInfo.imsi }); 143 logger.info('IMSI extracted', { imsi: modemInfo.imsi });
141 resolve(modemInfo.imsi); 144 resolve(modemInfo.imsi);
142 }); 145 });
143 146
144 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMSI'); 147 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMSI');
145 148
146 port.pipe(parser); 149 port.pipe(parser);
147 await writeToPort('AT+CIMI\r'); 150 await writeToPort('AT+CIMI\r');
148 }); 151 });
149 }; 152 };
150 153
151 exports.queryIMEIAndIMSI = async function queryIMEIAndIMSI() { 154 exports.queryIMEIAndIMSI = async function queryIMEIAndIMSI() {
152 await mutex.lock(MUTEX_COMMAND, 'queryIMEIAndIMSI'); 155 await mutex.lock(MUTEX_COMMAND, 'queryIMEIAndIMSI');
153 156
154 const imei = await this.queryIMEI(MUTEX_SUBCOMMAND); 157 const imei = await this.queryIMEI(MUTEX_SUBCOMMAND);
155 const imsi = await this.queryIMSI(MUTEX_SUBCOMMAND); 158 const imsi = await this.queryIMSI(MUTEX_SUBCOMMAND);
156 159
157 await mutex.unlock(MUTEX_COMMAND, 'queryIMEIAndIMSI'); 160 await mutex.unlock(MUTEX_COMMAND, 'queryIMEIAndIMSI');
158 return { imei, imsi }; 161 return { imei, imsi };
159 }; 162 };
163
164 exports.initATCommands = async function initATCommands() {
165 await mutex.lock(MUTEX_COMMAND, 'INIT MODEM');
166 await this.writeToPortAndWaitForOkOrError('ATE0\r', MUTEX_SUBCOMMAND);
167 await this.writeToPortAndWaitForOkOrError('AT+CMGF=0\r', MUTEX_SUBCOMMAND);
168 await this.writeToPortAndWaitForOkOrError('AT+CNMI=1,2,0,1,0\r', MUTEX_SUBCOMMAND);
169 mutex.unlock(MUTEX_COMMAND, 'INIT MODEM');
170 };
160 171
lib/serialport-parsers.js
Diff comments   View file @ fad8552
1 const PARSER_READLINE_DELIMITER = '\r\n'; 1 const PARSER_READLINE_DELIMITER = '\r\n';
2 const PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = /\r\n(?:OK|ERROR)\r\n/; 2 const PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = /\n(?:OK|ERROR)\r\n/;
3 3
4 const moment = require('moment'); 4 const moment = require('moment');
5 const nodePdu = require('node-pdu'); 5 const nodePdu = require('node-pdu');
6 // const pdu = require('pdu'); 6 // const pdu = require('pdu');
7 const ParserReadline = require('@serialport/parser-readline'); 7 const ParserReadline = require('@serialport/parser-readline');
8 const ParserRegex = require('@serialport/parser-regex'); 8 const ParserRegex = require('@serialport/parser-regex');
9 9
10 const logger = require('komodo-sdk/logger'); 10 const logger = require('komodo-sdk/logger');
11 11
12 const dbCops = require('./db-cops'); 12 const dbCops = require('./db-cops');
13 const modemInfo = require('./modem-info'); 13 const modemInfo = require('./modem-info');
14 14
15 let port; 15 let port;
16 16
17 exports.setPort = function setPort(val) { 17 exports.setPort = function setPort(val) {
18 logger.info('SERIALPORT-PARSERS: setting port'); 18 logger.info('SERIALPORT-PARSERS: setting port');
19 port = val; 19 port = val;
20 }; 20 };
21 21
22 exports.getPort = function getPort() { 22 exports.getPort = function getPort() {
23 return port; 23 return port;
24 }; 24 };
25 25
26 function parsePdu(data) { 26 function parsePdu(data) {
27 if (!data) return null; 27 if (!data) return null;
28 28
29 try { 29 try {
30 const result = nodePdu.parse(data.toString().trim() || ''); 30 const result = nodePdu.parse(data.toString().trim() || '');
31 return result; 31 return result;
32 } catch (e) { 32 } catch (e) {
33 return null; 33 return null;
34 } 34 }
35 } 35 }
36 36
37 function onCSQ(data) { 37 function onCSQ(data) {
38 const val = data.toString().trim().match(/\+CSQ:\s*(.*)/); 38 const val = data.toString().trim().match(/\+CSQ:\s*(.*)/);
39 if (!val || !val[1]) return null; 39 if (!val || !val[1]) return null;
40 40
41 const [, signalStrength] = val; 41 const [, signalStrength] = val;
42 42
43 logger.info('Signal quality extracted', { signalQuality: val[1] }); 43 logger.info('Signal quality extracted', { signalQuality: val[1] });
44 44
45 modemInfo.signalStrength = signalStrength; 45 modemInfo.signalStrength = signalStrength;
46 modemInfo.signalStrengthTs = new Date(); 46 modemInfo.signalStrengthTs = new Date();
47 modemInfo.signalStrengthTsReadable = moment(modemInfo.signalStrengthTs).format('YYYY-MM-DD HH:mm:ss'); 47 modemInfo.signalStrengthTsReadable = moment(modemInfo.signalStrengthTs).format('YYYY-MM-DD HH:mm:ss');
48 48
49 return signalStrength; 49 return signalStrength;
50 } 50 }
51 51
52 function onPduDeliver(data, parsedData) { 52 function onPduDeliver(data, parsedData) {
53 const from = parsedData.getAddress && parsedData.getAddress().getPhone 53 const from = parsedData.getAddress && parsedData.getAddress().getPhone
54 ? parsedData.getAddress().getPhone() : null; 54 ? parsedData.getAddress().getPhone() : null;
55 55
56 const msg = parsedData.getData && parsedData.getData().getData 56 const msg = parsedData.getData && parsedData.getData().getData
57 ? parsedData.getData().getData() : null; 57 ? parsedData.getData().getData() : null;
58 58
59 const ts = new Date(parsedData.getScts().getIsoString()); 59 const ts = new Date(parsedData.getScts().getIsoString());
60 60
61 logger.verbose('PDU processed', { ts, from, msg }); 61 logger.verbose('PDU processed', { ts, from, msg });
62 return { from, msg }; 62 return { from, msg };
63 } 63 }
64 64
65 function onCOPS(data) { 65 function onCOPS(data) {
66 const val = data.toString().trim().match(/\+COPS:\s*(.*)/); 66 const val = data.toString().trim().match(/\+COPS:\s*(.*)/);
67 if (!val || !val[1]) return null; 67 if (!val || !val[1]) return null;
68 68
69 const cops = val[1]; 69 const cops = val[1];
70 70
71 if (!cops) return null; 71 if (!cops) return null;
72 const [mode, format, networkId] = cops.split(','); 72 const [mode, format, networkId] = cops.split(',');
73 const networkName = networkId ? dbCops[networkId] || networkId : null; 73 const networkName = networkId ? dbCops[networkId] || networkId : null;
74 74
75 logger.info('COPS extracted', { 75 logger.info('COPS extracted', {
76 cops, mode, format, networkId, networkName, 76 cops, mode, format, networkId, networkName,
77 }); 77 });
78 78
79 modemInfo.cops = cops; 79 modemInfo.cops = cops;
80 modemInfo.networkId = networkId; 80 modemInfo.networkId = networkId || null;
81 modemInfo.networkName = networkName; 81 modemInfo.networkName = networkName || null;
82 82
83 return { 83 return {
84 cops, mode, format, networkId, networkName, 84 cops, mode, format, networkId, networkName,
85 }; 85 };
86 } 86 }
87 87
88 88
89 function isResultCodeIs(data, resultCode) { 89 function isResultCodeIs(data, resultCode) {
90 if (!data) return false; 90 if (!data) return false;
91 const cleanedData = (data.toString() || '').trim(); 91 const cleanedData = (data.toString() || '').trim();
92 if (!cleanedData) return false; 92 if (!cleanedData) return false;
93 93
94 if (resultCode.indexOf('+') !== 0) { 94 if (resultCode.indexOf('+') !== 0) {
95 // eslint-disable-next-line no-param-reassign 95 // eslint-disable-next-line no-param-reassign
96 resultCode = `+${resultCode}`; 96 resultCode = `+${resultCode}`;
97 } 97 }
98 98
99 if (resultCode.search(/:$/) < 0) { 99 if (resultCode.search(/:$/) < 0) {
100 // eslint-disable-next-line no-param-reassign 100 // eslint-disable-next-line no-param-reassign
101 resultCode += ':'; 101 resultCode += ':';
102 } 102 }
103 103
104 return cleanedData.indexOf(resultCode) === 0; 104 return cleanedData.indexOf(resultCode) === 0;
105 } 105 }
106 106
107 const parserReadline = new ParserReadline({ delimiter: PARSER_READLINE_DELIMITER }); 107 const parserReadline = new ParserReadline({ delimiter: PARSER_READLINE_DELIMITER });
108 parserReadline.on('data', (data) => { 108 parserReadline.on('data', (data) => {
109 modemInfo.lastReadTs = new Date(); 109 modemInfo.lastReadTs = new Date();
110 logger.verbose('INCOMING', { data: `${data.toString()}${PARSER_READLINE_DELIMITER}`, parser: 'parserReadLine' }); 110 logger.verbose('INCOMING', { data: `${data.toString()}${PARSER_READLINE_DELIMITER}`, parser: 'parserReadLine' });
111 111
112 if (!data) return; 112 if (!data) return;
113 113
114 const pduParsed = parsePdu(data); 114 const pduParsed = parsePdu(data);
115 if (pduParsed) { 115 if (pduParsed) {
116 logger.verbose('PDU parsed', { type: (typeof pduParsed.getType === 'function') && pduParsed.getType() }); 116 logger.verbose('PDU parsed', { type: (typeof pduParsed.getType === 'function') && pduParsed.getType() });
117 } 117 }
118 118
119 if (pduParsed && pduParsed.constructor.name !== 'Deliver') { 119 if (pduParsed && pduParsed.constructor.name !== 'Deliver') {
120 logger.warn('WARN-9DA32C41: Unknown PDU message type name. PLEASE REPORT IT TO DEVELOPER AT TEKTRANS', { typeName: pduParsed.constructor.name, type: pduParsed.getType(), data: data.toString().trim() }); 120 logger.warn('WARN-9DA32C41: Unknown PDU message type name. PLEASE REPORT IT TO DEVELOPER AT TEKTRANS', { typeName: pduParsed.constructor.name, type: pduParsed.getType(), data: data.toString().trim() });
121 } 121 }
122 122
123 if (pduParsed && pduParsed.constructor.name === 'Deliver' && pduParsed.getData().getSize()) { 123 if (pduParsed && pduParsed.constructor.name === 'Deliver' && pduParsed.getData().getSize()) {
124 logger.verbose('Got a PDU SMS-DELIVER', { type: pduParsed.getType() }); 124 logger.verbose('Got a PDU SMS-DELIVER', { type: pduParsed.getType() });
125 onPduDeliver(data, pduParsed); 125 onPduDeliver(data, pduParsed);
126 } else if (isResultCodeIs(data, 'CSQ')) { 126 } else if (isResultCodeIs(data, 'CSQ')) {
127 logger.verbose('Got a signal quality report', { data: data.toString() }); 127 logger.verbose('Got a signal quality report', { data: data.toString() });
128 onCSQ(data); 128 onCSQ(data);
129 } else if (isResultCodeIs(data, 'COPS:')) { 129 } else if (isResultCodeIs(data, 'COPS:')) {
130 logger.verbose('Got a COPS report', { data: data.toString() }); 130 logger.verbose('Got a COPS report', { data: data.toString() });
131 onCOPS(data); 131 onCOPS(data);
132 } else if (isResultCodeIs(data, 'CMT')) { 132 } else if (isResultCodeIs(data, 'CMT')) {
133 logger.verbose('Got a new message report', { data: data.toString() }); 133 logger.verbose('Got a new message report', { data: data.toString() });
134 } else if (isResultCodeIs(data, 'CMTI')) { 134 } else if (isResultCodeIs(data, 'CMTI')) {
135 logger.verbose('Got a new message notification report', { data: data.toString() }); 135 logger.verbose('Got a new message notification report', { data: data.toString() });
136 } 136 }
137 }); 137 });
138 138
139 const parserWaitForOkOrError = new ParserRegex({ regex: PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 139 const parserWaitForOkOrError = new ParserRegex({ regex: PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
140 parserWaitForOkOrError.on('data', (data) => { 140 parserWaitForOkOrError.on('data', (data) => {
141 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserWaitForOkOrError' }); 141 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserWaitForOkOrError' });
142 }); 142 });
143 143
144 144
145 exports.PARSER_READLINE_DELIMITER = PARSER_READLINE_DELIMITER; 145 exports.PARSER_READLINE_DELIMITER = PARSER_READLINE_DELIMITER;
146 exports.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = PARSER_WAIT_FOR_OK_OR_ERROR_REGEX; 146 exports.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = PARSER_WAIT_FOR_OK_OR_ERROR_REGEX;
147 147
148 exports.parserReadline = parserReadline; 148 exports.parserReadline = parserReadline;
149 exports.parserWaitForOkOrError = parserWaitForOkOrError; 149 exports.parserWaitForOkOrError = parserWaitForOkOrError;
150 150
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 const ParserInterByteTimeout = require('@serialport/parser-inter-byte-timeout'); 6 const ParserInterByteTimeout = require('@serialport/parser-inter-byte-timeout');
7 7
8 const parsers = require('./lib/serialport-parsers'); 8 const parsers = require('./lib/serialport-parsers');
9 const modemCommands = require('./lib/modem-commands'); 9 const modemCommands = require('./lib/modem-commands');
10 const modemInfo = require('./lib/modem-info'); 10 const modemInfo = require('./lib/modem-info');
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 await modemCommands.queryIMEIAndIMSI(); 28 await modemCommands.queryIMEIAndIMSI();
29 await modemCommands.queryCOPSAndSignalQuality(); 29 await modemCommands.queryCOPSAndSignalQuality();
30 logger.info('Modem state', modemInfo); 30 logger.info('Modem state', modemInfo);
31 31
32 setInterval(async () => { 32 setInterval(async () => {
33 await modemCommands.initATCommands();
33 await modemCommands.queryIMEIAndIMSI(); 34 await modemCommands.queryIMEIAndIMSI();
34 await modemCommands.queryCOPSAndSignalQuality(); 35 await modemCommands.queryCOPSAndSignalQuality();
35 logger.info('Modem state', modemInfo); 36 logger.info('Modem state', modemInfo);
36 }, (config && config.interval_beetwen_signal_strength_ms) || 30000); 37 }, (config && config.interval_beetwen_signal_strength_ms) || 30000);
37 }); 38 });
38 39
39 parsers.setPort(port); 40 parsers.setPort(port);
40 modemCommands.setPort(port); 41 modemCommands.setPort(port);
41 42
42 if (config && config.modem_tester && config.modem_tester.parser === 'regex') { 43 if (config && config.modem_tester && config.modem_tester.parser === 'regex') {
43 logger.info('Using parserWaitForOkOrError'); 44 logger.info('Using parserWaitForOkOrError');
44 port.pipe(parsers.parserWaitForOkOrError); 45 port.pipe(parsers.parserWaitForOkOrError);
45 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') { 46 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') {
46 logger.info('Using parserInterByteTimeout'); 47 logger.info('Using parserInterByteTimeout');
47 port.pipe(parserInterByteTimeout); 48 port.pipe(parserInterByteTimeout);
48 } else { 49 } else {
49 logger.info('Using parserReadline'); 50 logger.info('Using parserReadline');
50 port.pipe(parsers.parserReadline); 51 port.pipe(parsers.parserReadline);
51 } 52 }
52 53