Komodo / komodo-modem-sms

Download as
Browse Code ยป

Commit 08d2d23e1c8712dd08758b08327147ddfc4aedf6

Authored by Adhidarma Hadiwinoto
1 parent c5e93b5ea3
Exists in master

Perbaikan mutex unlick pada queryIMEIAndIMSI

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

lib/modem-commands.js
Diff comments   View file @ 08d2d23
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; 26 let resolved = false;
27 27
28 return new Promise(async (resolve) => { 28 return new Promise(async (resolve) => {
29 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER }); 29 const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER });
30 parser.on('data', (data) => { 30 parser.on('data', (data) => {
31 port.unpipe(parser); 31 port.unpipe(parser);
32 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 32 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
33 if (!resolved) { 33 if (!resolved) {
34 resolved = true; 34 resolved = true;
35 resolve(data); 35 resolve(data);
36 } 36 }
37 }); 37 });
38 38
39 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 39 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
40 port.pipe(parser); 40 port.pipe(parser);
41 await writeToPort(cmd); 41 await writeToPort(cmd);
42 }); 42 });
43 }; 43 };
44 44
45 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) { 45 exports.writeToPortAndWaitForOkOrError = function writeToPortAndWaitForOkOrError(cmd, lockName) {
46 return new Promise(async (resolve) => { 46 return new Promise(async (resolve) => {
47 const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ }); 47 const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ });
48 parser.on('data', (data) => { 48 parser.on('data', (data) => {
49 port.unpipe(parser); 49 port.unpipe(parser);
50 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim()); 50 mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
51 resolve(data); 51 resolve(data);
52 }); 52 });
53 53
54 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim()); 54 await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
55 port.pipe(parser); 55 port.pipe(parser);
56 await writeToPort(cmd); 56 await writeToPort(cmd);
57 }); 57 });
58 }; 58 };
59 59
60 exports.sleep = function sleep(ms) { 60 exports.sleep = function sleep(ms) {
61 return new Promise((resolve) => { 61 return new Promise((resolve) => {
62 setTimeout(() => { 62 setTimeout(() => {
63 resolve(); 63 resolve();
64 }, ms || 0); 64 }, ms || 0);
65 }); 65 });
66 }; 66 };
67 67
68 68
69 exports.setPort = function setPort(val) { 69 exports.setPort = function setPort(val) {
70 port = val; 70 port = val;
71 }; 71 };
72 72
73 exports.querySignalQuality = function querySignalQuality() { 73 exports.querySignalQuality = function querySignalQuality() {
74 return new Promise(async (resolve) => { 74 return new Promise(async (resolve) => {
75 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) { 75 if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) {
76 resolve(false); 76 resolve(false);
77 return; 77 return;
78 } 78 }
79 79
80 await writeToPort('AT+CSQ\r'); 80 await writeToPort('AT+CSQ\r');
81 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality'); 81 mutex.unlock(MUTEX_COMMAND, 'querySignalQuality');
82 resolve(true); 82 resolve(true);
83 }); 83 });
84 }; 84 };
85 85
86 exports.queryCOPS = function queryCOPS(lockName) { 86 exports.queryCOPS = function queryCOPS(lockName) {
87 return new Promise(async (resolve) => { 87 return new Promise(async (resolve) => {
88 await mutex.lock(lockName || MUTEX_COMMAND, 'queryCOPS'); 88 await mutex.lock(lockName || MUTEX_COMMAND, 'queryCOPS');
89 await writeToPort('AT+COPS?\r'); 89 await writeToPort('AT+COPS?\r');
90 mutex.unlock(lockName || MUTEX_COMMAND, 'queryCOPS'); 90 mutex.unlock(lockName || MUTEX_COMMAND, 'queryCOPS');
91 resolve(true); 91 resolve(true);
92 }); 92 });
93 }; 93 };
94 94
95 exports.queryCOPSAndSignalQuality = function queryCOPSAndSignalQuality(skipOnLocked) { 95 exports.queryCOPSAndSignalQuality = function queryCOPSAndSignalQuality(skipOnLocked) {
96 return new Promise(async (resolve) => { 96 return new Promise(async (resolve) => {
97 if (!skipOnLocked) { 97 if (!skipOnLocked) {
98 await mutex.lock(MUTEX_COMMAND); 98 await mutex.lock(MUTEX_COMMAND);
99 } else if (!mutex.tryLock(MUTEX_COMMAND, 'queryCOPSAndSignalQuality')) { 99 } else if (!mutex.tryLock(MUTEX_COMMAND, 'queryCOPSAndSignalQuality')) {
100 resolve(false); 100 resolve(false);
101 return; 101 return;
102 } 102 }
103 103
104 await this.writeToPortAndWaitForOkOrError('AT+COPS?\r', MUTEX_SUBCOMMAND); 104 await this.writeToPortAndWaitForOkOrError('AT+COPS?\r', MUTEX_SUBCOMMAND);
105 await this.writeToPortAndWaitForOkOrError('AT+CSQ\r', MUTEX_SUBCOMMAND); 105 await this.writeToPortAndWaitForOkOrError('AT+CSQ\r', MUTEX_SUBCOMMAND);
106 106
107 mutex.unlock(MUTEX_COMMAND, 'queryCopsAndSignalQuality'); 107 mutex.unlock(MUTEX_COMMAND, 'queryCopsAndSignalQuality');
108 resolve(true); 108 resolve(true);
109 }); 109 });
110 }; 110 };
111 111
112 exports.queryIMEI = function queryIMEI(lockName) { 112 exports.queryIMEI = function queryIMEI(lockName) {
113 return new Promise(async (resolve) => { 113 return new Promise(async (resolve) => {
114 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 114 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
115 parser.on('data', (data) => { 115 parser.on('data', (data) => {
116 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' }); 116 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' });
117 port.unpipe(parser); 117 port.unpipe(parser);
118 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMEI'); 118 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMEI');
119 modemInfo.imei = data.toString().trim(); 119 modemInfo.imei = data.toString().trim();
120 resolve(modemInfo.imei); 120 resolve(modemInfo.imei);
121 }); 121 });
122 122
123 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMEI'); 123 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMEI');
124 124
125 port.pipe(parser); 125 port.pipe(parser);
126 await writeToPort('AT+CGSN\r'); 126 await writeToPort('AT+CGSN\r');
127 }); 127 });
128 }; 128 };
129 129
130 exports.queryIMSI = function queryIMSI(lockName) { 130 exports.queryIMSI = function queryIMSI(lockName) {
131 return new Promise(async (resolve) => { 131 return new Promise(async (resolve) => {
132 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX }); 132 const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
133 parser.on('data', (data) => { 133 parser.on('data', (data) => {
134 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' }); 134 logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' });
135 port.unpipe(parser); 135 port.unpipe(parser);
136 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMSI'); 136 mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMSI');
137 modemInfo.imsi = data.toString().trim(); 137 modemInfo.imsi = data.toString().trim();
138 resolve(modemInfo.imsi); 138 resolve(modemInfo.imsi);
139 }); 139 });
140 140
141 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMSI'); 141 await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMSI');
142 142
143 port.pipe(parser); 143 port.pipe(parser);
144 await writeToPort('AT+CIMI\r'); 144 await writeToPort('AT+CIMI\r');
145 }); 145 });
146 }; 146 };
147 147
148 exports.queryIMEIAndIMSI = async function queryIMEIAndIMSI() { 148 exports.queryIMEIAndIMSI = async function queryIMEIAndIMSI() {
149 await mutex.lock(MUTEX_COMMAND, 'queryIMEIAndIMSI'); 149 await mutex.lock(MUTEX_COMMAND, 'queryIMEIAndIMSI');
150 150
151 await this.queryIMEI(MUTEX_SUBCOMMAND); 151 await this.queryIMEI(MUTEX_SUBCOMMAND);
152 await this.queryIMSI(MUTEX_SUBCOMMAND); 152 await this.queryIMSI(MUTEX_SUBCOMMAND);
153 153
154 await mutex.unlock(MUTEX_SUBCOMMAND, 'queryIMEIAndIMSI'); 154 await mutex.unlock(MUTEX_COMMAND, 'queryIMEIAndIMSI');
155 }; 155 };
156 156