/**
|
* 驱动模块文件
|
* 包含系统所有硬件驱动的初始化和操作方法，是系统与硬件交互的核心模块
|
*/
|
import * as os from "os"
|
import capturer from '../dxmodules/dxCapturer.js'
|
import cameraCalibration from '../dxmodules/dxCameraCalibration.js'
|
import face from '../dxmodules/dxFace.js'
|
import std from '../dxmodules/dxStd.js'
|
import common from '../dxmodules/dxCommon.js'
|
import utils from './common/utils/utils.js'
|
import alsa from '../dxmodules/dxAlsa.js'
|
import config from '../dxmodules/dxConfig.js'
|
import pwm from '../dxmodules/dxPwm.js'
|
import net from '../dxmodules/dxNet.js'
|
import ntp from '../dxmodules/dxNtp.js'
|
import mqtt from '../dxmodules/dxMqtt.js'
|
import dxMap from '../dxmodules/dxMap.js'
|
import logger from '../dxmodules/dxLogger.js'
|
import sqliteService from "./service/sqliteService.js"
|
import mqttService from "./service/mqttService.js"
|
import gpio from "../dxmodules/dxGpio.js"
|
import map from "../dxmodules/dxMap.js"
|
import eid from "../dxmodules/dxEid.js"
|
import nfc from "../dxmodules/dxNfc.js"
|
import bus from "../dxmodules/dxEventBus.js"
|
import dxUart from "../dxmodules/dxUart.js"
|
import watchdog from "../dxmodules/dxWatchdog.js"
|
import base64 from "../dxmodules/dxBase64.js"
|
import dxGpioKey from "../dxmodules/dxGpioKey.js"
|
import dxDriver from "../dxmodules/dxDriver.js"
|
const driver = {}
|
|
/**
|
* 音频驱动模块
|
* 负责音频播放和语音合成
|
*/
|
driver.alsa = alsa
|
|
/**
|
* 配置驱动模块
|
* 负责初始化系统配置，设置系统基本信息
|
*/
|
driver.config = {
|
/**
|
* 初始化配置
|
* 初始化配置模块，设置系统MAC、UUID、SN等基本信息
|
*/
|
init: function () {
|
config.init()
|
let mac = common.getUuid2mac(19)
|
let uuid = common.getSn(19)
|
if (!config.get('sys.mac') && mac) {
|
config.set('sys.mac', mac)
|
}
|
if (!config.get('sys.uuid') && uuid) {
|
config.set('sys.uuid', uuid)
|
}
|
//如果 sn 为空先用设备 uuid
|
if (!config.get('sys.sn') && uuid) {
|
config.set('sys.sn', uuid)
|
}
|
if (!config.get('mqtt.clientId') && uuid) {
|
config.set('mqtt.clientId', uuid)
|
}
|
config.save()
|
}
|
}
|
/**
|
* 屏幕驱动模块
|
* 负责屏幕相关的事件触发和操作
|
*/
|
driver.screen = {
|
/**
|
* 通行失败
|
* 触发通行失败事件
|
*/
|
accessFail: function () {
|
bus.fire('accessRes', false)
|
},
|
|
/**
|
* 通行成功
|
* 触发通行成功事件
|
*/
|
accessSuccess: function () {
|
bus.fire('accessRes', true)
|
},
|
|
/**
|
* 升级
|
* 触发升级事件
|
* @param {object} data - 升级数据
|
*/
|
upgrade: function (data) {
|
bus.fire('upgrade', data)
|
},
|
|
/**
|
* 获取卡片
|
* 播放读卡声音并触发获取卡片事件
|
* @param {string} card - 卡片信息
|
*/
|
getCard: function (card) {
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/read.wav`)
|
bus.fire('getCard', card)
|
},
|
|
/**
|
* 隐藏SN
|
* 触发隐藏SN事件
|
* @param {object} data - 事件数据
|
*/
|
hideSn: function (data) {
|
bus.fire('hideSn', data)
|
},
|
|
/**
|
* 应用模式
|
* 触发应用模式事件
|
* @param {object} data - 模式数据
|
*/
|
appMode: function (data) {
|
bus.fire('appMode', data)
|
},
|
|
/**
|
* 隐藏IP
|
* 触发隐藏IP事件
|
* @param {object} data - 事件数据
|
*/
|
hideIp: function (data) {
|
bus.fire('hideIp', data)
|
},
|
|
/**
|
* 切换语言
|
* 触发语言切换事件
|
*/
|
changeLanguage: function () {
|
bus.fire('changeLanguage')
|
}
|
}
|
/**
|
* SQLite驱动模块
|
* 负责数据库初始化和管理
|
*/
|
driver.sqlite = {
|
/**
|
* 初始化数据库
|
* 确保数据库路径存在并初始化SQLite服务
|
*/
|
init: function () {
|
std.ensurePathExists('/app/data/db/app.db')
|
sqliteService.init('/app/data/db/app.db')
|
}
|
}
|
|
/**
|
* PWM驱动模块
|
* 负责控制补光灯的亮度
|
*/
|
driver.pwm = {
|
/**
|
* 初始化PWM
|
* 初始化白色补光灯和红外补光灯的PWM通道
|
*/
|
init: function () {
|
// 白灯
|
let luminanceWhite = config.get('base.luminanceWhite') ?? 80
|
pwm.request(dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL);
|
pwm.setPeriodByChannel(dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL, dxDriver.PWM.WHITE_SUPPLEMENT_PERIOD_NS)
|
pwm.enable(dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL, true);
|
pwm.setDutyByChannel(dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL, dxDriver.PWM.WHITE_SUPPLEMENT_PERIOD_NS - (dxDriver.PWM.WHITE_SUPPLEMENT_PERIOD_NS * (luminanceWhite / 100)))
|
// 红外
|
let luminanceNir = config.get('base.luminanceNir') ?? 80
|
pwm.request(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL);
|
pwm.setPeriodByChannel(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL, dxDriver.PWM.NIR_SUPPLEMENT_PERIOD_NS)
|
pwm.enable(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL, true);
|
pwm.setDutyByChannel(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL, dxDriver.PWM.NIR_SUPPLEMENT_PERIOD_NS - (dxDriver.PWM.NIR_SUPPLEMENT_PERIOD_NS * (luminanceNir / 100)))
|
},
|
|
/**
|
* 调节白色补光灯亮度
|
* @param {number} value - 亮度值，范围0-100
|
*/
|
luminanceWhite: function (value) {
|
if (value < 0 || value > 100) {
|
logger.error("[driver.pwm]: value should be between 0 and 100")
|
return
|
}
|
pwm.setDutyByChannel(dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL, dxDriver.PWM.WHITE_SUPPLEMENT_PERIOD_NS - (dxDriver.PWM.WHITE_SUPPLEMENT_PERIOD_NS * (value / 100)))
|
},
|
|
/**
|
* 调节红外补光灯亮度
|
* @param {number} value - 亮度值，范围0-100
|
*/
|
luminanceNir: function (value) {
|
if (value < 0 || value > 100) {
|
logger.error("[driver.pwm]: value should be between 0 and 100")
|
return
|
}
|
pwm.setDutyByChannel(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL, dxDriver.PWM.NIR_SUPPLEMENT_PERIOD_NS - (dxDriver.PWM.NIR_SUPPLEMENT_PERIOD_NS * (value / 100)))
|
}
|
}
|
|
/**
|
* ALSA驱动模块
|
* 负责音频播放和音量控制
|
*/
|
driver.alsa = {
|
/**
|
* 初始化音频
|
* 初始化ALSA音频模块并设置音量
|
*/
|
init: function () {
|
alsa.init()
|
this.volume(config.get("base.volume"))
|
},
|
|
/**
|
* 播放音频文件
|
* @param {string} src - 音频文件路径
|
*/
|
play: function (src) {
|
alsa.play(src)
|
},
|
|
/**
|
* 文本转语音播放
|
* @param {string} text - 要播放的文本
|
*/
|
ttsPlay: function (text) {
|
alsa.ttsPlay(text)
|
},
|
|
/**
|
* 获取或设置音量
|
* @param {number} [volume] - 音量值，范围1-100
|
* @returns {number} 当前音量值（当未提供参数时）
|
*/
|
volume: function (volume) {
|
if (volume === undefined || volume === null) {
|
return alsa.getVolume()
|
} else {
|
function mapScore(input) {
|
// 确保输入值在1-100之间
|
if (input < 1 || input > 100) {
|
throw new Error('输入值必须在1到100之间');
|
}
|
if (input < 60 && input > 30) {
|
input = input * 1.2
|
}
|
if (input < 30 && input > 1) {
|
input = input * 2
|
}
|
return input
|
}
|
alsa.setVolume(mapScore(volume))
|
}
|
}
|
}
|
|
/**
|
* 摄像头驱动模块
|
* 负责摄像头的初始化和操作，包括彩色摄像头和红外摄像头
|
*/
|
driver.capturer = {
|
/**
|
* 彩色摄像头配置
|
*/
|
options1: {
|
id: "rgb",
|
path: dxDriver.CAPTURER.RGB_PATH,
|
width: dxDriver.CAPTURER.RGB_WIDTH,
|
height: dxDriver.CAPTURER.RGB_HEIGHT,
|
preview_width: dxDriver.CAPTURER.RGB_HEIGHT,
|
preview_height: dxDriver.CAPTURER.RGB_WIDTH,
|
preview_mode: 2,
|
preview_screen_index: 0 // 先后顺序，数字越大越在前面
|
},
|
|
/**
|
* 红外摄像头配置
|
*/
|
options2: {
|
id: "nir",
|
path: dxDriver.CAPTURER.NIR_PATH,
|
width: dxDriver.CAPTURER.NIR_WIDTH,
|
height: dxDriver.CAPTURER.NIR_HEIGHT,
|
preview_width: 150,
|
preview_height: 200,
|
preview_mode: 1,
|
preview_left: 605,
|
preview_top: 80,
|
preview_screen_index: 1 // 先后顺序，数字越大越在前面
|
},
|
|
/**
|
* 初始化摄像头
|
* 初始化彩色摄像头和红外摄像头
|
*/
|
init: function () {
|
capturer.worker.beforeLoop(this.options1)
|
capturer.worker.beforeLoop(this.options2)
|
|
this.showNir(config.get("face.showNir"))
|
},
|
|
/**
|
* 显示或隐藏红外摄像头预览
|
* @param {boolean} enable - 是否启用红外摄像头预览
|
*/
|
showNir: function (enable) {
|
capturer.capturerEnable(enable, this.options2.id)
|
},
|
|
/**
|
* 将图片数据转换为图像
|
* @param {string} base64Data - Base64编码的图片数据
|
* @returns {number} 图像ID
|
*/
|
pictureDataToImage: function (base64Data) {
|
return capturer.pictureDataToImage(base64Data, base64Data.length, 1)
|
},
|
|
/**
|
* 将图像保存为文件
|
* @param {number} imageId - 图像ID
|
* @param {string} savePath - 保存路径
|
* @returns {boolean} 是否保存成功
|
*/
|
imageToPictureFile: function (imageId, savePath) {
|
return capturer.imageToPictureFile(imageId, 1, 0, 24, savePath)
|
},
|
|
/**
|
* 将图像保存为文件（高质量）
|
* @param {number} imageId - 图像ID
|
* @param {string} savePath - 保存路径
|
* @returns {boolean} 是否保存成功
|
*/
|
imageToPictureFile2: function (imageId, savePath) {
|
return capturer.imageToPictureFile(imageId, 1, 0, 100, savePath)
|
},
|
|
/**
|
* 调整图像分辨率
|
* @param {number} imageId - 图像ID
|
* @param {number} width - 目标宽度
|
* @param {number} height - 目标高度
|
* @returns {number} 调整后的图像ID
|
*/
|
imageResizeResolution: function (imageId, width, height) {
|
return capturer.imageResizeResolution(imageId, width, height, 0)
|
},
|
|
/**
|
* 摄像头循环
|
* 执行摄像头的循环操作
|
*/
|
loop: function () {
|
capturer.worker.loop(this.options1)
|
capturer.worker.loop(this.options2)
|
}
|
}
|
/**
|
* NFC驱动模块
|
* 负责NFC卡片的读取和处理
|
*/
|
driver.nfc = {
|
/**
|
* NFC配置选项
|
*/
|
options: { m1: true, psam: false },
|
|
/**
|
* 初始化NFC
|
* 初始化NFC模块，根据配置决定是否启用
|
*/
|
init: function () {
|
if (!config.get('sys.nfc')) {
|
logger.debug("刷卡已关闭")
|
return
|
}
|
this.options.useEid = config.get("sys.nfcIdentityCardEnable") == 3 ? 1 : 0
|
nfc.worker.beforeLoop(this.options)
|
},
|
|
/**
|
* 初始化EID（电子身份证）
|
* 更新EID配置
|
*/
|
eidInit: function () {
|
if (!config.get('sys.nfc')) {
|
return
|
}
|
if (config.get("sys.nfcIdentityCardEnable") == 3) {
|
nfc.eidUpdateConfig({ appid: "1621503", sn: config.get("sys.sn"), device_model: config.get("sys.appVersion") })
|
}
|
},
|
|
/**
|
* NFC循环
|
* 执行NFC的循环操作，根据配置决定是否启用
|
*/
|
loop: function () {
|
if (!config.get('sys.nfc')) {
|
this.loop = () => { }
|
} else {
|
this.loop = () => nfc.worker.loop(this.options)
|
}
|
}
|
}
|
/**
|
* 人脸识别驱动模块
|
* 负责人脸识别、注册和相关功能的管理
|
*/
|
driver.face = {
|
/**
|
* 初始化人脸识别
|
* 初始化人脸模块，设置相关参数和配置
|
*/
|
init: function () {
|
common.systemBrief('mkdir -p /app/data/user/temp/')
|
let options = {
|
dbPath: "/app/data/db/face.db",
|
rgbPath: "/dev/video3",
|
nirPath: "/dev/video0",
|
capturerRgbId: "rgb",
|
capturerNirId: "nir",
|
dbMax: 5000, //人脸注册上限
|
score: config.get("face.similarity"),
|
picPath: "/app/data/user/temp",
|
gThumbnailHeight: 1280 / 6,
|
gThumbnailWidth: 800 / 6,
|
// 是否开启重检
|
recgFaceattrEnable: 1,
|
// 活体开关
|
livingCheckEnable: config.get("face.livenessOff"),
|
// 活体检测阈值
|
livingScore: config.get("face.livenessVal"),
|
// 口罩检测开关
|
detectMaskEnable: config.get("face.detectMask"),
|
// 重检间隔
|
recheckIntervalTime: 5000,
|
// 检测超时
|
detectTimeoutTime: 1000
|
}
|
face.worker.beforeLoop(options)
|
|
// 默认为人脸识别模式
|
this.mode(0)
|
// 关闭所有人脸功能
|
this.status(false)
|
|
// 屏幕亮度
|
this.setDisplayBacklight(config.get("base.brightness"))
|
|
this.screenStatus(1)
|
|
// 补光灯状态跟踪
|
let isLightOn = true
|
|
// 屏幕亮度自动调节
|
std.setInterval(() => {
|
// 熄屏判断
|
let screenOff = map.get("screenOff")
|
if (screenOff.get("status") == 1) {
|
this.setDisplayBacklight(0)
|
this.screenStatus(0)
|
// 关闭补光灯（仅当补光灯当前是开启状态时）
|
if (isLightOn) {
|
driver.pwm.luminanceWhite(0)
|
driver.pwm.luminanceNir(0)
|
logger.info("[driver.face]: 熄屏，关闭补光灯")
|
isLightOn = false
|
}
|
}
|
|
// 停止熄屏
|
if (screenOff.get("status") != 1) {
|
if (config.get("base.brightnessAuto") == 1) {
|
// 自动调节屏幕亮度
|
let brightness = Math.floor(face.getEnvBrightness() / 10)
|
brightness = brightness > 100 ? 100 : brightness
|
this.setDisplayBacklight(brightness)
|
} else {
|
this.setDisplayBacklight(config.get("base.brightness"))
|
}
|
// 开启补光灯（仅当补光灯当前是关闭状态时）
|
if (!isLightOn) {
|
let luminanceWhite = config.get('base.luminanceWhite') ?? 80
|
let luminanceNir = config.get('base.luminanceNir') ?? 80
|
driver.pwm.luminanceWhite(luminanceWhite)
|
driver.pwm.luminanceNir(luminanceNir)
|
logger.info(`[driver.face]: 退出熄屏，开启补光灯（白灯: ${luminanceWhite}%, 红外: ${luminanceNir}%）`)
|
isLightOn = true
|
}
|
}
|
}, 1000)
|
},
|
|
/**
|
* 获取人脸跟踪框
|
* @returns {object} 跟踪框信息
|
*/
|
getTrackingBox: function () {
|
return face.getTrackingBox()
|
},
|
|
/**
|
* 人脸识别循环
|
* 执行人脸识别的循环操作
|
*/
|
loop: function () {
|
// 检查屏幕是否处于熄屏状态
|
let screenOff = map.get("screenOff")
|
if (screenOff && screenOff.get("status") == 1) {
|
// 熄屏状态下不进行人脸识别
|
return
|
}
|
face.worker.loop()
|
},
|
|
/**
|
* 人脸线程启用开关
|
* @param {boolean} flag - 是否启用人脸检测
|
*/
|
status: function (flag) {
|
console.log('---人脸检测' + (flag ? '开启' : '暂停') + '---');
|
face.faceSetEnable(flag)
|
},
|
|
/**
|
* 设置人脸识别模式
|
* @param {number} value - 模式值，0为识别模式，1为注册模式
|
*/
|
mode: function (value) {
|
console.log('---人脸' + (value ? '注册' : '识别') + '模式---');
|
face.setRecgMode(value)
|
},
|
|
/**
|
* 人脸注册
|
* @param {string} id - 用户ID
|
* @param {string} feature - 人脸特征
|
* @returns {boolean} 是否注册成功
|
*/
|
reg: function (id, feature) {
|
return face.addFaceFeatures(id, feature);
|
},
|
|
/**
|
* 更新人脸配置
|
* @param {object} options - 配置选项
|
*/
|
faceUpdateConfig: function (options) {
|
console.log("更新人脸配置", JSON.stringify(options));
|
face.faceUpdateConfig(options)
|
},
|
|
/**
|
* 设置屏幕亮度
|
* @param {number} brightness - 亮度值
|
*/
|
setDisplayBacklight: function (brightness) {
|
brightness = brightness < 2 ? 2 : brightness
|
face.setDisplayBacklight(brightness)
|
},
|
|
/**
|
* 通过图片文件注册人脸
|
* @param {string} userId - 用户ID
|
* @param {string} picPath - 图片路径
|
* @returns {boolean} 是否注册成功
|
*/
|
registerFaceByPicFile: function (userId, picPath) {
|
return face.registerFaceByPicFile(userId, picPath)
|
},
|
|
/**
|
* 清空人脸数据
|
* @returns {boolean} 是否清空成功
|
*/
|
clean: function () {
|
// 清空人脸，需要在初始化人脸组件之前才能执行，否则报错
|
face.faceFeaturesClean()
|
common.systemBrief("rm -rf /app/data/db/face.db")
|
return !std.exist("/app/data/db/face.db")
|
},
|
|
/**
|
* 删除指定用户的人脸数据
|
* @param {string} userId - 用户ID
|
* @returns {boolean} 是否删除成功
|
*/
|
delete: function (userId) {
|
return face.deleteFaceFeatures(userId)
|
},
|
|
/**
|
* 设置屏幕状态
|
* @param {boolean} status - 是否启用屏幕
|
*/
|
screenStatus: function (status) {
|
if (status) {
|
face.setPowerMode(0)
|
} else {
|
face.setPowerMode(1)
|
}
|
face.setEnableStatus(status)
|
},
|
|
/**
|
* 将文件转换为base64编码
|
* @param {string} filePath - 文件路径
|
* @returns {string} Base64编码的文件内容
|
*/
|
fileToBase64: function (filePath) {
|
function fileToUint8Array(filename) {
|
// 读取文件
|
const file = std.open(filename, "rb");
|
if (!file) {
|
throw new Error("无法打开文件");
|
}
|
|
// 获取文件大小
|
const size = std.seek(file, 0, std.SEEK_END)
|
std.seek(file, 0, std.SEEK_SET)
|
|
// 检查文件大小是否有效
|
if (size <= 0) {
|
std.close(file);
|
throw new Error("文件大小无效");
|
}
|
|
// 创建 ArrayBuffer 并读取文件内容
|
const buffer = new ArrayBuffer(size);
|
const array = new Uint8Array(buffer);
|
std.read(file, array.buffer, 0, size);
|
|
std.close(file);
|
|
return array;
|
}
|
|
try {
|
// 检查文件路径是否存在
|
if (!filePath) {
|
throw new Error("文件路径为空");
|
}
|
const data = fileToUint8Array(filePath);
|
return base64.fromUint8Array(data);
|
} catch (error) {
|
logger.info("文件转Base64失败: " + error.message);
|
return "";
|
}
|
}
|
}
|
|
/**
|
* 网络驱动模块
|
* 负责网络连接和管理
|
*/
|
driver.net = {
|
/**
|
* 初始化网络
|
* 初始化网络模块，设置网络配置
|
*/
|
init: function () {
|
let dns = config.get("net.dns").split(",")
|
let option = {
|
type: config.get("net.type"),
|
dhcp: config.get("net.dhcp"),
|
ip: config.get("net.ip"),
|
gateway: config.get("net.gateway"),
|
netmask: config.get("net.mask"),
|
dns0: dns[0],
|
dns1: dns[1],
|
macAddr: common.getUuid2mac()
|
}
|
logger.info("更新联网配置：", JSON.stringify(option));
|
net.worker.beforeLoop(option)
|
config.set("net.mac", common.getUuid2mac())
|
if (config.get("net.type") == 2) {
|
//wifi取配置文件去连接
|
let ssid = utils.isEmpty(config.get('net.ssid')) ? "ssid" : config.get('net.ssid')
|
let psk = utils.isEmpty(config.get('net.psk')) ? "psk" : config.get('net.psk')
|
driver.net.netConnectWifiSsid(ssid, psk)
|
}
|
// 解决网络切换状态不对
|
std.setInterval(() => {
|
let status = net.getStatus()
|
if (status.status != map.get("NET").get("status")) {
|
status.type = config.get("net.type")
|
bus.fire(net.STATUS_CHANGE, status)
|
}
|
}, 1000)
|
},
|
|
/**
|
* 切换网络类型
|
* 切换网络类型并配置相应的网络参数
|
*/
|
changeNetType: function () {
|
// 加锁
|
if (map.get("NET").get("changeType") == "Y") {
|
return
|
}
|
map.get("NET").put("changeType", "Y")
|
let type = config.get("net.type")
|
logger.info("切换网络", type);
|
[1, 2, 4].filter(v => v != type).forEach(v => {
|
logger.info("关闭网卡", v, net.cardEnable(v, false));
|
})
|
logger.info("设置主网卡", type, net.setMasterCard(type));
|
logger.info("开启网卡", type, net.cardEnable(type, true));
|
if (type == 2) {
|
//wifi取配置文件去连接
|
let ssid = utils.isEmpty(config.get('net.ssid')) ? "ssid" : config.get('net.ssid')
|
let psk = utils.isEmpty(config.get('net.psk')) ? "psk" : config.get('net.psk')
|
logger.info("连接wifi", ssid, psk);
|
net.netConnectWifiSsid(ssid, psk)
|
|
// 等待WiFi连接成功后再设置网络模式
|
std.setTimeout(() => {
|
let dns = config.get("net.dns").split(",")
|
net.setModeByCard(type, config.get("net.dhcp"), config.get("net.dhcp") == 1 ? {
|
ip: config.get("net.ip"),
|
gateway: config.get("net.gateway"),
|
netmask: config.get("net.mask"),
|
dns0: dns[0],
|
dns1: dns[1],
|
} : undefined)
|
}, 3000); // 等待3秒让WiFi连接成功
|
} else if (type == 1) {
|
// 以太网直接设置网络模式
|
let dns = config.get("net.dns").split(",")
|
net.setModeByCard(type, config.get("net.dhcp"), config.get("net.dhcp") == 1 ? {
|
ip: config.get("net.ip"),
|
gateway: config.get("net.gateway"),
|
netmask: config.get("net.mask"),
|
dns0: dns[0],
|
dns1: dns[1],
|
} : undefined)
|
}
|
map.get("NET").del("changeType")
|
},
|
|
/**
|
* 初始化EID网络
|
* 退出网络并重启相关服务
|
*/
|
eidInit: function () {
|
net.exit();
|
common.systemWithRes(`pkill -9 -f 'wpa_supplicant|udhcpc'`, 5)
|
},
|
|
/**
|
* 获取网络状态
|
* @returns {boolean} 是否连接成功
|
*/
|
getStatus: function () {
|
let status = net.getStatus()
|
if (status.connected == true && status.status == 4) {
|
return true
|
} else {
|
return false
|
}
|
|
},
|
|
/**
|
* 连接WiFi
|
* @param {string} ssid - WiFi名称
|
* @param {string} psk - WiFi密码
|
*/
|
netConnectWifiSsid: function (ssid, psk) {
|
net.netConnectWifiSsid(ssid, psk, "")
|
},
|
|
/**
|
* 获取WiFi列表
|
* @returns {array} WiFi列表
|
*/
|
netGetWifiSsidList: function () {
|
if (!driver.net.getStatus()) {
|
//如果 wifi 连接失败 获取列表会失败需要先销毁
|
net.netDisconnetWifi()
|
}
|
let result = net.netGetWifiSsidList(1000, 5)
|
if (!result || !result.results || result.results.length === 0) {
|
return [];
|
}
|
let wifiList = []; // 初始化wifiList为数组
|
result.results.forEach(element => wifiList.push(element.ssid)); // 使用push方法添加ssid到数组
|
return wifiList;
|
},
|
|
/**
|
* 重置网卡
|
*/
|
cardReset: function () {
|
// net.netCardReset(2,1)
|
},
|
|
/**
|
* 网络循环
|
* 执行网络的循环操作
|
*/
|
loop: function () {
|
net.worker.loop()
|
}
|
}
|
|
/**
|
* NTP驱动模块
|
* 负责网络时间同步
|
*/
|
driver.ntp = {
|
/**
|
* NTP循环
|
* 初始化NTP模块并执行时间同步操作
|
*/
|
loop: function () {
|
// 每秒钟判断时间，如果时差大于2秒则进行了对时
|
let last = new Date().getTime()
|
dxMap.get("NTP_SYNC").put("syncTime", last)
|
std.setInterval(() => {
|
let now = new Date().getTime()
|
let diff = now - last
|
if (diff > 2000) {
|
dxMap.get("NTP_SYNC").put("syncTime", now)
|
last = now
|
}
|
}, 1000)
|
|
ntp.beforeLoop(config.get("ntp.server"), 9999999999999)
|
this.ntpHour = config.get('ntp.hour')
|
this.flag = true
|
driver.ntp.loop = () => {
|
if (config.get("ntp.ntp")) {
|
ntp.loop()
|
if (new Date().getHours() == this.ntpHour && this.flag) {
|
// 定时同步，立即同步一次时间
|
ntp.syncnow = true
|
this.flag = false
|
}
|
if (new Date().getHours() != this.ntpHour) {
|
// 等过了这个小时再次允许对时
|
this.flag = true
|
}
|
}
|
}
|
}
|
}
|
/**
|
* 同步驱动模块
|
* 提供异步转同步的实现
|
*/
|
driver.sync = {
|
/**
|
* 异步转同步请求
|
* @param {string} topic - 主题
|
* @param {number} timeout - 超时时间（毫秒）
|
* @returns {any} 响应数据
|
*/
|
request: function (topic, timeout) {
|
let map = dxMap.get("SYNC")
|
let count = 0
|
let data = map.get(topic)
|
while (utils.isEmpty(data) && count * 10 < timeout) {
|
data = map.get(topic)
|
std.sleep(10)
|
count += 1
|
}
|
let res = map.get(topic)
|
map.del(topic)
|
return res
|
},
|
|
/**
|
* 同步响应
|
* @param {string} topic - 主题
|
* @param {any} data - 响应数据
|
*/
|
response: function (topic, data) {
|
let map = dxMap.get("SYNC")
|
map.put(topic, data)
|
}
|
}
|
/**
|
* MQTT驱动模块
|
* 负责MQTT通信和消息处理
|
*/
|
driver.mqtt = {
|
/**
|
* 初始化MQTT
|
* 初始化MQTT模块，设置连接参数
|
*/
|
init: function () {
|
mqtt.run({ mqttAddr: config.get("mqtt.addr"), clientId: config.get('mqtt.clientId'), subs: mqttService.getTopics(), username: config.get("mqtt.username"), password: config.get("mqtt.password"), qos: config.get("mqtt.qos"), willTopic: config.get("mqtt.willTopic"), willMessage: JSON.stringify({ "uuid": config.get("sys.uuid") }) })
|
},
|
|
/**
|
* 初始化EID的MQTT
|
* 销毁MQTT连接
|
*/
|
eidInit: function () {
|
mqtt.destroy()
|
},
|
|
/**
|
* 发送MQTT消息
|
* @param {string} topic - 消息主题
|
* @param {any} payload - 消息载荷
|
*/
|
send: function (topic, payload,) {
|
logger.info("[driver.mqtt] send :", topic)
|
mqtt.send(topic, payload)
|
},
|
|
/**
|
* 获取在线检查
|
* @returns {any} 在线检查结果
|
*/
|
getOnlinecheck: function () {
|
let timeout = config.get("mqtt.timeout")
|
timeout = utils.isEmpty(timeout) ? 2000 : timeout
|
return driver.sync.request("mqtt.getOnlinecheck", timeout)
|
},
|
|
/**
|
* 在线检查回复
|
* @param {any} data - 回复数据
|
*/
|
getOnlinecheckReply: function (data) {
|
driver.sync.response("mqtt.getOnlinecheck", data)
|
},
|
|
/**
|
* 获取MQTT连接状态
|
* @returns {boolean} 是否连接成功
|
*/
|
getStatus: function () {
|
return mqtt.isConnected()
|
},
|
|
/**
|
* MQTT心跳
|
* 发送心跳消息，保持连接
|
*/
|
heartbeat: function () {
|
if (utils.isEmpty(this.heart_en)) {
|
let heart_en = config.get('sys.heart_en')
|
this.heart_en = utils.isEmpty(heart_en) ? 0 : heart_en
|
let heart_time = config.get('sys.heart_time')
|
this.heart_time = utils.isEmpty(heart_time) ? 30 : heart_time < 30 ? 30 : heart_time
|
}
|
if (utils.isEmpty(this.lastHeartbeat)) {
|
this.lastHeartbeat = 0
|
}
|
if (this.heart_en === 1 && (new Date().getTime() - this.lastHeartbeat >= (this.heart_time * 1000))) {
|
this.lastHeartbeat = new Date().getTime()
|
driver.mqtt.send("access_device/v2/event/heartbeat", JSON.stringify(mqttService.mqttReply(std.genRandomStr(10), undefined, mqttService.CODE.S_000)))
|
}
|
}
|
}
|
|
/**
|
* GPIO驱动模块
|
* 负责GPIO设备的控制，主要是继电器控制
|
*/
|
driver.gpio = {
|
/**
|
* 初始化GPIO
|
* 初始化GPIO模块并请求继电器引脚
|
*/
|
init: function () {
|
gpio.init()
|
gpio.request(dxDriver.GPIO.RELAY0)
|
},
|
|
/**
|
* 打开继电器
|
* 打开继电器并在指定时间后自动关闭
|
*/
|
open: function () {
|
logger.info("[GPIO]: 打开继电器")
|
let result = gpio.setValue(dxDriver.GPIO.RELAY0, 1);
|
logger.info("[GPIO]: 打开继电器结果: " + result)
|
|
let relayTime = config.get("access.relayTime")
|
|
std.setTimeout(() => {
|
logger.info("[GPIO]: 关闭继电器")
|
let closeResult = gpio.setValue(dxDriver.GPIO.RELAY0, 0);
|
logger.info("[GPIO]: 关闭继电器结果: " + closeResult)
|
}, relayTime)
|
},
|
|
/**
|
* 关闭继电器
|
* 立即关闭继电器
|
*/
|
close: function () {
|
gpio.setValue(dxDriver.GPIO.RELAY0, 0)
|
}
|
}
|
|
/**
|
* UART485驱动模块
|
* 负责UART485通信
|
*/
|
driver.uart485 = {
|
/**
|
* UART485 ID
|
*/
|
id: 'uart485',
|
|
/**
|
* 初始化UART485
|
* 初始化UART485模块并设置通信参数
|
*/
|
init: function () {
|
dxUart.runvg({ id: this.id, type: dxUart.TYPE.UART, path: '/dev/ttySLB2', result: 0, passThrough: false })
|
std.sleep(2000)
|
dxUart.ioctl(6, '115200-8-N-1', this.id)
|
},
|
|
/**
|
* 控制UART485
|
* @param {string} data - 控制数据
|
*/
|
ioctl: function (data) {
|
dxUart.ioctl(6, data, this.id)
|
},
|
|
/**
|
* 发送数据
|
* @param {string} data - 要发送的数据
|
*/
|
send: function (data) {
|
dxUart.send(data, this.id)
|
},
|
|
/**
|
* 发送VG数据
|
* @param {object|string} data - 要发送的数据
|
*/
|
sendVg: function (data) {
|
if (typeof data == 'object') {
|
data.length = data.length ? data.length : (data.data ? data.data.length / 2 : 0)
|
}
|
dxUart.sendVg(data, this.id)
|
}
|
}
|
|
/**
|
* UARTCode驱动模块
|
* 负责UART条码扫描通信
|
*/
|
driver.uartCode = {
|
/**
|
* UARTCode ID
|
*/
|
id: 'uartCode',
|
|
/**
|
* 初始化UARTCode
|
* 初始化UARTCode模块并设置通信参数
|
*/
|
init: function () {
|
dxUart.runvg({ id: this.id, type: dxUart.TYPE.UART, path: '/dev/ttySLB1', result: 0, passThrough: false })
|
std.sleep(500)
|
dxUart.ioctl(6, '115200-8-N-1', this.id)
|
},
|
|
/**
|
* 控制UARTCode
|
* @param {string} data - 控制数据
|
*/
|
ioctl: function (data) {
|
dxUart.ioctl(6, data, this.id)
|
},
|
|
/**
|
* 发送数据
|
* @param {string} data - 要发送的数据
|
*/
|
send: function (data) {
|
dxUart.send(data, this.id)
|
},
|
|
/**
|
* 发送VG数据
|
* @param {object|string} data - 要发送的数据
|
*/
|
sendVg: function (data) {
|
if (typeof data == 'object') {
|
data.length = data.length ? data.length : (data.data ? data.data.length / 2 : 0)
|
}
|
dxUart.sendVg(data, this.id)
|
},
|
}
|
|
/**
|
* EID驱动模块
|
* 负责电子身份证相关操作
|
*/
|
driver.eid = {
|
/**
|
* EID ID
|
*/
|
id: "eid",
|
|
/**
|
* 激活EID
|
* @param {string} sn - 设备SN
|
* @param {string} version - 版本号
|
* @param {string} mac - MAC地址
|
* @param {string} codeMsg - 激活码
|
* @returns {boolean} 是否激活成功
|
*/
|
active: function (sn, version, mac, codeMsg) {
|
return eid.active(sn, version, mac, codeMsg)
|
},
|
|
/**
|
* 获取EID版本
|
* @returns {string} EID版本
|
*/
|
getVerion: function () {
|
return eid.getVersion()
|
}
|
}
|
/**
|
* GPIO按键驱动模块
|
* 负责GPIO按键的初始化和循环处理
|
*/
|
driver.gpiokey = {
|
/**
|
* 初始化GPIO按键
|
* 初始化GPIO按键模块
|
*/
|
init: function () {
|
dxGpioKey.worker.beforeLoop()
|
},
|
|
/**
|
* GPIO按键循环
|
* 执行GPIO按键的循环操作
|
*/
|
loop: function () {
|
dxGpioKey.worker.loop()
|
},
|
}
|
/**
|
* 看门狗驱动模块
|
* 负责系统看门狗的初始化和喂狗操作
|
*/
|
driver.watchdog = {
|
/**
|
* 初始化看门狗
|
* 初始化看门狗模块
|
*/
|
init: function () {
|
// watchdog.open(1)
|
// watchdog.enable(1)
|
// watchdog.start(20000)
|
},
|
|
/**
|
* 看门狗循环
|
* 执行看门狗的循环操作
|
*/
|
loop: function () {
|
// watchdog.loop(1)
|
},
|
|
/**
|
* 喂狗
|
* 向看门狗发送喂狗信号，防止系统重启
|
* @param {string} flag - 喂狗标志
|
* @param {number} timeout - 超时时间
|
*/
|
feed: function (flag, timeout) {
|
// if (utils.isEmpty(this["feedTime" + flag]) || new Date().getTime() - this["feedTime" + flag] > 2000) {
|
// // 降低喂狗频率，间隔2秒喂一次
|
// this["feedTime" + flag] = new Date().getTime()
|
// watchdog.feed(flag, timeout)
|
// }
|
}
|
}
|
|
/**
|
* 自动重启驱动模块
|
* 负责系统的自动重启功能
|
*/
|
driver.autoRestart = {
|
/**
|
* 上次重启检查的小时数
|
*/
|
lastRestartCheck: new Date().getHours(), // 初始化为当前小时数，而不是0
|
|
/**
|
* 初始化自动重启
|
* 初始化自动重启模块，设置定时重启功能
|
*/
|
init: function () {
|
// std.setInterval(() => { // 检查是否需要整点重启
|
// const now = new Date()
|
// const currentHour = now.getHours()
|
// // 只有当小时数等于设定值，且不是上次检查过的小时时才执行
|
// if (currentHour === 3 && currentHour !== this.lastRestartCheck && now.getMinutes() === 0) {
|
// common.systemBrief('reboot')
|
// }
|
// // 更新上次检查的小时数
|
// this.lastRestartCheck = currentHour
|
// }, 60000)
|
}
|
}
|
|
export default driver
|
