2154 lines
58 KiB
JavaScript
2154 lines
58 KiB
JavaScript
import { SerialPort } from 'serialport';
|
|
import { ReadlineParser } from '@serialport/parser-readline';
|
|
import { Submit } from 'node-pdu';
|
|
import EventEmitter from 'events';
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
import logger from './logger.js';
|
|
|
|
class ModemManager extends EventEmitter {
|
|
constructor(config, mobileDataConfig = {}, appConfig = {}) {
|
|
super();
|
|
this.config = config;
|
|
this.appConfig = appConfig;
|
|
this.mobileDataConfig = {
|
|
cid: this.normalizeMobileDataCid(mobileDataConfig.cid)
|
|
};
|
|
this.smsSending = false;
|
|
this.port = null;
|
|
this.parser = null;
|
|
this.atCommandQueue = Promise.resolve();
|
|
this.ready = false;
|
|
this.modelInfo = {
|
|
manufacturer: '未知',
|
|
model: '未知',
|
|
version: '未知'
|
|
};
|
|
this.sim = {
|
|
supported: false,
|
|
canSwitch: false,
|
|
mode: null,
|
|
modeLabel: '未知',
|
|
activeSlot: null,
|
|
switchSlot: null,
|
|
bindSlot: null,
|
|
switching: false,
|
|
slots: this.createSimSlots(),
|
|
lastCheckedAt: null,
|
|
error: '',
|
|
notice: '直出模式下按模组URC接收短信；URC未携带卡槽时显示未知SIM。'
|
|
};
|
|
this.mobileData = {
|
|
cid: this.mobileDataConfig.cid,
|
|
desiredEnabled: false,
|
|
enabled: false,
|
|
targetEnabled: false,
|
|
anyActive: false,
|
|
status: 'disabled',
|
|
mode: 'unknown',
|
|
contexts: [],
|
|
lastCheckedAt: null,
|
|
error: ''
|
|
};
|
|
}
|
|
|
|
createSimSlots() {
|
|
return [0, 1].map(slot => this.createSimSlot(slot));
|
|
}
|
|
|
|
createSimSlot(slot) {
|
|
const phoneNumber = this.getConfiguredSimPhoneNumber(slot);
|
|
|
|
return {
|
|
slot,
|
|
name: `SIM${slot + 1}`,
|
|
active: false,
|
|
phoneNumber,
|
|
phoneLabel: phoneNumber || `SIM${slot + 1}`,
|
|
lastCheckedAt: null
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 打开串口并初始化模组
|
|
*/
|
|
async open() {
|
|
try {
|
|
const portPath = await this.resolvePortPath();
|
|
|
|
logger.info(`准备打开串口: ${portPath} (${this.config.baudRate})`);
|
|
|
|
// 打开串口
|
|
this.port = new SerialPort({
|
|
path: portPath,
|
|
baudRate: this.config.baudRate,
|
|
dataBits: 8,
|
|
stopBits: 1,
|
|
parity: 'none',
|
|
autoOpen: false
|
|
});
|
|
|
|
// 设置行解析器
|
|
this.parser = this.port.pipe(new ReadlineParser({ delimiter: '\r\n' }));
|
|
|
|
// 监听串口事件
|
|
this.port.on('error', (err) => {
|
|
logger.error('串口错误:', err);
|
|
this.emit('error', err);
|
|
});
|
|
|
|
this.port.on('close', () => {
|
|
logger.warn('串口已关闭');
|
|
this.ready = false;
|
|
this.emit('close');
|
|
});
|
|
|
|
// 监听URC（主动上报）消息
|
|
this.setupURCListener();
|
|
|
|
// 等待串口打开
|
|
await new Promise((resolve, reject) => {
|
|
this.port.open((err) => {
|
|
if (err) {
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
resolve();
|
|
});
|
|
});
|
|
this.config.path = portPath;
|
|
logger.info(`串口已打开: ${portPath}`);
|
|
|
|
// 初始化模组
|
|
await this.init();
|
|
|
|
} catch (err) {
|
|
logger.error('打开串口失败:', err);
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 自动探测能响应AT命令的串口；可通过 serial.autoDetect=false 关闭。
|
|
*/
|
|
async resolvePortPath() {
|
|
const manualPath = this.normalizePortPath(this.config.path);
|
|
|
|
if (this.config.autoDetect === false) {
|
|
return manualPath;
|
|
}
|
|
|
|
const candidates = await this.getSerialProbeCandidates(manualPath);
|
|
if (candidates.length === 0) {
|
|
throw new Error('未发现可探测的串口设备');
|
|
}
|
|
|
|
logger.info(`开始自动探测AT串口: ${this.formatProbeCandidateList(candidates)}`);
|
|
|
|
const timeout = this.config.probeTimeout || 1200;
|
|
const failures = [];
|
|
|
|
for (const candidate of candidates) {
|
|
const result = await this.probeATPort(candidate.path, timeout);
|
|
if (result.ok) {
|
|
logger.info(`✓ 自动探测到AT串口: ${candidate.path}`);
|
|
return candidate.path;
|
|
}
|
|
|
|
failures.push(result);
|
|
logger.debug(`串口探测未通过: ${candidate.path} (${this.formatProbeFailure(result)})`);
|
|
}
|
|
|
|
const summary = failures
|
|
.slice(0, 8)
|
|
.map(item => `${item.path}: ${this.formatProbeFailure(item)}`)
|
|
.join('; ');
|
|
|
|
throw new Error(`未找到可响应AT的串口，已探测 ${failures.length} 个端口${summary ? ` (${summary})` : ''}`);
|
|
}
|
|
|
|
normalizePortPath(portPath) {
|
|
if (!portPath) {
|
|
return null;
|
|
}
|
|
|
|
const normalized = String(portPath).trim();
|
|
if (process.platform === 'win32' && /^\d+$/.test(normalized)) {
|
|
return `COM${normalized}`;
|
|
}
|
|
|
|
return normalized;
|
|
}
|
|
|
|
async getSerialProbeCandidates(manualPath) {
|
|
const candidates = new Map();
|
|
|
|
const addCandidate = (path, portInfo = {}, manual = false) => {
|
|
if (!path) {
|
|
return;
|
|
}
|
|
|
|
const candidate = candidates.get(path) || {
|
|
path,
|
|
portInfo: {},
|
|
manual: false
|
|
};
|
|
|
|
candidate.portInfo = { ...candidate.portInfo, ...portInfo };
|
|
candidate.manual = candidate.manual || manual;
|
|
candidate.metadata = this.getPortMetadata(path, candidate.portInfo);
|
|
candidate.priority = this.getProbeCandidatePriority(path, candidate.portInfo, candidate.manual, candidate.metadata);
|
|
candidates.set(path, candidate);
|
|
};
|
|
|
|
let ports = [];
|
|
try {
|
|
ports = await SerialPort.list();
|
|
} catch (err) {
|
|
logger.warn(`读取系统串口列表失败: ${err.message}`);
|
|
}
|
|
|
|
for (const portInfo of ports) {
|
|
addCandidate(this.normalizePortPath(portInfo.path), portInfo);
|
|
}
|
|
|
|
addCandidate(manualPath, {}, true);
|
|
|
|
return Array.from(candidates.values())
|
|
.sort((a, b) => a.priority - b.priority || a.path.localeCompare(b.path));
|
|
}
|
|
|
|
getProbeCandidatePriority(portPath, portInfo, manual, metadata) {
|
|
const interfaceName = (metadata.interfaceName || '').toLowerCase();
|
|
const interfaceNumber = metadata.interfaceNumber;
|
|
|
|
if (interfaceName.includes('at interface') || /\bat\b/.test(interfaceName)) {
|
|
return interfaceNumber === null ? 0 : interfaceNumber;
|
|
}
|
|
|
|
if (portInfo.vendorId === '2ecc' && portInfo.productId === '3012') {
|
|
// ML307A: if02/if03 are AT interfaces; if04 is Diag; if00/if01 are RNDIS.
|
|
if (interfaceNumber === 2 || interfaceNumber === 3) {
|
|
return interfaceNumber;
|
|
}
|
|
|
|
return 40 + (interfaceNumber ?? 9);
|
|
}
|
|
|
|
if (interfaceName.includes('diag')) {
|
|
return 40;
|
|
}
|
|
|
|
if (interfaceName.includes('rndis') || interfaceName.includes('network')) {
|
|
return 50;
|
|
}
|
|
|
|
if (portInfo.vendorId || portInfo.productId || /usb|acm/i.test(portPath)) {
|
|
return 20;
|
|
}
|
|
|
|
if (/^COM\d+$/i.test(portPath)) {
|
|
return 30;
|
|
}
|
|
|
|
if (manual) {
|
|
return 35;
|
|
}
|
|
|
|
return 80;
|
|
}
|
|
|
|
getPortMetadata(portPath, portInfo) {
|
|
const metadata = {
|
|
interfaceName: '',
|
|
interfaceNumber: this.parseUSBInterfaceNumber(portInfo.pnpId)
|
|
};
|
|
|
|
if (process.platform !== 'linux') {
|
|
return metadata;
|
|
}
|
|
|
|
const ttyName = this.getTTYName(portPath);
|
|
if (!ttyName) {
|
|
return metadata;
|
|
}
|
|
|
|
try {
|
|
const ttyDevicePath = fs.realpathSync(`/sys/class/tty/${ttyName}/device`);
|
|
const usbInterfacePath = path.dirname(ttyDevicePath);
|
|
metadata.interfaceName = this.readFirstLine(path.join(usbInterfacePath, 'interface')) || '';
|
|
|
|
const sysfsInterfaceNumber = this.readFirstLine(path.join(usbInterfacePath, 'bInterfaceNumber'));
|
|
if (sysfsInterfaceNumber) {
|
|
metadata.interfaceNumber = Number.parseInt(sysfsInterfaceNumber, 16);
|
|
}
|
|
} catch (err) {
|
|
// Some platforms expose serial ports without Linux USB sysfs metadata.
|
|
}
|
|
|
|
return metadata;
|
|
}
|
|
|
|
parseUSBInterfaceNumber(pnpId) {
|
|
const match = String(pnpId || '').match(/if(\d+)/i);
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
|
|
return Number.parseInt(match[1], 10);
|
|
}
|
|
|
|
getTTYName(portPath) {
|
|
try {
|
|
return path.basename(fs.realpathSync(portPath));
|
|
} catch (err) {
|
|
return path.basename(portPath);
|
|
}
|
|
}
|
|
|
|
readFirstLine(filePath) {
|
|
try {
|
|
return fs.readFileSync(filePath, 'utf8').split('\n')[0].trim();
|
|
} catch (err) {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
formatProbeCandidateList(candidates) {
|
|
const paths = candidates.map(item => item.path);
|
|
if (paths.length <= 12) {
|
|
return paths.join(', ');
|
|
}
|
|
|
|
return `${paths.slice(0, 12).join(', ')} ... 共${paths.length}个`;
|
|
}
|
|
|
|
async probeATPort(path, timeout = 1200) {
|
|
return new Promise((resolve) => {
|
|
let buffer = '';
|
|
let settled = false;
|
|
|
|
const port = new SerialPort({
|
|
path,
|
|
baudRate: this.config.baudRate,
|
|
dataBits: 8,
|
|
stopBits: 1,
|
|
parity: 'none',
|
|
autoOpen: false
|
|
});
|
|
|
|
const done = (result) => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
|
|
settled = true;
|
|
clearTimeout(timer);
|
|
port.removeListener('data', onData);
|
|
port.removeListener('error', onError);
|
|
|
|
const finalResult = {
|
|
path,
|
|
...result,
|
|
response: buffer
|
|
};
|
|
|
|
if (port.isOpen) {
|
|
port.close(() => resolve(finalResult));
|
|
return;
|
|
}
|
|
|
|
resolve(finalResult);
|
|
};
|
|
|
|
const onData = (data) => {
|
|
buffer += data.toString('utf8');
|
|
if (buffer.includes('OK')) {
|
|
done({ ok: true, reason: 'ok' });
|
|
} else if (buffer.includes('ERROR')) {
|
|
done({ ok: false, reason: 'error_response' });
|
|
}
|
|
};
|
|
|
|
const onError = (err) => {
|
|
done({ ok: false, reason: 'error', error: err.message });
|
|
};
|
|
|
|
const timer = setTimeout(() => {
|
|
done({ ok: false, reason: 'timeout' });
|
|
}, timeout);
|
|
|
|
port.on('data', onData);
|
|
port.on('error', onError);
|
|
|
|
port.open((err) => {
|
|
if (err) {
|
|
done({ ok: false, reason: 'open_error', error: err.message });
|
|
return;
|
|
}
|
|
|
|
port.write('AT\r\n', (writeErr) => {
|
|
if (writeErr) {
|
|
done({ ok: false, reason: 'write_error', error: writeErr.message });
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
formatProbeFailure(result) {
|
|
if (result.error) {
|
|
return `${result.reason}: ${result.error}`;
|
|
}
|
|
|
|
return result.reason;
|
|
}
|
|
|
|
normalizeMobileDataCid(value) {
|
|
const cid = Number.parseInt(value, 10);
|
|
if (Number.isInteger(cid) && cid > 0 && cid <= 15 && cid !== 8) {
|
|
return cid;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
getConfiguredSimPhoneNumber(slotNumber) {
|
|
const slot = this.normalizeSimSlot(slotNumber);
|
|
if (slot === null) {
|
|
return '';
|
|
}
|
|
|
|
const sources = [
|
|
this.appConfig?.simCards,
|
|
this.appConfig?.simSlots,
|
|
this.appConfig?.sims,
|
|
this.appConfig?.sim
|
|
];
|
|
|
|
for (const source of sources) {
|
|
const phoneNumber = this.extractConfiguredSimPhoneNumber(source, slot);
|
|
if (phoneNumber) {
|
|
return phoneNumber;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
extractConfiguredSimPhoneNumber(source, slot) {
|
|
if (!source) {
|
|
return '';
|
|
}
|
|
|
|
let candidate = null;
|
|
if (Array.isArray(source)) {
|
|
candidate = source.find(item => this.normalizeSimSlot(item?.slot ?? item?.simSlot ?? item?.sim) === slot) ||
|
|
source[slot];
|
|
} else if (typeof source === 'object') {
|
|
candidate = source[slot] ?? source[String(slot)] ?? source[`sim${slot + 1}`] ?? source[`SIM${slot + 1}`];
|
|
}
|
|
|
|
if (typeof candidate === 'string' || typeof candidate === 'number') {
|
|
return this.normalizePhoneNumber(candidate);
|
|
}
|
|
|
|
if (candidate && typeof candidate === 'object') {
|
|
return this.normalizePhoneNumber(candidate.phoneNumber ?? candidate.phone ?? candidate.msisdn ?? candidate.number);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
normalizePhoneNumber(value) {
|
|
const text = String(value || '').trim();
|
|
if (!text) {
|
|
return '';
|
|
}
|
|
|
|
const normalized = text.replace(/[^\d+]/g, '');
|
|
return normalized.length >= 3 ? normalized : '';
|
|
}
|
|
|
|
normalizeSimSlot(value) {
|
|
if (typeof value === 'string') {
|
|
const normalized = value.trim().toUpperCase();
|
|
if (normalized === 'SIM1') {
|
|
return 0;
|
|
}
|
|
if (normalized === 'SIM2') {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
const slot = Number.parseInt(value, 10);
|
|
return slot === 0 || slot === 1 ? slot : null;
|
|
}
|
|
|
|
getCachedSimStatus() {
|
|
return {
|
|
...this.sim,
|
|
slots: this.sim.slots.map(slot => ({ ...slot }))
|
|
};
|
|
}
|
|
|
|
isSimSwitching() {
|
|
return Boolean(this.sim.switching);
|
|
}
|
|
|
|
formatDualSimMode(mode) {
|
|
if (mode === 0) {
|
|
return '双卡双待';
|
|
}
|
|
if (mode === 1) {
|
|
return '双卡单待';
|
|
}
|
|
if (mode === 3) {
|
|
return '双卡双待(FP)';
|
|
}
|
|
return '未知';
|
|
}
|
|
|
|
parseDualSimMode(resp) {
|
|
const match = String(resp || '').match(/\+DUALSIM:\s*(\d+)/);
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
|
|
const mode = Number.parseInt(match[1], 10);
|
|
return Number.isInteger(mode) ? mode : null;
|
|
}
|
|
|
|
parseSimSlotResponse(resp, prefix) {
|
|
const pattern = new RegExp(`\\+${prefix}:\\s*(\\d+)`, 'i');
|
|
const match = String(resp || '').match(pattern);
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
|
|
return this.normalizeSimSlot(match[1]);
|
|
}
|
|
|
|
markActiveSimSlot(status, activeSlot) {
|
|
status.activeSlot = activeSlot;
|
|
status.slots = status.slots.map(slot => ({
|
|
...slot,
|
|
active: slot.slot === activeSlot
|
|
}));
|
|
}
|
|
|
|
getBusinessSimSlot(status = this.sim) {
|
|
return this.normalizeSimSlot(status.bindSlot) ?? this.normalizeSimSlot(status.switchSlot);
|
|
}
|
|
|
|
getSimSlotLabel(slotNumber) {
|
|
const slot = this.normalizeSimSlot(slotNumber);
|
|
if (slot === null) {
|
|
return '未知SIM';
|
|
}
|
|
|
|
const slotInfo = this.sim.slots.find(item => item.slot === slot);
|
|
return slotInfo?.phoneLabel || slotInfo?.phoneNumber || `SIM${slot + 1}`;
|
|
}
|
|
|
|
updateSimSlotPhoneNumber(status, slotNumber, phoneNumber) {
|
|
const slot = this.normalizeSimSlot(slotNumber);
|
|
if (slot === null) {
|
|
return;
|
|
}
|
|
|
|
const normalized = this.normalizePhoneNumber(phoneNumber);
|
|
if (!normalized) {
|
|
return;
|
|
}
|
|
|
|
status.slots = status.slots.map(item => {
|
|
if (item.slot !== slot) {
|
|
return item;
|
|
}
|
|
|
|
return {
|
|
...item,
|
|
phoneNumber: normalized,
|
|
phoneLabel: normalized,
|
|
lastCheckedAt: new Date().toISOString()
|
|
};
|
|
});
|
|
}
|
|
|
|
parseOwnNumberResponse(resp) {
|
|
const lines = String(resp || '')
|
|
.split('\n')
|
|
.map(line => line.trim())
|
|
.filter(Boolean);
|
|
|
|
for (const line of lines) {
|
|
if (/^AT/i.test(line) || line === 'OK' || line === 'ERROR') {
|
|
continue;
|
|
}
|
|
|
|
const match = line.match(/^\+CNUM:\s*(?:"[^"]*")?\s*,\s*"?([^",\s]*)"?/i);
|
|
if (match) {
|
|
return this.normalizePhoneNumber(match[1]);
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
async queryOwnPhoneNumber() {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+CNUM', 2000);
|
|
return this.parseOwnNumberResponse(resp);
|
|
} catch (err) {
|
|
logger.debug(`查询当前SIM手机号失败: ${err.message}`);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
async readCurrentSimSlotPhoneNumber(slotNumber, context = '当前') {
|
|
const slot = this.normalizeSimSlot(slotNumber);
|
|
if (slot === null) {
|
|
return false;
|
|
}
|
|
|
|
const phoneNumber = await this.queryOwnPhoneNumber();
|
|
if (!phoneNumber) {
|
|
logger.debug(`${context}SIM${slot + 1}未读取到手机号`);
|
|
return false;
|
|
}
|
|
|
|
this.updateSimSlotPhoneNumber(this.sim, slot, phoneNumber);
|
|
logger.info(`✓ ${context}SIM${slot + 1}手机号: ${phoneNumber}`);
|
|
return true;
|
|
}
|
|
|
|
async switchSimForIdentityRead(slotNumber, options = {}) {
|
|
const targetSlot = this.normalizeSimSlot(slotNumber);
|
|
if (targetSlot === null) {
|
|
throw new Error('SIM卡槽参数无效，只支持 SIM1 或 SIM2');
|
|
}
|
|
|
|
const {
|
|
context = '启动探测',
|
|
purpose = '',
|
|
retries = 2,
|
|
retryDelay = 2000,
|
|
settleDelay = 3000,
|
|
confirmTimeout = 15000,
|
|
confirmInterval = 1000
|
|
} = options;
|
|
|
|
const currentSlot = await this.querySwitchSimSlot().catch(() => this.sim.switchSlot);
|
|
this.sim.switchSlot = currentSlot;
|
|
|
|
if (currentSlot === targetSlot) {
|
|
await this.waitSIMReady();
|
|
return targetSlot;
|
|
}
|
|
|
|
logger.info(`${context}: 切到SIM${targetSlot + 1}${purpose ? purpose : ''}`);
|
|
let switched = false;
|
|
|
|
for (let attempt = 1; attempt <= retries && !switched; attempt++) {
|
|
try {
|
|
const resp = await this.sendATCommand(`AT+SWITCHSIM=${targetSlot}`, 10000);
|
|
if (!resp.includes('OK')) {
|
|
logger.warn(`${context}切到SIM${targetSlot + 1}返回非OK(${attempt}/${retries}): ${this.formatATResponse(resp)}`);
|
|
}
|
|
} catch (err) {
|
|
logger.warn(`${context}切到SIM${targetSlot + 1}命令失败(${attempt}/${retries}): ${err.message}`);
|
|
}
|
|
|
|
switched = await this.waitForSwitchSimSlot(targetSlot, confirmTimeout, confirmInterval);
|
|
if (!switched && attempt < retries && retryDelay > 0) {
|
|
await this.sleep(retryDelay);
|
|
}
|
|
}
|
|
|
|
if (!switched) {
|
|
throw new Error(`${context}切到SIM${targetSlot + 1}失败`);
|
|
}
|
|
|
|
this.sim.switchSlot = targetSlot;
|
|
this.markActiveSimSlot(this.sim, this.getBusinessSimSlot(this.sim) ?? targetSlot);
|
|
await this.sleep(settleDelay);
|
|
await this.waitSIMReady();
|
|
|
|
return targetSlot;
|
|
}
|
|
|
|
async waitForSwitchSimSlot(targetSlot, timeout = 15000, interval = 1000) {
|
|
const startedAt = Date.now();
|
|
|
|
while (Date.now() - startedAt <= timeout) {
|
|
try {
|
|
const currentSlot = await this.querySwitchSimSlot();
|
|
this.sim.switchSlot = currentSlot;
|
|
if (currentSlot === targetSlot) {
|
|
return true;
|
|
}
|
|
} catch (err) {
|
|
logger.debug(`等待SWITCHSIM生效失败: ${err.message}`);
|
|
}
|
|
|
|
await this.sleep(interval);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
async ensureATSimMatchesBinding(context = 'SIM同步') {
|
|
if (!this.sim.supported || !this.sim.canSwitch) {
|
|
return null;
|
|
}
|
|
|
|
const bindSlot = this.normalizeSimSlot(this.sim.bindSlot ?? await this.queryBindSimSlot());
|
|
if (bindSlot === null) {
|
|
return null;
|
|
}
|
|
|
|
const switchSlot = await this.querySwitchSimSlot();
|
|
this.sim.switchSlot = switchSlot;
|
|
this.markActiveSimSlot(this.sim, bindSlot);
|
|
|
|
if (switchSlot === bindSlot) {
|
|
return {
|
|
slot: bindSlot,
|
|
changed: false
|
|
};
|
|
}
|
|
|
|
const currentLabel = switchSlot === null ? '未知' : `SIM${switchSlot + 1}`;
|
|
logger.warn(`${context}: 业务绑定为SIM${bindSlot + 1}，但AT当前为${currentLabel}，准备同步AT卡槽`);
|
|
await this.switchSimForIdentityRead(bindSlot, {
|
|
context,
|
|
purpose: '用于短信发送',
|
|
retries: 4,
|
|
retryDelay: 3000,
|
|
settleDelay: 3000
|
|
});
|
|
|
|
return {
|
|
slot: bindSlot,
|
|
changed: true
|
|
};
|
|
}
|
|
|
|
async discoverSimSlotIdentities() {
|
|
const status = await this.refreshSimStatus({ refreshIdentity: false });
|
|
const currentSlot = this.normalizeSimSlot(status.switchSlot) ??
|
|
this.normalizeSimSlot(status.activeSlot) ??
|
|
0;
|
|
|
|
logger.info(`启动仅初始化当前SIM${currentSlot + 1}，不读取SMSC、不遍历其他卡槽`);
|
|
await this.waitSIMReady();
|
|
await this.readCurrentSimSlotPhoneNumber(currentSlot, '启动当前');
|
|
this.sim.lastCheckedAt = new Date().toISOString();
|
|
|
|
return this.getCachedSimStatus();
|
|
}
|
|
|
|
identifyIncomingSms(metadata = {}) {
|
|
const urcSlot = this.normalizeSimSlot(metadata.simSlot);
|
|
if (urcSlot !== null) {
|
|
return {
|
|
slot: urcSlot,
|
|
source: metadata.simSource || 'urc'
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
async queryDualSimMode() {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+DUALSIM?', 2000);
|
|
const mode = this.parseDualSimMode(resp);
|
|
if (mode === null) {
|
|
return {
|
|
supported: false,
|
|
mode: null,
|
|
modeLabel: '未检测到双卡能力',
|
|
error: this.formatATResponse(resp)
|
|
};
|
|
}
|
|
|
|
return {
|
|
supported: true,
|
|
mode,
|
|
modeLabel: this.formatDualSimMode(mode),
|
|
error: ''
|
|
};
|
|
} catch (err) {
|
|
return {
|
|
supported: false,
|
|
mode: null,
|
|
modeLabel: '未检测到双卡能力',
|
|
error: err.message
|
|
};
|
|
}
|
|
}
|
|
|
|
async querySwitchSimSlot() {
|
|
const resp = await this.sendATCommand('AT+SWITCHSIM?', 2000);
|
|
return this.parseSimSlotResponse(resp, 'SWITCHSIM');
|
|
}
|
|
|
|
async queryBindSimSlot() {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+BINDSIM?', 2000);
|
|
return this.parseSimSlotResponse(resp, 'BINDSIM');
|
|
} catch (err) {
|
|
logger.debug(`查询BINDSIM失败: ${err.message}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async getSimStatus(options = {}) {
|
|
return await this.refreshSimStatus(options);
|
|
}
|
|
|
|
async refreshSimStatus(options = {}) {
|
|
const refreshIdentity = options.refreshIdentity === true;
|
|
const status = {
|
|
...this.sim,
|
|
slots: this.sim.slots.map(slot => ({ ...slot })),
|
|
error: ''
|
|
};
|
|
|
|
try {
|
|
const dualSim = await this.queryDualSimMode();
|
|
status.supported = dualSim.supported;
|
|
status.canSwitch = false;
|
|
status.mode = dualSim.mode;
|
|
status.modeLabel = dualSim.modeLabel;
|
|
|
|
if (!dualSim.supported) {
|
|
status.activeSlot = null;
|
|
status.switchSlot = null;
|
|
status.bindSlot = null;
|
|
status.error = dualSim.error || '';
|
|
status.lastCheckedAt = new Date().toISOString();
|
|
this.sim = status;
|
|
return this.getCachedSimStatus();
|
|
}
|
|
|
|
const switchSlot = await this.querySwitchSimSlot();
|
|
if (switchSlot !== null) {
|
|
status.canSwitch = true;
|
|
status.switchSlot = switchSlot;
|
|
} else {
|
|
status.switchSlot = null;
|
|
status.error = '未能读取当前AT SIM卡槽';
|
|
}
|
|
|
|
status.bindSlot = await this.queryBindSimSlot();
|
|
this.markActiveSimSlot(status, this.getBusinessSimSlot(status));
|
|
|
|
if (refreshIdentity && switchSlot !== null) {
|
|
const phoneNumber = await this.queryOwnPhoneNumber();
|
|
this.updateSimSlotPhoneNumber(status, switchSlot, phoneNumber);
|
|
}
|
|
|
|
status.lastCheckedAt = new Date().toISOString();
|
|
this.sim = status;
|
|
return this.getCachedSimStatus();
|
|
} catch (err) {
|
|
logger.warn(`查询SIM状态失败: ${err.message}`);
|
|
status.error = err.message;
|
|
status.lastCheckedAt = new Date().toISOString();
|
|
this.sim = status;
|
|
return this.getCachedSimStatus();
|
|
}
|
|
}
|
|
|
|
async switchSim(slotNumber) {
|
|
const targetSlot = this.normalizeSimSlot(slotNumber);
|
|
if (targetSlot === null) {
|
|
throw new Error('SIM卡槽参数无效，只支持 SIM1 或 SIM2');
|
|
}
|
|
|
|
if (this.sim.switching) {
|
|
throw new Error('SIM正在切换中，请稍后再试');
|
|
}
|
|
|
|
const before = await this.refreshSimStatus({ refreshIdentity: false });
|
|
if (!before.supported || !before.canSwitch) {
|
|
logger.warn(`绑定SIM前状态不可用: supported=${before.supported}, canSwitch=${before.canSwitch}, bindSlot=${before.bindSlot ?? 'unknown'}, switchSlot=${before.switchSlot ?? 'unknown'}, error=${before.error || 'none'}`);
|
|
throw new Error(before.error || '当前模组未检测到双卡绑定能力');
|
|
}
|
|
|
|
if (this.normalizeSimSlot(before.bindSlot) === targetSlot && this.normalizeSimSlot(before.switchSlot) === targetSlot) {
|
|
logger.info(`当前已经绑定并切到SIM${targetSlot + 1}`);
|
|
return {
|
|
changed: false,
|
|
status: await this.refreshSimStatus({ refreshIdentity: false })
|
|
};
|
|
}
|
|
|
|
logger.info(`准备切到并绑定SIM${targetSlot + 1}`);
|
|
this.sim.switching = true;
|
|
|
|
try {
|
|
if (this.normalizeSimSlot(before.switchSlot) !== targetSlot) {
|
|
await this.switchSimForIdentityRead(targetSlot, {
|
|
context: `切换SIM${targetSlot + 1}`,
|
|
purpose: '用于业务绑定',
|
|
retries: 4,
|
|
retryDelay: 3000,
|
|
settleDelay: 3000
|
|
});
|
|
} else {
|
|
await this.waitSIMReady();
|
|
}
|
|
|
|
if (this.normalizeSimSlot(before.bindSlot) !== targetSlot) {
|
|
await this.sendATWithRetry(`AT+BINDSIM=${targetSlot}`, {
|
|
timeout: 5000,
|
|
retries: 2,
|
|
retryDelay: 1000,
|
|
label: `绑定到SIM${targetSlot + 1}`
|
|
});
|
|
}
|
|
|
|
this.sim.bindSlot = targetSlot;
|
|
this.markActiveSimSlot(this.sim, targetSlot);
|
|
await this.readCurrentSimSlotPhoneNumber(targetSlot, '切换后');
|
|
await this.configureSMS();
|
|
|
|
this.sim.switching = false;
|
|
const status = await this.refreshSimStatus({ refreshIdentity: false });
|
|
const activeSlot = this.normalizeSimSlot(status.activeSlot);
|
|
const switchSlot = this.normalizeSimSlot(status.switchSlot);
|
|
if (activeSlot !== targetSlot || switchSlot !== targetSlot) {
|
|
throw new Error(`切换SIM后状态不一致: activeSlot=${activeSlot ?? 'unknown'}, switchSlot=${switchSlot ?? 'unknown'}`);
|
|
}
|
|
|
|
logger.info(`✓ 已绑定并切到SIM${targetSlot + 1}`);
|
|
return {
|
|
changed: true,
|
|
status
|
|
};
|
|
} finally {
|
|
this.sim.switching = false;
|
|
}
|
|
}
|
|
|
|
getMobileDataMode() {
|
|
return this.isML307Family() ? 'mipcall' : 'cgact';
|
|
}
|
|
|
|
getMobileDataCommand(mode = this.getMobileDataMode(), enabled = false, cid = this.mobileDataConfig.cid) {
|
|
if (mode === 'mipcall') {
|
|
return `AT+MIPCALL=${enabled ? 1 : 0},${cid}`;
|
|
}
|
|
|
|
return `AT+CGACT=${enabled ? 1 : 0},${cid}`;
|
|
}
|
|
|
|
getMobileDataStatusCommand(mode = this.getMobileDataMode()) {
|
|
return mode === 'mipcall' ? 'AT+MIPCALL?' : 'AT+CGACT?';
|
|
}
|
|
|
|
getCachedMobileDataStatus() {
|
|
return {
|
|
...this.mobileData,
|
|
contexts: this.mobileData.contexts.map(item => ({ ...item }))
|
|
};
|
|
}
|
|
|
|
async getMobileDataStatus() {
|
|
const mode = this.getMobileDataMode();
|
|
const command = this.getMobileDataStatusCommand(mode);
|
|
|
|
try {
|
|
const resp = await this.sendATCommand(command, 5000);
|
|
const status = this.parseMobileDataStatusResponse(resp, mode);
|
|
this.updateMobileDataStatus(status);
|
|
return this.getCachedMobileDataStatus();
|
|
} catch (err) {
|
|
logger.warn(`查询移动数据状态失败: ${err.message}`);
|
|
this.updateMobileDataStatus({
|
|
mode,
|
|
cid: this.mobileDataConfig.cid,
|
|
status: 'unknown',
|
|
enabled: false,
|
|
targetEnabled: false,
|
|
anyActive: false,
|
|
contexts: [],
|
|
error: err.message
|
|
});
|
|
return this.getCachedMobileDataStatus();
|
|
}
|
|
}
|
|
|
|
parseMobileDataStatusResponse(resp, mode) {
|
|
const contexts = [];
|
|
const lines = resp.split('\n').map(line => line.trim()).filter(Boolean);
|
|
|
|
for (const line of lines) {
|
|
const payload = this.extractMobileDataPayload(line, mode);
|
|
if (!payload) {
|
|
continue;
|
|
}
|
|
|
|
const match = payload.match(/^(\d+)\s*,\s*(\d+)(.*)$/);
|
|
if (!match) {
|
|
continue;
|
|
}
|
|
|
|
const cid = Number.parseInt(match[1], 10);
|
|
const state = Number.parseInt(match[2], 10);
|
|
const addresses = [...match[3].matchAll(/"([^"]+)"/g)].map(item => item[1]).filter(Boolean);
|
|
|
|
contexts.push({
|
|
cid,
|
|
active: state === 1,
|
|
state,
|
|
addresses
|
|
});
|
|
}
|
|
|
|
const target = contexts.find(item => item.cid === this.mobileDataConfig.cid);
|
|
const anyActive = contexts.some(item => item.active);
|
|
const targetEnabled = target ? target.active : false;
|
|
|
|
return {
|
|
mode,
|
|
cid: this.mobileDataConfig.cid,
|
|
enabled: anyActive,
|
|
targetEnabled,
|
|
anyActive,
|
|
status: anyActive ? 'enabled' : 'disabled',
|
|
contexts,
|
|
error: ''
|
|
};
|
|
}
|
|
|
|
extractMobileDataPayload(line, mode) {
|
|
if (mode === 'mipcall') {
|
|
if (line.startsWith('+MIPCALL:')) {
|
|
return line.slice('+MIPCALL:'.length).trim();
|
|
}
|
|
|
|
if (/^\d+\s*,\s*\d+/.test(line)) {
|
|
return line;
|
|
}
|
|
}
|
|
|
|
if (line.startsWith('+CGACT:')) {
|
|
return line.slice('+CGACT:'.length).trim();
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
updateMobileDataStatus(status) {
|
|
this.mobileData = {
|
|
...this.mobileData,
|
|
...status,
|
|
cid: this.mobileDataConfig.cid,
|
|
lastCheckedAt: new Date().toISOString(),
|
|
contexts: Array.isArray(status.contexts) ? status.contexts : []
|
|
};
|
|
}
|
|
|
|
getMobileDataTargetCids(status) {
|
|
const cids = new Set([this.mobileDataConfig.cid]);
|
|
for (const context of status.contexts || []) {
|
|
if (context.active && context.cid !== 8) {
|
|
cids.add(context.cid);
|
|
}
|
|
}
|
|
|
|
return [...cids].filter(cid => this.normalizeMobileDataCid(cid) === cid);
|
|
}
|
|
|
|
async setMobileDataEnabled(enabled, options = {}) {
|
|
this.mobileData.desiredEnabled = Boolean(enabled);
|
|
if (enabled) {
|
|
return await this.enableMobileData(options);
|
|
}
|
|
|
|
return await this.disableMobileData(options);
|
|
}
|
|
|
|
async enableMobileData(options = {}) {
|
|
const mode = this.getMobileDataMode();
|
|
const cid = this.mobileDataConfig.cid;
|
|
const command = this.getMobileDataCommand(mode, true, cid);
|
|
const label = mode === 'mipcall' ? '开启移动数据拨号' : '激活PDP数据连接';
|
|
|
|
logger.warn(`准备开启移动数据(CID ${cid})，可能产生流量费用`);
|
|
const resp = await this.sendATWithRetry(command, {
|
|
timeout: 30000,
|
|
retries: 1,
|
|
label,
|
|
required: false
|
|
});
|
|
|
|
const status = await this.waitForMobileDataState(true, options.timeout || 20000);
|
|
if (!resp || !status.anyActive) {
|
|
throw new Error('移动数据开启失败，未检测到已激活的数据连接');
|
|
}
|
|
|
|
logger.info(`✓ 已开启移动数据(CID ${cid})`);
|
|
return status;
|
|
}
|
|
|
|
async disableMobileData(options = {}) {
|
|
const mode = this.getMobileDataMode();
|
|
if (mode === 'mipcall') {
|
|
return await this.disableMipcallMobileData(options);
|
|
}
|
|
|
|
return await this.disableCgactMobileData(options);
|
|
}
|
|
|
|
async disableMipcallMobileData(options = {}) {
|
|
const before = await this.getMobileDataStatus();
|
|
const cids = this.getMobileDataTargetCids(before);
|
|
|
|
logger.info(`${options.reason || '手动操作'}: 断开ML307应用层拨号连接，避免流量消耗`);
|
|
|
|
for (const cid of cids) {
|
|
try {
|
|
await this.sendATWithRetry(this.getMobileDataCommand('mipcall', false, cid), {
|
|
timeout: 8000,
|
|
retries: 1,
|
|
label: `断开应用层拨号(CID ${cid})`,
|
|
required: true
|
|
});
|
|
} catch (err) {
|
|
err.mobileDataCritical = true;
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
const status = await this.waitForMobileDataState(false, options.timeout || 8000);
|
|
if (status.anyActive) {
|
|
const err = new Error(`MIPCALL断开后仍检测到活动连接: ${this.formatMobileDataContexts(status.contexts)}`);
|
|
err.mobileDataCritical = true;
|
|
throw err;
|
|
}
|
|
|
|
if (status.status === 'unknown') {
|
|
logger.warn('MIPCALL断开命令已成功发送，但状态未确认');
|
|
}
|
|
|
|
await this.tryDeactivatePdpContexts(cids);
|
|
|
|
logger.info('✓ 应用层拨号连接已断开');
|
|
return status;
|
|
}
|
|
|
|
async disableCgactMobileData(options = {}) {
|
|
const before = await this.getMobileDataStatus();
|
|
const cids = this.getMobileDataTargetCids(before);
|
|
let commandSucceeded = false;
|
|
|
|
logger.info(`${options.reason || '手动操作'}: 停用PDP数据连接，避免流量消耗`);
|
|
|
|
for (const cid of cids) {
|
|
const resp = await this.sendATWithRetry(this.getMobileDataCommand('cgact', false, cid), {
|
|
timeout: 8000,
|
|
retries: 1,
|
|
label: `停用PDP数据连接(CID ${cid})`,
|
|
required: false
|
|
});
|
|
|
|
commandSucceeded = commandSucceeded || Boolean(resp);
|
|
}
|
|
|
|
const status = await this.waitForMobileDataState(false, options.timeout || 8000);
|
|
if (status.anyActive) {
|
|
const message = `移动数据关闭后仍检测到活动连接: ${this.formatMobileDataContexts(status.contexts)}`;
|
|
if (options.required === false) {
|
|
logger.warn(message);
|
|
return status;
|
|
}
|
|
|
|
throw new Error(message);
|
|
}
|
|
|
|
if (status.status === 'unknown') {
|
|
const message = commandSucceeded ? '移动数据关闭命令已发送，但状态未确认' : '移动数据关闭命令未确认成功';
|
|
if (options.required === false) {
|
|
logger.warn(message);
|
|
return status;
|
|
}
|
|
|
|
throw new Error(message);
|
|
}
|
|
|
|
if (!commandSucceeded && before.status === 'unknown' && options.required !== false) {
|
|
throw new Error('移动数据关闭命令未确认成功');
|
|
}
|
|
|
|
logger.info('✓ 移动数据已关闭');
|
|
return status;
|
|
}
|
|
|
|
async tryDeactivatePdpContexts(cids) {
|
|
for (const cid of cids) {
|
|
const resp = await this.sendATWithRetry(this.getMobileDataCommand('cgact', false, cid), {
|
|
timeout: 8000,
|
|
retries: 1,
|
|
label: `保护性停用PDP(CID ${cid})`,
|
|
required: false
|
|
});
|
|
|
|
if (!resp) {
|
|
logger.warn(`保护性停用PDP(CID ${cid})未成功，已按MIPCALL断开结果继续`);
|
|
}
|
|
}
|
|
}
|
|
|
|
async forceMobileDataOff(stage) {
|
|
this.mobileData.desiredEnabled = false;
|
|
try {
|
|
return await this.disableMobileData({
|
|
reason: stage,
|
|
required: false,
|
|
timeout: 5000
|
|
});
|
|
} catch (err) {
|
|
if (err.mobileDataCritical) {
|
|
throw err;
|
|
}
|
|
|
|
logger.warn(`${stage}: 移动数据关闭未确认: ${err.message}`);
|
|
return this.getCachedMobileDataStatus();
|
|
}
|
|
}
|
|
|
|
async consumeMobileDataTraffic(options = {}) {
|
|
const target = this.normalizePingTarget(options.target || '8.8.8.8');
|
|
const status = await this.getMobileDataStatus();
|
|
|
|
if (status.status === 'unknown') {
|
|
const err = new Error(status.error || '未能确认移动数据状态，无法执行流量消耗测试');
|
|
err.statusCode = 503;
|
|
throw err;
|
|
}
|
|
|
|
if (!status.anyActive) {
|
|
const err = new Error('当前未开启流量，请先开启后再执行流量消耗测试');
|
|
err.statusCode = 409;
|
|
throw err;
|
|
}
|
|
|
|
return await this.runMPing(target, {
|
|
timeout: options.timeout || 35000,
|
|
pingTimeoutSeconds: options.pingTimeoutSeconds || 30,
|
|
count: options.count || 1
|
|
});
|
|
}
|
|
|
|
normalizePingTarget(value) {
|
|
const target = String(value || '').trim();
|
|
if (!target || !/^[A-Za-z0-9.:-]{1,253}$/.test(target)) {
|
|
throw new Error('Ping目标地址无效');
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
runMPing(target, options = {}) {
|
|
if (!this.port || !this.port.isOpen) {
|
|
throw new Error('串口未打开');
|
|
}
|
|
|
|
const timeout = options.timeout || 35000;
|
|
const pingTimeoutSeconds = Math.min(Math.max(Number(options.pingTimeoutSeconds) || 30, 1), 255);
|
|
const count = Math.min(Math.max(Number(options.count) || 1, 1), 10);
|
|
const command = `AT+MPING="${target}",${pingTimeoutSeconds},${count}`;
|
|
|
|
logger.info(`准备通过模组执行MPING，目标: ${target}`);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const lines = [];
|
|
let settled = false;
|
|
let commandAccepted = false;
|
|
|
|
const finish = (err, result = null) => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
|
|
settled = true;
|
|
clearTimeout(timer);
|
|
this.parser.removeListener('data', handler);
|
|
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(result);
|
|
}
|
|
};
|
|
|
|
const timer = setTimeout(() => {
|
|
finish(new Error(`MPING超时，未收到结果: ${target}`));
|
|
}, timeout);
|
|
|
|
const handler = (line) => {
|
|
const trimmed = String(line).trim();
|
|
if (!trimmed) {
|
|
return;
|
|
}
|
|
|
|
lines.push(trimmed);
|
|
|
|
if (trimmed === 'OK') {
|
|
commandAccepted = true;
|
|
return;
|
|
}
|
|
|
|
if (trimmed.includes('ERROR')) {
|
|
finish(new Error(`MPING命令失败: ${this.formatATResponse(lines.join('\n'))}`));
|
|
return;
|
|
}
|
|
|
|
if (trimmed.startsWith('+MPING:')) {
|
|
const result = this.parseMPingResult(trimmed, target);
|
|
result.commandAccepted = commandAccepted;
|
|
result.rawResponse = lines.join('\n');
|
|
|
|
if (result.success) {
|
|
logger.info(`✓ ${result.message}`);
|
|
finish(null, result);
|
|
} else {
|
|
const err = new Error(result.message);
|
|
err.statusCode = 502;
|
|
err.data = result;
|
|
finish(err);
|
|
}
|
|
}
|
|
};
|
|
|
|
this.parser.on('data', handler);
|
|
|
|
logger.debug(`>> ${command}`);
|
|
this.port.write(`${command}\r\n`, (err) => {
|
|
if (err) {
|
|
finish(err);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
parseMPingResult(line, target) {
|
|
const payload = line.slice('+MPING:'.length).trim();
|
|
const params = payload.match(/"[^"]*"|[^,]+/g)?.map(item => {
|
|
const value = item.trim();
|
|
return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
|
|
}) || [];
|
|
const resultCode = Number.parseInt(params[0], 10);
|
|
const responseTarget = params[1] || target;
|
|
const packetLength = Number.parseInt(params[2], 10);
|
|
const latencyMs = Number.parseInt(params[3], 10);
|
|
const ttl = Number.parseInt(params[4], 10);
|
|
const hasReplyFields = params.length >= 4;
|
|
const success = (resultCode === 0 || resultCode === 1) && hasReplyFields;
|
|
const message = success
|
|
? `MPING成功: ${responseTarget}, 延迟 ${Number.isFinite(latencyMs) ? `${latencyMs}ms` : '未知'}, TTL ${Number.isFinite(ttl) ? ttl : '未知'}`
|
|
: `MPING失败或目标不可达，错误码: ${Number.isFinite(resultCode) ? resultCode : payload}`;
|
|
|
|
return {
|
|
success,
|
|
target: responseTarget,
|
|
resultCode: Number.isFinite(resultCode) ? resultCode : null,
|
|
packetLength: Number.isFinite(packetLength) ? packetLength : null,
|
|
latencyMs: Number.isFinite(latencyMs) ? latencyMs : null,
|
|
ttl: Number.isFinite(ttl) ? ttl : null,
|
|
message,
|
|
rawLine: line
|
|
};
|
|
}
|
|
|
|
async waitForMobileDataState(enabled, timeout = 10000) {
|
|
const startedAt = Date.now();
|
|
let status = await this.getMobileDataStatus();
|
|
|
|
while (status.status !== 'unknown' && status.anyActive !== enabled && Date.now() - startedAt < timeout) {
|
|
await this.sleep(1000);
|
|
status = await this.getMobileDataStatus();
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
formatMobileDataContexts(contexts = []) {
|
|
const active = contexts
|
|
.filter(item => item.active)
|
|
.map(item => `CID ${item.cid}`)
|
|
.join(', ');
|
|
|
|
return active || '无';
|
|
}
|
|
|
|
splitATFields(value) {
|
|
const fields = [];
|
|
let current = '';
|
|
let quoted = false;
|
|
|
|
for (const char of String(value || '')) {
|
|
if (char === '"') {
|
|
quoted = !quoted;
|
|
continue;
|
|
}
|
|
|
|
if (char === ',' && !quoted) {
|
|
fields.push(current.trim());
|
|
current = '';
|
|
continue;
|
|
}
|
|
|
|
current += char;
|
|
}
|
|
|
|
fields.push(current.trim());
|
|
return fields;
|
|
}
|
|
|
|
parseSimSlotHint(value) {
|
|
const text = String(value || '').trim();
|
|
if (!text) {
|
|
return null;
|
|
}
|
|
|
|
const explicit = text.match(/\bSIM\s*[:=]?\s*([12])\b/i) || text.match(/\bSLOT\s*[:=]?\s*([12])\b/i);
|
|
if (explicit) {
|
|
return Number.parseInt(explicit[1], 10) - 1;
|
|
}
|
|
|
|
const zeroBased = text.match(/\b(?:SIM|SLOT)\s*[:=]\s*([01])\b/i);
|
|
if (zeroBased) {
|
|
return Number.parseInt(zeroBased[1], 10);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
parseIncomingSmsURC(line) {
|
|
const raw = String(line || '').trim();
|
|
const payload = raw.replace(/^\+CMT:\s*/i, '');
|
|
const fields = this.splitATFields(payload);
|
|
const length = Number.parseInt(fields[fields.length - 1], 10);
|
|
const simSlot = fields
|
|
.map(field => this.parseSimSlotHint(field))
|
|
.find(slot => slot === 0 || slot === 1);
|
|
|
|
return {
|
|
type: 'CMT',
|
|
raw,
|
|
fields,
|
|
length: Number.isFinite(length) ? length : null,
|
|
simSlot: simSlot ?? null,
|
|
receivedAt: new Date().toISOString()
|
|
};
|
|
}
|
|
|
|
parseIncomingSmsIndexURC(line) {
|
|
const raw = String(line || '').trim();
|
|
const payload = raw.replace(/^\+CMTI:\s*/i, '');
|
|
const fields = this.splitATFields(payload);
|
|
const mem = fields[0] || '';
|
|
const index = Number.parseInt(fields[1], 10);
|
|
const simSlot = fields
|
|
.map(field => this.parseSimSlotHint(field))
|
|
.find(slot => slot === 0 || slot === 1);
|
|
|
|
return {
|
|
type: 'CMTI',
|
|
raw,
|
|
mem,
|
|
index: Number.isFinite(index) ? index : null,
|
|
simSlot: simSlot ?? null,
|
|
receivedAt: new Date().toISOString()
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 设置URC监听器
|
|
*/
|
|
setupURCListener() {
|
|
let waitingPDU = false;
|
|
let pendingSms = null;
|
|
|
|
this.parser.on('data', (line) => {
|
|
line = line.trim();
|
|
|
|
// 调试输出
|
|
if (line.length > 0 && !line.startsWith('AT')) {
|
|
logger.debug(`<< ${line}`);
|
|
}
|
|
|
|
// 检测短信URC
|
|
if (line.startsWith('+CMT:')) {
|
|
pendingSms = this.parseIncomingSmsURC(line);
|
|
const slotLabel = pendingSms.simSlot === null ? '未携带卡槽' : `SIM${pendingSms.simSlot + 1}`;
|
|
logger.info(`检测到短信URC(${slotLabel})，等待PDU数据...`);
|
|
waitingPDU = true;
|
|
} else if (line.startsWith('+CMTI:')) {
|
|
const notification = this.parseIncomingSmsIndexURC(line);
|
|
const slotLabel = notification.simSlot === null ? '未携带卡槽' : `SIM${notification.simSlot + 1}`;
|
|
logger.info(`检测到短信存储通知(${slotLabel}): ${notification.mem || '未知存储'} ${notification.index ?? '未知编号'}`);
|
|
this.emit('sms-notification', notification);
|
|
this.readSmsFromNotification(notification).catch((err) => {
|
|
logger.warn(`读取短信存储通知失败: ${err.message}`);
|
|
});
|
|
} else if (waitingPDU && this.isHexString(line)) {
|
|
logger.info('收到PDU数据');
|
|
waitingPDU = false;
|
|
this.emit('sms', {
|
|
pdu: line,
|
|
metadata: pendingSms || {
|
|
type: 'CMT',
|
|
raw: '',
|
|
simSlot: null,
|
|
receivedAt: new Date().toISOString()
|
|
}
|
|
});
|
|
pendingSms = null;
|
|
} else if (waitingPDU && line.length === 0) {
|
|
// 跳过空行
|
|
} else if (waitingPDU) {
|
|
// 收到非PDU数据，返回等待状态
|
|
waitingPDU = false;
|
|
pendingSms = null;
|
|
}
|
|
|
|
// 检测网络注册状态变化
|
|
if (line.startsWith('+CEREG:')) {
|
|
this.emit('cereg', line);
|
|
}
|
|
});
|
|
}
|
|
|
|
parseStoredSmsResponse(resp, notification = {}) {
|
|
const lines = String(resp || '')
|
|
.split('\n')
|
|
.map(line => line.trim())
|
|
.filter(Boolean);
|
|
let header = '';
|
|
let pdu = '';
|
|
|
|
for (const line of lines) {
|
|
if (line.startsWith('+CMGR:')) {
|
|
header = line;
|
|
continue;
|
|
}
|
|
|
|
if (!pdu && this.isHexString(line) && line.length > 8) {
|
|
pdu = line;
|
|
}
|
|
}
|
|
|
|
if (!pdu) {
|
|
return null;
|
|
}
|
|
|
|
const headerFields = header ? this.splitATFields(header.replace(/^\+CMGR:\s*/i, '')) : [];
|
|
const length = Number.parseInt(headerFields[headerFields.length - 1], 10);
|
|
|
|
return {
|
|
pdu,
|
|
metadata: {
|
|
...notification,
|
|
type: 'CMTI',
|
|
raw: notification.raw || '',
|
|
cmgrRaw: header,
|
|
length: Number.isFinite(length) ? length : null,
|
|
receivedAt: notification.receivedAt || new Date().toISOString()
|
|
}
|
|
};
|
|
}
|
|
|
|
async readSmsFromNotification(notification = {}) {
|
|
if (!Number.isInteger(notification.index)) {
|
|
logger.warn('短信存储通知缺少有效编号，跳过读取');
|
|
return false;
|
|
}
|
|
|
|
const memLabel = notification.mem ? `${notification.mem},` : '';
|
|
logger.info(`读取存储短信: ${memLabel}${notification.index}`);
|
|
const resp = await this.sendATCommand(`AT+CMGR=${notification.index}`, 5000);
|
|
const sms = this.parseStoredSmsResponse(resp, notification);
|
|
|
|
if (!sms) {
|
|
logger.warn(`未能从存储短信读取到PDU: ${this.formatATResponse(resp)}`);
|
|
return false;
|
|
}
|
|
|
|
logger.info('收到存储短信PDU数据');
|
|
this.emit('sms', sms);
|
|
await this.deleteSmsAtIndex(notification.index, notification.simSlot);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 检查是否为十六进制字符串
|
|
*/
|
|
isHexString(str) {
|
|
return /^[0-9A-Fa-f]+$/.test(str);
|
|
}
|
|
|
|
/**
|
|
* 发送AT命令并等待响应
|
|
*/
|
|
async sendATCommand(cmd, timeout = 2000) {
|
|
return this.enqueueATCommand(() => this.sendATCommandUnlocked(cmd, timeout));
|
|
}
|
|
|
|
enqueueATCommand(task) {
|
|
const run = this.atCommandQueue.then(task, task);
|
|
this.atCommandQueue = run.catch(() => {});
|
|
return run;
|
|
}
|
|
|
|
sendATCommandUnlocked(cmd, timeout = 2000) {
|
|
return new Promise((resolve, reject) => {
|
|
if (!this.port || !this.port.isOpen || !this.parser) {
|
|
reject(new Error('串口未打开'));
|
|
return;
|
|
}
|
|
|
|
let buffer = '';
|
|
const timer = setTimeout(() => {
|
|
this.parser.removeListener('data', handler);
|
|
reject(new Error(`AT命令超时: ${cmd}`));
|
|
}, timeout);
|
|
|
|
const handler = (line) => {
|
|
buffer += line + '\n';
|
|
if (line.includes('OK') || line.includes('ERROR')) {
|
|
clearTimeout(timer);
|
|
this.parser.removeListener('data', handler);
|
|
resolve(buffer);
|
|
}
|
|
};
|
|
|
|
this.parser.on('data', handler);
|
|
|
|
logger.debug(`>> ${cmd}`);
|
|
this.port.write(cmd + '\r\n');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 发送AT命令并等待OK
|
|
*/
|
|
async sendATandWaitOK(cmd, timeout = 2000) {
|
|
try {
|
|
const resp = await this.sendATCommand(cmd, timeout);
|
|
return resp.includes('OK');
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 发送AT命令，失败时打印模组原始响应，便于排查型号差异
|
|
*/
|
|
async sendATWithRetry(cmd, options = {}) {
|
|
const {
|
|
timeout = 2000,
|
|
retries = 3,
|
|
retryDelay = 1000,
|
|
label = cmd,
|
|
required = true
|
|
} = options;
|
|
|
|
for (let attempt = 1; attempt <= retries; attempt++) {
|
|
try {
|
|
const resp = await this.sendATCommand(cmd, timeout);
|
|
if (resp.includes('OK')) {
|
|
return resp;
|
|
}
|
|
|
|
logger.warn(`${label}失败(${attempt}/${retries}): ${this.formatATResponse(resp)}`);
|
|
} catch (err) {
|
|
logger.warn(`${label}失败(${attempt}/${retries}): ${err.message}`);
|
|
}
|
|
|
|
if (attempt < retries && retryDelay > 0) {
|
|
await this.sleep(retryDelay);
|
|
}
|
|
}
|
|
|
|
if (required) {
|
|
throw new Error(`${label}失败`);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 压缩AT响应，避免日志跨太多行
|
|
*/
|
|
formatATResponse(resp) {
|
|
return resp
|
|
.split('\n')
|
|
.map(line => line.trim())
|
|
.filter(Boolean)
|
|
.join(' | ');
|
|
}
|
|
|
|
/**
|
|
* 初始化模组
|
|
*/
|
|
async init() {
|
|
logger.info('开始初始化4G模组...');
|
|
|
|
// 1. AT握手
|
|
let retries = 0;
|
|
while (!(await this.sendATandWaitOK('AT', 1000)) && retries < 10) {
|
|
logger.warn('AT未响应，重试...');
|
|
retries++;
|
|
await this.sleep(1000);
|
|
}
|
|
if (retries >= 10) {
|
|
throw new Error('模组AT握手失败');
|
|
}
|
|
logger.info('✓ 模组AT响应正常');
|
|
|
|
// 2. 查询模组信息
|
|
try {
|
|
const resp = await this.sendATCommand('ATI', 2000);
|
|
const lines = resp.split('\n').map(l => l.trim()).filter(l => l && l !== 'ATI' && l !== 'OK');
|
|
if (lines.length >= 3) {
|
|
this.modelInfo.manufacturer = lines[0];
|
|
this.modelInfo.model = lines[1];
|
|
this.modelInfo.version = lines[2];
|
|
logger.info(`模组信息: ${this.modelInfo.manufacturer} ${this.modelInfo.model} ${this.modelInfo.version}`);
|
|
}
|
|
} catch (err) {
|
|
logger.warn('查询模组信息失败');
|
|
}
|
|
|
|
// 3. 启动时先重置协议栈，避免上一次双卡切换/短信上报状态残留。
|
|
await this.resetProtocolStackForStartup();
|
|
|
|
// 3.1. 查询双卡能力和当前卡槽；不支持时保持单卡运行。
|
|
await this.refreshSimStatus({ refreshIdentity: false });
|
|
|
|
// 3. 按ML307A文档先确认SIM卡和协议栈状态
|
|
await this.waitSIMReady();
|
|
|
|
// 启动时只初始化当前卡，不遍历其他卡槽。
|
|
await this.discoverSimSlotIdentities();
|
|
await this.ensureFullFunctionality();
|
|
|
|
// 4. 启动保护：先断开应用层拨号，再等待短信所需的网络注册。
|
|
await this.forceMobileDataOff('启动保护(CFUN=1后)');
|
|
|
|
// 5. 等待网络注册
|
|
this.ready = await this.waitForNetworkRegistration('启动', 30, 2000);
|
|
|
|
// 6. 驻网后再断开一次，防止模组自动拨号在驻网完成后重新拉起。
|
|
await this.forceMobileDataOff('启动保护(驻网后)');
|
|
|
|
// 7. 按文档配置短信功能，并启用本项目需要的PDU模式
|
|
await this.configureSMS();
|
|
await this.refreshSimStatus({ refreshIdentity: true });
|
|
|
|
logger.info('模组初始化完成');
|
|
this.emit('ready');
|
|
}
|
|
|
|
/**
|
|
* 等待SIM卡完成初始化
|
|
*/
|
|
async waitSIMReady() {
|
|
for (let attempt = 1; attempt <= 10; attempt++) {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+CPIN?', 2000);
|
|
if (resp.includes('+CPIN: READY')) {
|
|
logger.info('✓ SIM卡已就绪');
|
|
return;
|
|
}
|
|
|
|
logger.warn(`SIM卡未就绪(${attempt}/10): ${this.formatATResponse(resp)}`);
|
|
} catch (err) {
|
|
logger.warn(`查询SIM卡状态失败(${attempt}/10): ${err.message}`);
|
|
}
|
|
|
|
await this.sleep(1000);
|
|
}
|
|
|
|
throw new Error('SIM卡未就绪');
|
|
}
|
|
|
|
/**
|
|
* 确保驻网前协议栈功能模式为CFUN=1
|
|
*/
|
|
async ensureFullFunctionality() {
|
|
const resp = await this.sendATCommand('AT+CFUN?', 2000);
|
|
const match = resp.match(/\+CFUN:\s*(\d+)/);
|
|
|
|
if (match && match[1] === '1') {
|
|
logger.info('✓ 协议栈功能模式正常(CFUN=1)');
|
|
return;
|
|
}
|
|
|
|
logger.warn(`当前CFUN状态不是1: ${this.formatATResponse(resp)}`);
|
|
await this.sendATWithRetry('AT+CFUN=1', {
|
|
timeout: 5000,
|
|
retries: 3,
|
|
label: '设置CFUN=1'
|
|
});
|
|
|
|
// 文档要求CFUN切换后等待模组完成协议栈恢复。
|
|
await this.sleep(2000);
|
|
logger.info('✓ 已设置协议栈功能模式(CFUN=1)');
|
|
}
|
|
|
|
/**
|
|
* 启动时重置协议栈。避免使用 AT+CFUN=1,1 整机重启导致USB串口断开后反复重启容器。
|
|
*/
|
|
async resetProtocolStackForStartup() {
|
|
logger.info('启动初始化: 重置协议栈(CFUN=0 -> CFUN=1)');
|
|
|
|
try {
|
|
await this.sendATWithRetry('AT+CFUN=0', {
|
|
timeout: 8000,
|
|
retries: 2,
|
|
retryDelay: 1000,
|
|
label: '启动重置协议栈(CFUN=0)',
|
|
required: false
|
|
});
|
|
|
|
await this.sleep(3000);
|
|
|
|
await this.sendATWithRetry('AT+CFUN=1', {
|
|
timeout: 10000,
|
|
retries: 3,
|
|
retryDelay: 2000,
|
|
label: '启动恢复协议栈(CFUN=1)'
|
|
});
|
|
|
|
await this.sleep(5000);
|
|
logger.info('✓ 启动协议栈重置完成');
|
|
} catch (err) {
|
|
logger.warn(`启动协议栈重置失败，继续初始化: ${err.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 按ML307A文档配置短信功能；项目接收逻辑依赖PDU模式下的+CMT上报。
|
|
*/
|
|
async configureSMS() {
|
|
if (this.modelInfo.version.includes('ML307A-DL')) {
|
|
throw new Error('当前ML307A-DL型号不支持短信功能');
|
|
}
|
|
|
|
await this.sendATWithRetry('AT+CMGF=0', {
|
|
timeout: 2000,
|
|
retries: 3,
|
|
label: '设置PDU模式'
|
|
});
|
|
logger.info('✓ PDU模式设置完成');
|
|
|
|
await this.sendATWithRetry('AT+CNMI=2,2,0,2,0', {
|
|
timeout: 2000,
|
|
retries: 3,
|
|
label: '设置CNMI短信上报'
|
|
});
|
|
logger.info('✓ CNMI参数设置完成');
|
|
|
|
await this.sendATWithRetry('AT+CSCS="IRA"', {
|
|
timeout: 2000,
|
|
retries: 3,
|
|
label: '设置短信字符集'
|
|
});
|
|
logger.info('✓ 短信字符集设置完成');
|
|
|
|
await this.sendATWithRetry('AT+CSMP=33,167,0,0', {
|
|
timeout: 2000,
|
|
retries: 3,
|
|
label: '设置短信发送参数'
|
|
});
|
|
logger.info('✓ 短信发送参数设置完成');
|
|
|
|
return null;
|
|
}
|
|
|
|
async deleteSmsAtIndex(index, slot = null) {
|
|
try {
|
|
await this.sendATWithRetry(`AT+CMGD=${index}`, {
|
|
timeout: 5000,
|
|
retries: 1,
|
|
label: `删除已读取短信${slot === null ? '' : `(SIM${slot + 1})`}`,
|
|
required: false
|
|
});
|
|
} catch (err) {
|
|
logger.warn(`删除已读取短信失败: ${err.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 判断是否为ML307系列模组
|
|
*/
|
|
isML307Family() {
|
|
return this.modelInfo.model.startsWith('ML307') || this.modelInfo.version.startsWith('ML307');
|
|
}
|
|
|
|
/**
|
|
* 检测网络注册状态
|
|
*/
|
|
async waitCEREG() {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+CEREG?', 2000);
|
|
// +CEREG: 0,1 或 +CEREG: 0,5 表示已注册
|
|
if (resp.includes('+CEREG:')) {
|
|
if (resp.includes(',1') || resp.includes(',5')) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async waitForNetworkRegistration(label = '网络注册', maxRetries = 30, retryDelay = 2000) {
|
|
let retries = 0;
|
|
while (!(await this.waitCEREG()) && retries < maxRetries) {
|
|
logger.info(`${label}: 等待网络注册...`);
|
|
retries++;
|
|
await this.sleep(retryDelay);
|
|
}
|
|
|
|
if (retries < maxRetries) {
|
|
logger.info('✓ 网络已注册');
|
|
return true;
|
|
}
|
|
|
|
logger.error(`${label}: 网络注册超时（无SIM卡或信号差）`);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 发送短信（PDU模式）
|
|
*/
|
|
async sendSMS(phoneNumber, message) {
|
|
const sendResult = {
|
|
success: false,
|
|
simSlot: null,
|
|
simLabel: '未知SIM',
|
|
parts: 0
|
|
};
|
|
|
|
if (this.isSimSwitching()) {
|
|
logger.warn('SIM切换中，暂不发送短信');
|
|
return sendResult;
|
|
}
|
|
|
|
logger.info(`准备发送短信到: ${phoneNumber}`);
|
|
logger.info(`短信内容: ${message}`);
|
|
this.smsSending = true;
|
|
|
|
try {
|
|
const simSync = await this.ensureATSimMatchesBinding('发送短信前SIM同步');
|
|
if (simSync?.changed) {
|
|
await this.configureSMS();
|
|
}
|
|
|
|
const sendSlot = this.normalizeSimSlot(simSync?.slot ?? this.sim.bindSlot ?? await this.queryBindSimSlot().catch(() => null));
|
|
sendResult.simSlot = sendSlot;
|
|
sendResult.simLabel = this.getSimSlotLabel(sendSlot);
|
|
logger.info(`发送使用SIM: ${sendResult.simLabel}${sendSlot === null ? '' : ` (SIM${sendSlot + 1})`}`);
|
|
|
|
// 编码PDU
|
|
const submit = new Submit(phoneNumber, message);
|
|
const parts = submit.getPartStrings();
|
|
sendResult.parts = parts.length;
|
|
|
|
if (parts.length === 0) {
|
|
throw new Error('PDU编码失败');
|
|
}
|
|
|
|
for (let i = 0; i < parts.length; i++) {
|
|
const pduData = parts[i];
|
|
const pduLength = this.getSubmitPduLength(pduData);
|
|
|
|
logger.debug(`PDU分段: ${i + 1}/${parts.length}`);
|
|
logger.debug(`PDU数据: ${pduData}`);
|
|
logger.debug(`PDU长度: ${pduLength}`);
|
|
|
|
const success = await this.sendPduPart(pduData, pduLength);
|
|
if (!success) {
|
|
logger.error(`✗ 短信分段发送失败: ${i + 1}/${parts.length}`);
|
|
return sendResult;
|
|
}
|
|
}
|
|
|
|
logger.info('✓ 短信发送成功');
|
|
sendResult.success = true;
|
|
return sendResult;
|
|
} catch (err) {
|
|
logger.error('发送短信异常:', err);
|
|
return sendResult;
|
|
} finally {
|
|
this.smsSending = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 计算AT+CMGS需要的TPDU长度，不包含SMSC长度字段和SMSC内容。
|
|
*/
|
|
getSubmitPduLength(pduData) {
|
|
const smscLength = parseInt(pduData.slice(0, 2), 16);
|
|
const totalLength = pduData.length / 2;
|
|
const submitLength = totalLength - smscLength - 1;
|
|
|
|
if (!Number.isFinite(submitLength) || submitLength <= 0) {
|
|
throw new Error(`PDU长度无效: ${pduData}`);
|
|
}
|
|
|
|
return submitLength;
|
|
}
|
|
|
|
/**
|
|
* 发送单个PDU分段。
|
|
*/
|
|
async sendPduPart(pduData, pduLength) {
|
|
const cmgsCmd = `AT+CMGS=${pduLength}`;
|
|
this.port.write(cmgsCmd + '\r\n');
|
|
|
|
const gotPrompt = await this.waitForPrompt();
|
|
if (!gotPrompt) {
|
|
throw new Error('未收到>提示符');
|
|
}
|
|
|
|
logger.debug('收到>提示符，发送PDU数据...');
|
|
this.port.write(pduData + String.fromCharCode(0x1A));
|
|
|
|
return await this.waitForCMGSResult();
|
|
}
|
|
|
|
/**
|
|
* 等待CMGS输入提示符。提示符通常没有行结束符，所以直接监听原始串口数据。
|
|
*/
|
|
waitForPrompt(timeout = 5000) {
|
|
return new Promise((resolve) => {
|
|
let buffer = '';
|
|
const timer = setTimeout(() => {
|
|
this.port.removeListener('data', handler);
|
|
resolve(false);
|
|
}, timeout);
|
|
|
|
const handler = (chunk) => {
|
|
buffer += chunk.toString('utf8');
|
|
if (buffer.includes('>')) {
|
|
clearTimeout(timer);
|
|
this.port.removeListener('data', handler);
|
|
resolve(true);
|
|
}
|
|
};
|
|
|
|
this.port.on('data', handler);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 等待短信发送结果。
|
|
*/
|
|
waitForCMGSResult(timeout = 30000) {
|
|
return new Promise((resolve) => {
|
|
const timer = setTimeout(() => {
|
|
this.parser.removeListener('data', handler);
|
|
logger.warn('等待CMGS发送结果超时');
|
|
resolve(false);
|
|
}, timeout);
|
|
|
|
const handler = (line) => {
|
|
if (line.includes('OK')) {
|
|
clearTimeout(timer);
|
|
this.parser.removeListener('data', handler);
|
|
resolve(true);
|
|
} else if (line.includes('ERROR')) {
|
|
clearTimeout(timer);
|
|
this.parser.removeListener('data', handler);
|
|
logger.warn(`CMGS发送返回错误: ${String(line).trim()}`);
|
|
resolve(false);
|
|
}
|
|
};
|
|
|
|
this.parser.on('data', handler);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 查询信号强度
|
|
*/
|
|
async getSignalQuality() {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+CSQ', 2000);
|
|
const match = resp.match(/\+CSQ:\s*(\d+),(\d+)/);
|
|
if (match) {
|
|
const rssi = parseInt(match[1]);
|
|
const ber = parseInt(match[2]);
|
|
let quality = '未知';
|
|
if (rssi === 99) {
|
|
quality = '未知或不可检测';
|
|
} else if (rssi >= 20) {
|
|
quality = '很好';
|
|
} else if (rssi >= 15) {
|
|
quality = '好';
|
|
} else if (rssi >= 10) {
|
|
quality = '一般';
|
|
} else {
|
|
quality = '弱';
|
|
}
|
|
return { rssi, ber, quality };
|
|
}
|
|
return null;
|
|
} catch (err) {
|
|
logger.error('查询信号强度失败:', err);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 查询运营商
|
|
*/
|
|
async getOperator() {
|
|
try {
|
|
const resp = await this.sendATCommand('AT+COPS?', 2000);
|
|
const match = resp.match(/\+COPS:\s*\d+,\d+,"([^"]+)"/);
|
|
if (match) {
|
|
return match[1];
|
|
}
|
|
return '未知';
|
|
} catch (err) {
|
|
logger.error('查询运营商失败:', err);
|
|
return '未知';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 关闭串口
|
|
*/
|
|
async close() {
|
|
if (this.port && this.port.isOpen) {
|
|
await new Promise((resolve) => {
|
|
this.port.close(resolve);
|
|
});
|
|
logger.info('串口已关闭');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 辅助函数：延时
|
|
*/
|
|
sleep(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
}
|
|
|
|
export default ModemManager;
|