Komodo / komodo-modem-sms

Browse Code »

Commit 1d6334a9bf44e972f534cb11fd6552c5329477be

Authored by Adhidarma Hadiwinoto 6 years ago

1 parent fded2e0c7f

Exists in master

Coba sms error

Showing 3 changed files with 18 additions and 2 deletions Inline Diff

lib/modem-commands/index.js
lib/serialport-parsers.js
modem-tester.js

lib/modem-commands/index.js

Diff comments View file @ 1d6334a

 const MUTEX_COMMAND = 'COMMAND';
 exports.MUTEX_COMMAND = MUTEX_COMMAND;
 const MUTEX_SUBCOMMAND = 'SUBCOMMAND';
 exports.MUTEX_SUBCOMMAND = MUTEX_SUBCOMMAND;
 const CTRLZ = '\u001a';
 const pdu = require('node-pdu');
 const uuidv1 = require('uuid/v1');
 const ParserReadline = require('@serialport/parser-readline');
 const ParserRegex = require('@serialport/parser-regex');
 const ParserReady = require('@serialport/parser-ready');
 const logger = require('komodo-sdk/logger');
 const mutex = require('../mutex-common');
 const parsers = require('../serialport-parsers');
 const modemInfo = require('../modem-info');
 let port;
 function writeToPort(data) {
     return new Promise((resolve) => {
         modemInfo.lastWriteTs = new Date();
         port.write(data, (err, bytesWritten) => {
             if (err) logger.warn(`ERROR: ${err.toString()}`);
             logger.verbose('OUTGOING', { data: data.toString(), bytesWritten, err });
             resolve(bytesWritten);
         });
     });
 }
 exports.writeToPort = writeToPort;
 function writeToPortAndWaitForReadline(cmd, lockName) {
     let resolved = false;
     return new Promise(async (resolve) => {
         const parser = new ParserReadline({ delimiter: parsers.PARSER_READLINE_DELIMITER });
         parser.on('data', (data) => {
             port.unpipe(parser);
             mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
             if (!resolved) {
                 resolved = true;
                 resolve(data);
             }
         });
         await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
         port.pipe(parser);
         await writeToPort(cmd);
     });
 }
 exports.writeToPortAndWaitForReadline = writeToPortAndWaitForReadline;
 function writeToPortAndWaitForOkOrError(cmd, lockName) {
     return new Promise(async (resolve) => {
         const parser = new ParserRegex({ regex: /(?:OK|ERROR)\r\n/ });
         parser.on('data', (data) => {
             port.unpipe(parser);
             mutex.unlock(lockName || MUTEX_COMMAND, cmd.trim());
             resolve(data);
         });
         await mutex.lock(lockName || MUTEX_COMMAND, cmd.trim());
         port.pipe(parser);
         await writeToPort(cmd);
     });
 }
 exports.writeToPortAndWaitForOkOrError = writeToPortAndWaitForOkOrError;
 function sleep(ms) {
     return new Promise((resolve) => {
         setTimeout(() => {
             resolve();
         }, ms || 0);
     });
 }
 exports.sleep = sleep;
 exports.setPort = function setPort(val) {
     port = val;
 };
 function querySignalQuality() {
     return new Promise(async (resolve) => {
         if (!mutex.tryLock(MUTEX_COMMAND, 'querySignalQuality')) {
             resolve(false);
             return;
         }
         await writeToPort('AT+CSQ\r');
         mutex.unlock(MUTEX_COMMAND, 'querySignalQuality');
         resolve(true);
     });
 }
 exports.querySignalQuality = querySignalQuality;
 function queryCOPS(lockName) {
     return new Promise(async (resolve) => {
         await mutex.lock(lockName || MUTEX_COMMAND, 'queryCOPS');
         await writeToPort('AT+COPS?\r');
         mutex.unlock(lockName || MUTEX_COMMAND, 'queryCOPS');
         resolve(true);
     });
 }
 exports.queryCOPS = queryCOPS;
 function queryCOPSAndSignalQuality(skipOnLocked) {
     return new Promise(async (resolve) => {
         if (!skipOnLocked) {
             await mutex.lock(MUTEX_COMMAND);
         } else if (!mutex.tryLock(MUTEX_COMMAND, 'queryCOPSAndSignalQuality')) {
             resolve(false);
             return;
         }
         await writeToPortAndWaitForOkOrError('AT+COPS?\r', MUTEX_SUBCOMMAND);
         await writeToPortAndWaitForOkOrError('AT+CSQ\r', MUTEX_SUBCOMMAND);
         mutex.unlock(MUTEX_COMMAND, 'queryCopsAndSignalQuality');
         resolve(true);
     });
 }
 exports.queryCOPSAndSignalQuality = queryCOPSAndSignalQuality;
 function queryIMEI(lockName) {
     return new Promise(async (resolve) => {
         const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
         parser.on('data', (data) => {
             logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMEI' });
             port.unpipe(parser);
             mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMEI');
             modemInfo.imei = data.toString().trim() || null;
             logger.info('IMEI extracted', { imei: modemInfo.imei });
             resolve(modemInfo.imei);
         });
         await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMEI');
         port.pipe(parser);
         await writeToPort('AT+CGSN\r');
     });
 }
 exports.queryIMEI = queryIMEI;
 function queryIMSI(lockName) {
     return new Promise(async (resolve) => {
         const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
         parser.on('data', (data) => {
             logger.verbose('INCOMING', { data: data.toString(), parser: 'parserIMSI' });
             port.unpipe(parser);
             mutex.unlock(lockName || MUTEX_COMMAND, 'queryIMSI');
             modemInfo.imsi = data.toString().trim() || null;
             logger.info('IMSI extracted', { imsi: modemInfo.imsi });
             resolve(modemInfo.imsi);
         });
         await mutex.lock(lockName || MUTEX_COMMAND, 'queryIMSI');
         port.pipe(parser);
         await writeToPort('AT+CIMI\r');
     });
 }
 exports.queryIMSI = queryIMSI;
 exports.queryIMEIAndIMSI = async function queryIMEIAndIMSI() {
     await mutex.lock(MUTEX_COMMAND, 'queryIMEIAndIMSI');
     const imei = await queryIMEI(MUTEX_SUBCOMMAND);
     const imsi = await queryIMSI(MUTEX_SUBCOMMAND);
     await mutex.unlock(MUTEX_COMMAND, 'queryIMEIAndIMSI');
     return { imei, imsi };
 };
 exports.queryManufacturer = function queryManufacturer(lockName) {
     return new Promise(async (resolve) => {
         const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
         parser.on('data', (data) => {
             logger.verbose('INCOMING', { data: data.toString(), parser: 'parserManufacturer' });
             port.unpipe(parser);
             mutex.unlock(lockName || MUTEX_COMMAND, 'parserManufacturer');
             modemInfo.manufacturer = data.toString().trim() || null;
             logger.info('Manufacturer extracted', { manufacturer: modemInfo.manufacturer });
             resolve(modemInfo.manufacturer);
         });
         await mutex.lock(lockName || MUTEX_COMMAND, 'queryManufacturer');
         port.pipe(parser);
         await writeToPort('AT+CGMI\r');
     });
 };
 exports.queryModel = function queryModel(lockName) {
     return new Promise(async (resolve) => {
         const parser = new ParserRegex({ regex: parsers.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
         parser.on('data', (data) => {
             logger.verbose('INCOMING', { data: data.toString(), parser: 'parserModel' });
             port.unpipe(parser);
             mutex.unlock(lockName || MUTEX_COMMAND, 'parserModel');
             modemInfo.model = data.toString().trim() || null;
             logger.info('Model extracted', { model: modemInfo.model });
             resolve(modemInfo.model);
         });
         await mutex.lock(lockName || MUTEX_COMMAND, 'queryModel');
         port.pipe(parser);
         await writeToPort('AT+CGMM\r');
     });
 };
 async function sendCtrlZ() {
     await writeToPort(CTRLZ);
 }
 exports.sendCtrlZ = sendCtrlZ;
 async function initATCommands() {
     await mutex.lock(MUTEX_COMMAND, 'INIT MODEM');
     await this.writeToPortAndWaitForOkOrError(`${CTRLZ}ATE0\r`, MUTEX_SUBCOMMAND);
     await this.writeToPortAndWaitForOkOrError('AT+CMGF=0\r', MUTEX_SUBCOMMAND);
     await this.writeToPortAndWaitForOkOrError('AT+CNMI=1,2,0,1,0\r', MUTEX_SUBCOMMAND);
     mutex.unlock(MUTEX_COMMAND, 'INIT MODEM');
 }
 exports.initATCommands = initATCommands;
 function sendCMGSPdu(pduLength) {
     return new Promise((resolve) => {
         const parser = new ParserReady({ delimiter: '>' });
         parser.on('data', () => {
             logger.verbose('Got ">" message prompt, gonna to write PDU message');
             port.unpipe(parser);
             mutex.unlock(MUTEX_SUBCOMMAND, 'sendSmsPduCommand');
             resolve(true);
         });
         mutex.lock(MUTEX_SUBCOMMAND, 'sendSmsPduCommand');
         port.pipe(parser);
         writeToPort(`AT+CMGS=${pduLength}\r`);
     });
 }
 exports.sendSMS = function sendSMS(destination, msg) {
     return new Promise(async (resolve) => {
+        async function responseHandler(data) {
+            logger.verbose('SMS sent callback called', { data });
+        }
         await mutex.lock(MUTEX_COMMAND, 'sendSMS');
+        parsers.setSmsSentCallback(responseHandler);
         if (!destination || !destination.trim()) {
             resolve(false);
             return;
         }
         if (!msg || !msg.trim()) {
             resolve(false);
             return;
         }
         const correctedDestination = `+${destination.replace(/^0/, '62')}`.replace(/^\++/, '+');
         logger.verbose(`Sending sms to ${correctedDestination}`, { msg });
         await this.writeToPortAndWaitForOkOrError('AT+CMGF=0\r', MUTEX_SUBCOMMAND);
         const submit = pdu.Submit();
         submit.setAddress(correctedDestination);
         submit.setData(msg.trim());
         submit.getType().setSrr(0);
         await sendCMGSPdu(Math.floor(submit.toString().length / 2) - 1);
-        await writeToPort(`${submit.toString()}${CTRLZ}`);
+        await writeToPortAndWaitForOkOrError(`${submit.toString()}${CTRLZ}`, MUTEX_SUBCOMMAND);
         mutex.unlock(MUTEX_COMMAND, 'sendSMS');
         resolve(true);
     });
 };
 exports.executeUSSD = function executeUSSD(code, _includeCUSD2, _sessionId) {
     return new Promise(async (resolve) => {
         const includeCUSD2 = _includeCUSD2 || 0;
         const sessionId = _sessionId || uuidv1();
         async function responseHandler(data) {
             logger.verbose('Processing USSD response', { data });
             parsers.setUssdCallback(null);
             if (includeCUSD2 === 1 || includeCUSD2 === 2) {
                 await writeToPortAndWaitForOkOrError('AT+CUSD=2\r', MUTEX_SUBCOMMAND);
             }
             mutex.unlock(MUTEX_COMMAND, `executeUSSD ${sessionId}`);
             resolve(data);
         }
         mutex.lock(MUTEX_COMMAND, `executeUSSD ${sessionId}`);
         parsers.setUssdCallback(responseHandler);
         await this.writeToPortAndWaitForOkOrError(`${CTRLZ}AT+CMGF=0\r`, MUTEX_SUBCOMMAND);
         if (includeCUSD2 === -1 || includeCUSD2 === 2) {
             await this.writeToPortAndWaitForOkOrError('AT+CUSD=2\r', MUTEX_SUBCOMMAND);
         }
         await writeToPort(`AT+CUSD=1,"${code}",15\r`, MUTEX_SUBCOMMAND);
     });
 };

lib/serialport-parsers.js

Diff comments View file @ 1d6334a

 const PARSER_READLINE_DELIMITER = '\r\n';
 const PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = /\n(?:OK|ERROR)\r\n/;
 const moment = require('moment');
 const nodePdu = require('node-pdu');
 // const pdu = require('pdu');
 const ParserReadline = require('@serialport/parser-readline');
 const ParserRegex = require('@serialport/parser-regex');
 const logger = require('komodo-sdk/logger');
 const dbCops = require('./db-cops');
 const modemInfo = require('./modem-info');
 let port;
 exports.setPort = function setPort(val) {
     logger.info('SERIALPORT-PARSERS: setting port');
     port = val;
 };
 exports.getPort = function getPort() {
     return port;
 };
 let ussdCallback = null;
 function setUssdCallback(cb) {
     ussdCallback = cb;
 }
 exports.setUssdCallback = setUssdCallback;
+let smsSentCallback = null;
+function setSmsSentCallback(cb) {
+    smsSentCallback = cb;
+}
+exports.setSmsSentCallback = setSmsSentCallback;
 function isAlphaNumeric(str) {
     const len = str.length;
     // eslint-disable-next-line no-plusplus
     for (let i = 0; i < len; i++) {
         const code = str.charCodeAt(i);
         if (!(code > 47 && code < 58) // numeric (0-9)
             && !(code > 64 && code < 91) // upper alpha (A-Z)
             && !(code > 96 && code < 123)) { // lower alpha (a-z)
             return false;
         }
     }
     return true;
 }
 function parsePdu(_data) {
     const data = _data && _data.toString().trim().toUpperCase();
     if (!data) return null;
     if (!isAlphaNumeric(data)) return null;
     try {
         const result = nodePdu.parse(data);
         return result;
     } catch (e) {
         return null;
     }
 }
 function onCSQ(data) {
     const val = data.toString().trim().match(/\+CSQ:\s*(.*)/);
     if (!val || !val[1]) return null;
     const [, signalStrength] = val;
     logger.info('Signal quality extracted', { signalQuality: val[1] });
     modemInfo.signalStrength = signalStrength;
     modemInfo.signalStrengthTs = new Date();
     modemInfo.signalStrengthTsReadable = moment(modemInfo.signalStrengthTs).format('YYYY-MM-DD HH:mm:ss');
     return signalStrength;
 }
 function onPduDeliver(data, parsedData) {
     const from = parsedData.getAddress && parsedData.getAddress().getPhone
         ? parsedData.getAddress().getPhone() : null;
     const msg = parsedData.getData && parsedData.getData().getData
         ? parsedData.getData().getData() : null;
     const ts = new Date(parsedData.getScts().getIsoString());
     logger.verbose('PDU processed', { ts, from, msg });
     return { from, msg };
 }
 function onCOPS(data) {
     const val = data.toString().trim().match(/\+COPS:\s*(.*)/);
     if (!val || !val[1]) return null;
     const cops = val[1];
     if (!cops) return null;
     const [mode, format, networkId] = cops.split(',');
     const networkName = networkId ? dbCops[networkId] || networkId : null;
     logger.info('COPS extracted', {
         cops, mode, format, networkId, networkName,
     });
     modemInfo.cops = cops;
     modemInfo.networkId = networkId || null;
     modemInfo.networkName = networkName || null;
     return {
         cops, mode, format, networkId, networkName,
     };
 }
 function isResultCodeIs(data, resultCode) {
     if (!data) return false;
     const cleanedData = (data.toString() || '').trim();
     if (!cleanedData) return false;
     if (resultCode.indexOf('+') !== 0) {
         // eslint-disable-next-line no-param-reassign
         resultCode = `+${resultCode}`;
     }
     if (resultCode.search(/:$/) < 0) {
         // eslint-disable-next-line no-param-reassign
         resultCode += ':';
     }
     return cleanedData.indexOf(resultCode) === 0;
 }
 const parserReadline = new ParserReadline({ delimiter: PARSER_READLINE_DELIMITER });
 parserReadline.on('data', (data) => {
     modemInfo.lastReadTs = new Date();
     logger.verbose('INCOMING', { data: `${data.toString()}${PARSER_READLINE_DELIMITER}`, parser: 'parserReadLine' });
     if (!data) return;
     const pduParsed = parsePdu(data);
     if (pduParsed && pduParsed.constructor.name !== 'Deliver') {
         const pduType = pduParsed.getType();
         logger.warn('WARN-9DA32C41: Unknown PDU message type name. PLEASE REPORT IT TO DEVELOPER AT TEKTRANS', { typeName: pduParsed.constructor.name, pduType, data: data.toString().trim() });
     }
     if (pduParsed && pduParsed.constructor.name === 'Deliver' && pduParsed.getData().getSize()) {
         const pduType = pduParsed.getType();
         logger.verbose('Got a PDU SMS-DELIVER', { pduType });
         onPduDeliver(data, pduParsed);
     } else if (isResultCodeIs(data, 'CSQ')) {
         logger.verbose('Got a signal quality report', { data: data.toString() });
         onCSQ(data);
     } else if (isResultCodeIs(data, 'COPS:')) {
         logger.verbose('Got a COPS report', { data: data.toString() });
         onCOPS(data);
     } else if (isResultCodeIs(data, 'CMT')) {
         logger.verbose('Got a new message report', { data: data.toString() });
     } else if (isResultCodeIs(data, 'CMTI')) {
         logger.verbose('Got a new message notification report', { data: data.toString() });
     } else if (isResultCodeIs(data, 'CUSD')) {
         logger.verbose('Got a USSD command response', { data: data.toString() });
-        if (ussdCallback && typeof ussdCallback === 'function') {
+        if (typeof ussdCallback === 'function') {
             logger.verbose('Calling USSD callback');
             ussdCallback(data.toString());
         } else {
             logger.verbose('Skip unwanted USSD response');
         }
+    } else if (isResultCodeIs(data, 'CMGS')) {
+        logger.verbose('Got CMGS report', { data: data.toString() });
+        if (typeof smsSentCallback === 'function') smsSentCallback(data.toString());
     }
 });
 const parserWaitForOkOrError = new ParserRegex({ regex: PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
 parserWaitForOkOrError.on('data', (data) => {
     logger.verbose('INCOMING', { data: data.toString(), parser: 'parserWaitForOkOrError' });
 });
 exports.PARSER_READLINE_DELIMITER = PARSER_READLINE_DELIMITER;
 exports.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = PARSER_WAIT_FOR_OK_OR_ERROR_REGEX;
 exports.parserReadline = parserReadline;
 exports.parserWaitForOkOrError = parserWaitForOkOrError;

modem-tester.js

Diff comments View file @ 1d6334a

 const SerialPort = require('serialport');
 const config = require('komodo-sdk/config');
 const logger = require('komodo-sdk/logger');
 const ParserInterByteTimeout = require('@serialport/parser-inter-byte-timeout');
 const parsers = require('./lib/serialport-parsers');
 const modemCommands = require('./lib/modem-commands');
 const modemInfo = require('./lib/modem-info');
 const parserInterByteTimeout = new ParserInterByteTimeout({ interval: 1000 });
 parserInterByteTimeout.on('data', (data) => {
     logger.verbose('INCOMING', { parser: 'parserInterByteTimeout', data: data.toString() });
 });
 const port = new SerialPort(config.modem.device, { baudRate: 115200 }, async (err) => {
     if (err) {
         logger.warn(`Error opening modem. ${err}. Terminating modem ${config.modem.device}.`);
         process.exit(1);
     }
     await modemCommands.sendCtrlZ();
     // await modemCommands.writeToPortAndWaitForOkOrError('\rAT\r');
     await modemCommands.writeToPortAndWaitForOkOrError('AT&FE0\r');
     await modemCommands.writeToPortAndWaitForOkOrError('AT+CMGF=0\r');
     await modemCommands.writeToPortAndWaitForOkOrError('AT+CNMI=1,2,0,1,0\r');
     await modemCommands.queryManufacturer();
     await modemCommands.queryModel();
     await modemCommands.queryIMEIAndIMSI();
     await modemCommands.queryCOPSAndSignalQuality();
     logger.info('Modem state', modemInfo);
     // await modemCommands.sendSMS('628128364883', `coba pakai pdu ${new Date()}`);
     // await modemCommands.sendSMS('+6282210008543', `coba pakai pdu ${new Date()}`);
     // await modemCommands.sendSMS('6281809903333', `coba pakai pdu ${new Date()}`);
+    await modemCommands.sendSMS('999', `coba pakai pdu ${new Date()}`);
     // const ussdResponse = await modemCommands.executeUSSD('*888#', 2);
     // logger.info('USSD RESPONSE', { ussdResponse });
     setInterval(async () => {
         await modemCommands.initATCommands();
         await modemCommands.queryManufacturer();
         await modemCommands.queryModel();
         await modemCommands.queryIMEIAndIMSI();
         await modemCommands.queryCOPSAndSignalQuality();
         logger.info('Modem state', modemInfo);
     }, config.interval_beetwen_signal_strength_ms || 30000);
 });
 global.MODEM_PORT = port;
 parsers.setPort(port);
 modemCommands.setPort(port);
 if (config && config.modem_tester && config.modem_tester.parser === 'regex') {
     logger.info('Using parserWaitForOkOrError');
     port.pipe(parsers.parserWaitForOkOrError);
 } else if (config && config.modem_tester && config.modem_tester.parser === 'interbyte') {
     logger.info('Using parserInterByteTimeout');
     port.pipe(parserInterByteTimeout);
 } else {
     logger.info('Using parserReadline');
     port.pipe(parsers.parserReadline);
 }