import logger from "../dxmodules/dxLogger.js"
|
import std from '../dxmodules/dxStd.js'
|
import bus from "../dxmodules/dxEventBus.js"
|
import dxos from '../dxmodules/dxOs.js'
|
import config from '../dxmodules/dxConfig.js'
|
import dxMap from '../dxmodules/dxMap.js'
|
import dxFacial from '../dxmodules/dxFacial.js'
|
import dxCapcal from '../dxmodules/dxCapcal.js'
|
import dxCamera from '../dxmodules/dxCamera.js'
|
import audio from '../dxmodules/dxAudio.js'
|
import fingerMz from '../dxmodules/dxFingerMz.js'
|
import fingerZaz from '../dxmodules/dxFingerZaz.js'
|
import pwm from '../dxmodules/dxPwm.js'
|
import ntp from '../dxmodules/dxNtp.js'
|
import gpio from "../dxmodules/dxGpio.js"
|
import dxNfcCard from "../dxmodules/dxNfcCard.js"
|
import watchdog from "../dxmodules/dxWatchdog.js"
|
import dxGpioKey from "../dxmodules/dxGpioKey.js"
|
import net from "../dxmodules/dxNetwork.js"
|
import dxDriver from "../dxmodules/dxDriver.js"
|
import dxDisplay from "../dxmodules/dxDisplay.js"
|
import sqliteService from "./service/sqliteService.js"
|
import mqttService from "./service/mqttService.js"
|
import mqtt from '../dxmodules/dxMqttClient.js'
|
import dxVgCode from './common/utils/codeUtils.js'
|
import dxUartBle from '../dxmodules/dxVgBle.js'
|
import utils from "./common/utils/utils.js"
|
import common from "../dxmodules/dxCommon.js"
|
|
const driver = {}
|
|
driver.config = {
|
init: function () {
|
config.init()
|
let mac = dxos.getUuid2mac(19)
|
let uuid = dxos.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)
|
}
|
if (driver.device.finger) {
|
if (dxDriver.DRIVER.MODEL == "vf105") {
|
config.set('sys.model', "vf107")
|
} else if (dxDriver.DRIVER.MODEL == "vf114") {
|
config.set('sys.model', "vf124")
|
}
|
} else {
|
config.set('sys.model', dxDriver.DRIVER.MODEL)
|
}
|
//初始化语言判断国内版本还是国外版本
|
try {
|
const language = std.loadFile('/etc/app/region.conf')?.trim();
|
const defaultLanguage = "CN";
|
|
if (language === "INTL") {
|
if (config.get('base.language') == "CN") {
|
config.set('base.language', "EN")
|
}
|
} else {
|
// 包括 CN、空文件、读取失败等情况都使用默认语言
|
config.set('base.language', defaultLanguage);
|
}
|
} catch (error) {
|
config.set('base.language', "CN");
|
}
|
config.save()
|
}
|
}
|
|
driver.screen = {
|
accessFail: function () {
|
bus.fire('accessRes', false)
|
},
|
accessSuccess: function () {
|
bus.fire('accessRes', true)
|
},
|
upgrade: function (data) {
|
bus.fire('upgrade', data)
|
},
|
getCard: function (card) {
|
let language = config.get("base.language") || "CN";
|
driver.audio.play(`/app/code/resource/wav/${language}/read.wav`)
|
bus.fire('getCard', card)
|
},
|
hideSn: function (data) {
|
bus.fire('hideSn', data)
|
},
|
appMode: function (data) {
|
bus.fire('appMode', data)
|
},
|
hideIp: function (data) {
|
bus.fire('hideIp', data)
|
},
|
changeLanguage: function () {
|
bus.fire('changeLanguage')
|
},
|
reload: function () {
|
bus.fire('reload')
|
},
|
error: function (msg) {
|
bus.fire('showMessage', { status: false, msg: msg })
|
},
|
success: function (msg) {
|
bus.fire('showMessage', { status: true, msg: msg })
|
},
|
}
|
|
driver.sqlite = {
|
DB_PATH: '/data/db/app.db',
|
init: function () {
|
std.ensurePathExists(driver.sqlite.DB_PATH)
|
sqliteService.init(driver.sqlite.DB_PATH)
|
}
|
}
|
|
driver.pwm = {
|
init: function () {
|
let nirLuminance = config.get("base.nirBrightness")
|
let whiteLuminance = config.get("base.brightness")
|
if (dxDriver.DRIVER.MODEL == "vf203") {
|
pwm.init(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL);
|
pwm.setPower(nirLuminance, dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL);
|
} else if (dxDriver.DRIVER.MODEL == "vf202" || dxDriver.DRIVER.MODEL == "vf114" || dxDriver.DRIVER.MODEL == "vf105") {
|
pwm.init(dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL);
|
pwm.init(dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL);
|
pwm.setPower(whiteLuminance, dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL);
|
pwm.setPower(nirLuminance, dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL);
|
}
|
},
|
setWhitePower: function (whiteLuminance) {
|
pwm.setPower(whiteLuminance, dxDriver.PWM.WHITE_SUPPLEMENT_CHANNEL);
|
},
|
setNirPower: function (nirLuminance) {
|
pwm.setPower(nirLuminance, dxDriver.PWM.NIR_SUPPLEMENT_CHANNEL);
|
}
|
}
|
|
driver.audio = {
|
init: function () {
|
audio.init();
|
audio.setVolume(config.get("base.volume"))
|
},
|
play: function (src) {
|
audio.play(src)
|
},
|
ttsPlay: function (text) {
|
let type = config.get("base.language") == "CN" ? 0 : 1
|
audio.playTxt(text, type)
|
},
|
volume: function (volume) {
|
if (volume === undefined || volume === null) {
|
return audio.getVolume()
|
} else if (volume < 0 || volume > 10) {
|
throw new Error('输入值必须在0到10之间');
|
} else {
|
audio.setVolume(volume)
|
}
|
},
|
interrupt: function () {
|
audio.interrupt()
|
},
|
clearCache: function () {
|
audio.clearCache()
|
}
|
}
|
|
driver.nfc = {
|
NFC_CARD_RECEIVE: "nfcCardReceive",
|
EID_RECEIVE: "eidReceive",
|
init: function () {
|
dxNfcCard.init();
|
},
|
eidInit: function () {
|
try {
|
dxNfcCard.eidInit({ config: {
|
device_model: dxDriver.DRIVER.MODEL
|
} })
|
} catch (error) {
|
logger.error(error)
|
}
|
},
|
eidActive: function (code) {
|
const options = {
|
codeMsg: code,
|
version: config.get("sys.appVersion"),
|
macAddr: config.get("sys.mac")
|
};
|
return dxNfcCard.eidActive(options);
|
},
|
getConfig: function () {
|
return dxNfcCard.getConfig();
|
},
|
setConfig: function (options) {
|
dxNfcCard.updateConfig(options);
|
},
|
setCallbacks: function (callbacks) {
|
dxNfcCard.setCallbacks(callbacks);
|
},
|
loop: function () {
|
dxNfcCard.loop();
|
},
|
}
|
|
|
driver.face = {
|
options: {
|
det_max: 1,
|
liv_threshold: 5,
|
rec_timeout_ms: 5000,
|
det_timeout_ms: 100000,
|
nir: {
|
preview_width: dxDriver.DISPLAY.WIDTH * (120 / 600),
|
preview_height: dxDriver.DISPLAY.HEIGHT * (150 / 1024),
|
preview_top: dxDriver.DISPLAY.HEIGHT * (60 / 1024),
|
}
|
},
|
init: function () {
|
this.options.com_threshold = config.get("face.similarity")
|
this.options.liv_enable = config.get("face.livenessOff")
|
this.options.liv_threshold = config.get("face.livenessVal")
|
this.options.det_timeout_ms = config.get("face.recheck") === 1 ? 8000 : 100000
|
dxFacial.init(this.options);
|
// 默认关闭红外摄像头预览
|
this.capPreviewEnable(config.get("face.showNir"))
|
},
|
capPreviewEnable: function (enable) {
|
dxCamera.capPreviewEnable(1, enable);
|
},
|
getTrackingBox: function () {
|
let data = dxFacial.getDetectionData();
|
// data.push({ "id": 100, "status": 0, "rect": [20, 232, 110, 353], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 99, "status": 0, "rect": [81, 519, 180, 649], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 98, "status": 0, "rect": [110, 369, 207, 498], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 97, "status": 0, "rect": [159, 249, 257, 377], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 96, "status": 0, "rect": [196, 215, 296, 345], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 95, "status": 0, "rect": [240, 208, 340, 341], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 94, "status": 0, "rect": [303, 242, 403, 372], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 93, "status": 0, "rect": [354, 317, 456, 446], "qualityScore": 30, "livingScore": 0 })
|
// data.push({ "id": 92, "status": 0, "rect": [306, 603, 376, 710], "qualityScore": 30, "livingScore": 0 })
|
return data
|
},
|
status: function (flag) {
|
dxFacial.setStatus(flag);
|
},
|
setCallbacks: function (callbacks) {
|
dxFacial.setCallbacks(callbacks);
|
},
|
loop: function () {
|
dxFacial.loop();
|
},
|
// 配置管理
|
setConfig: function (options) {
|
dxFacial.setConfig(options);
|
},
|
getConfig: function () {
|
return dxFacial.getConfig();
|
},
|
// 特征值管理
|
getFeaByCap: function (timeout) {
|
return dxFacial.getFeaByCap(timeout);
|
},
|
getFeaByFile: function (picPath) {
|
return dxFacial.getFeaByFile(picPath);
|
},
|
addFea: function (userId, feature) {
|
try {
|
let ret = dxFacial.addFea(userId, feature)
|
return ret;
|
} catch (error) {
|
logger.error(error)
|
return error.message;
|
}
|
|
// TODO 这个逻辑很奇怪，异常没有抛上去，必须try catch return
|
// logger.info("addFea start", userId, feature)
|
// let ret = dxFacial.addFea(userId, feature)
|
// logger.info("addFea ret", ret)
|
// return ret;
|
},
|
updateFea: function (userId, feature) {
|
try {
|
return dxFacial.updateFea(userId, feature);
|
} catch (error) {
|
logger.error(error)
|
return error.message;
|
}
|
},
|
clean: function () {
|
return dxFacial.cleanFea()
|
},
|
deleteFea: function (userId) {
|
return dxFacial.deleteFea(userId)
|
},
|
}
|
|
driver.display = {
|
setBacklight: function (backlight) {
|
dxDisplay.setBacklight(backlight)
|
},
|
}
|
|
driver.capcal = {
|
init: function () {
|
dxCapcal.init()
|
},
|
deinit: function () {
|
dxCapcal.deinit()
|
},
|
calculate: function (cnt) {
|
return dxCapcal.calculate(cnt)
|
},
|
getBox: function (cnt) {
|
return dxCapcal.getBox(cnt)
|
}
|
}
|
|
driver.ntp = {
|
init: function () {
|
if (!config.get("ntp.ntp")) {
|
let time = config.get('sys.time')
|
if (time) {
|
this.setTime(time)
|
}
|
} else {
|
ntp.startSync(config.get("ntp.server"))
|
}
|
},
|
setTime: function (timestamp) {
|
ntp.setTime(utils.formatUnixTimestamp(timestamp), true)
|
}
|
}
|
|
driver.uartBle = {
|
init: function () {
|
dxUartBle.init()
|
let bleKey = config.get("sys.bleKey") || "01234567890123456789012345678901"
|
dxUartBle.slave.setConfig(bleKey)
|
},
|
setCallbacks: function (callbacks) {
|
dxUartBle.slave.setCallbacks(callbacks)
|
},
|
loop: function () {
|
dxUartBle.loop()
|
},
|
send: function (data) {
|
let connId = dxMap.get("connId").get("connId")
|
if (connId) {
|
dxUartBle.slave.sendMessage(data, connId)
|
}
|
}
|
}
|
|
driver.uartCode = {
|
RECEIVE_MSG: '__UART_RECEIVE_MSG__',
|
init: function () {
|
if (dxDriver.DRIVER.MODEL == 'vf105') {
|
dxVgCode.init('/dev/ttySLB1', '115200-8-N-1')
|
} else if (dxDriver.DRIVER.MODEL == 'vf114') {
|
dxVgCode.init('/dev/ttySLB3', '115200-8-N-1')
|
}
|
},
|
setCallbacks: function (callbacks) {
|
dxVgCode.setCallbacks(callbacks)
|
},
|
loop: function () {
|
dxVgCode.loop()
|
}
|
}
|
|
driver.sync = {
|
// 异步转同步实现优化
|
request: function (topic, timeout = 2000) {
|
const map = dxMap.get("SYNC");
|
// 并发重复topic丢弃
|
if (map.get(topic)) {
|
logger.error("当前已有相同的topic正在等待，请稍后再试")
|
return;
|
}
|
map.put(topic, "waiting");
|
const interval = 10;
|
const maxCount = Math.ceil(timeout / interval);
|
let count = 0;
|
let data = "waiting";
|
while (count < maxCount) {
|
data = map.get(topic);
|
if (data !== "waiting") break;
|
std.sleep(interval);
|
count++;
|
}
|
// 只有在不是"waiting"时才返回data，否则返回undefined
|
map.del(topic);
|
if (data === "waiting" || data === undefined) {
|
return;
|
}
|
return data;
|
},
|
response: function (topic, data) {
|
const map = dxMap.get("SYNC");
|
// 只有在topic为"waiting"时才允许响应
|
if (map.get(topic) !== "waiting") {
|
logger.error("没有正在等待的topic，禁止回复")
|
return;
|
}
|
map.put(topic, data);
|
}
|
}
|
|
driver.net = {
|
RECONNECT: "__NET_RECONNECT__",
|
SCAN_WIFI: "__NET_SCAN_WIFI__",
|
WIFI_LIST: "__NET_WIFI_LIST__",
|
CONNECTED_CHANGED: "__NET_CONNECTED_CHANGED__",
|
init: () => {
|
bus.newWorker('netWorker', '/app/code/src/worker/netWorker.js')
|
},
|
reconnect: () => {
|
bus.fire(driver.net.RECONNECT)
|
},
|
getNetParam: net.getNetParam,
|
isConnected: net.isConnected,
|
getNetMac: net.getNetMac
|
}
|
|
driver.mqtt = {
|
REINIT: "__MQTT_REINIT__",
|
SEND_MSG: "__MQTT_SEND_MSG__",
|
RECEIVE_MSG: "__MQTT_RECEIVE_MSG__",
|
CONNECTED_CHANGED: "__MQTT_CONNECTED_CHANGED__",
|
RESTART_HEARTBEAT: "__MQTT_RESTART_HEARTBEAT__",
|
init: () => {
|
bus.newWorker('mqttWorker', '/app/code/src/worker/mqttWorker.js')
|
},
|
reinit: () => {
|
// 重连mqtt，针对换了mqtt连接信息时需要执行，没换不用重连
|
bus.fire(driver.mqtt.REINIT)
|
},
|
send: function (topic, payload) {
|
bus.fire(driver.mqtt.SEND_MSG, {
|
topic, payload
|
})
|
},
|
// 修改了心跳相关配置需要重启心跳定时器，调这个
|
restartHeartbeat: () => {
|
bus.fire(driver.mqtt.RESTART_HEARTBEAT)
|
},
|
isConnected: () => {
|
return mqtt.getNative() && mqtt.isConnected()
|
},
|
}
|
|
driver.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")
|
// 确保 relayTime 是一个有效的数字，默认为 10 秒
|
if (!relayTime || isNaN(relayTime)) {
|
relayTime = 10
|
} else {
|
relayTime = parseInt(relayTime)
|
}
|
logger.info("[GPIO]: 继电器延时关闭时间: " + relayTime + "秒")
|
|
std.setTimeout(() => {
|
logger.info("[GPIO]: 关闭继电器")
|
let closeResult = gpio.setValue(dxDriver.GPIO.RELAY0, 0);
|
logger.info("[GPIO]: 关闭继电器结果: " + closeResult)
|
}, relayTime * 1000)
|
},
|
/**
|
* 关闭继电器
|
* 立即关闭继电器
|
*/
|
close: function () {
|
gpio.setValue(dxDriver.GPIO.RELAY0, 0)
|
},
|
setValue: function (value) {
|
if (config.get("access.fireStatus") === 0) {
|
gpio.setValue(dxDriver.GPIO.RELAY0, value)
|
}
|
}
|
}
|
|
driver.gpiokey = {
|
RECEIVE_MSG: "__GPIOKEY_RECEIVE_MSG__",
|
TYPE: {
|
DOOR_SENSOR: 0, // 门磁
|
FIRE_ALARM: 1, // 火警
|
TAMPER_ALARM: 2, // 防拆
|
},
|
VALUE: {
|
OPEN: 1, // 开
|
CLOSE: 0, // 关
|
},
|
init: function () {
|
dxGpioKey.init()
|
// 默认需要延续火警的状态
|
if (config.get("access.fire") == 1 && config.get("access.fireStatus") == 1) {
|
std.setTimeout(() => {
|
bus.fire(driver.gpiokey.RECEIVE_MSG, { code: 1, value: 1 })
|
}, 5000)
|
}
|
},
|
sensorChanged: function (type, value) {
|
let prefix = config.get("mqttInfo.prefix") || ''
|
driver.mqtt.send(prefix + "access_device/v2/event/alarm", JSON.stringify(mqttService.mqttReply(std.genRandomStr(10), { type: type, value: value }, mqttService.CODE.S_000)))
|
},
|
loop: function () {
|
dxGpioKey.loop()
|
},
|
setCallbacks: function (callbacks) {
|
dxGpioKey.setCallbacks(callbacks);
|
},
|
statusConfig: function (fire) {
|
config.setAndSave("access.fire", fire)
|
if (fire === 0) {
|
// 从配置上关闭火警时，也需要把火警状态重置
|
config.setAndSave("access.fireStatus", 0)
|
// 关闭继电器
|
driver.gpio.close()
|
}
|
},
|
controlFire: function (fire) {
|
if (config.get("access.fire") == 1) {
|
if (fire == 1) {
|
// 火警触发
|
print('火警触发')
|
driver.gpio.open()
|
// 上报火警状态
|
bus.fire(driver.gpiokey.RECEIVE_MSG, { code: 1, value: 1 })
|
} else {
|
// 火警解除
|
print('火警解除')
|
// 从配置上关闭火警时，也需要把火警状态重置
|
config.setAndSave("access.fireStatus", 0)
|
// 关闭继电器
|
driver.gpio.close()
|
}
|
}
|
}
|
}
|
|
driver.finger = {
|
RECEIVE_MSG: "__FINGER_RECEIVE_MSG__",
|
flag: true,
|
// 指纹模块类型：根据设备型号选择（vf114 -> MZ，其它 -> ZAZ）
|
// 说明：driver.finger 对外统一为“0表示成功、非0表示失败；索引统一使用0-based”
|
_type: null, // 'mz' | 'zaz'
|
_impl: null, // fingerMz | fingerZaz
|
_total: 1024, // 统一对外的最大指纹数量
|
_isZaz: function () {
|
return (dxDriver.DRIVER.MODEL !== "vf114")
|
},
|
_ensureImpl: function () {
|
if (this._impl) return
|
if (this._isZaz()) {
|
this._type = "zaz"
|
this._impl = fingerZaz
|
this._total = 1024
|
} else {
|
this._type = "mz"
|
this._impl = fingerMz
|
this._total = 1024
|
}
|
},
|
_ok: function (bool) {
|
return bool ? 0 : -1
|
},
|
init: function () {
|
this._ensureImpl()
|
let options
|
if (this._type === "zaz") {
|
options = {
|
type: 3,
|
path: '/dev/ttySLB1',
|
baudrate: '115200-8-N-1'
|
}
|
} else {
|
options = {
|
id: 'fingerUart',
|
total: this._total,
|
timeout: 500,
|
type: '3',
|
path: '/dev/ttySLB0', //测试时是ttySLB0 生产时是ttySLB3替换的扫码模组
|
baudrate: '57600-8-N-2'
|
}
|
}
|
this._impl.init(options)
|
const statusMap = dxMap.get("FINGER_STATUS")
|
statusMap.put("status", "start")
|
this.controlLed("BLUE")
|
},
|
loop: function () {
|
const statusMap = dxMap.get("FINGER_STATUS")
|
// 检查是否正在进行指纹录入，如果是，则跳过指纹对比
|
const isFingerEntering = dxMap.get("UI") && dxMap.get("UI").get("isFingerEntering")
|
if(statusMap && statusMap.get("status") == "start" && !isFingerEntering){
|
try {
|
let index = driver.finger.compare(0, 1024)
|
if(index != -1 && index != -2){
|
bus.fire(driver.finger.RECEIVE_MSG, {type: 500, index: index})
|
}
|
} catch (error) {
|
// 指纹对比失败的错误日志可以忽略，因为这是正常的指纹验证失败情况
|
}
|
}
|
},
|
getIndex: function() {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
const ret = this._impl.getEmptyId(1, this._total)
|
return ret
|
}
|
return this._impl.getIndex()
|
},
|
getEnrollImage: function() {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
// ZAZ 无 enroll/verify 区分，复用 getImage
|
return this.getImage()
|
}
|
return this._impl.getEnrollImage()
|
},
|
getImage: function () {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
return this._ok(this._impl.getImage())
|
}
|
return this._impl.getImage()
|
},
|
start: function () {
|
const statusMap = dxMap.get("FINGER_STATUS")
|
statusMap.put("status", "start")
|
},
|
stop: function () {
|
const statusMap = dxMap.get("FINGER_STATUS")
|
statusMap.put("status", "stop")
|
std.sleep(200)
|
},
|
delete: function(fingerId) {
|
return this.deleteChar(fingerId, 1)
|
},
|
genChar: function(bufferId) {
|
try {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
// 移除多余的打印语句
|
return this._ok(this._impl.generate(bufferId - 1))
|
}
|
return this._impl.genChar(bufferId)
|
} catch (error) {
|
// 只在非录入状态下输出错误日志，避免录入过程中的冗余日志
|
const isFingerEntering = dxMap.get("UI") && dxMap.get("UI").get("isFingerEntering")
|
if (!isFingerEntering) {
|
logger.error("finger.genChar 生成特征失败: ", error.message)
|
}
|
return -1
|
}
|
},
|
regModel: function() {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
// 这里写死 (3, 0)，合并3个特征，并存储到索引0
|
return this._ok(this._impl.merge(3, 0))
|
}
|
return this._impl.regModel()
|
},
|
deleteChar: function(fingerId, num) {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
return this._ok(this._impl.delChar(fingerId, fingerId))
|
}
|
return this._impl.deletChar(fingerId, num)
|
},
|
upChar: function(bufferId = 1) {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
const hex = this._impl.upChar(bufferId - 1)
|
if (!hex) return null
|
// 统一返回 Uint8Array/ArrayBuffer 语义，供 common.arrayBufferToHexString 处理
|
return common.hexStringToArrayBuffer(hex)
|
}
|
return this._impl.upChar(bufferId)
|
},
|
loadChar: function(index, bufferId = 1) {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
return this._ok(this._impl.loadChar(index, bufferId - 1))
|
}
|
return this._impl.loadChar(bufferId, index)
|
},
|
downChar: function(char, bufferId = 1) {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
// ZAZ 接收 hex string
|
let hex
|
if (typeof char === "string") {
|
hex = char
|
} else if (char instanceof ArrayBuffer) {
|
hex = common.arrayBufferToHexString(char)
|
} else {
|
// Uint8Array / 其它 array-like
|
hex = common.uint8ArrayToHexString(new Uint8Array(char))
|
}
|
return this._ok(this._impl.downChar(bufferId - 1, hex))
|
}
|
// MZ 接收 ArrayBuffer/Uint8Array：如果传入的是 hex string，这里转成 Uint8Array
|
let payload = char
|
if (typeof char === "string") {
|
payload = common.hexStringToUint8Array(char)
|
}
|
return this._impl.downChar(bufferId, payload)
|
},
|
search: function(bufferId, index, num) {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
const found = this._impl.search(bufferId - 1, 1, 1024)
|
if (found === false || found === null || found === undefined) {
|
return { code: 1, pageIndex: -1, score: 0 }
|
}
|
return { code: 0, pageIndex: found, score: 100 }
|
}
|
return this._impl.search(bufferId, index, num)
|
},
|
storeChar: function(index, bufferId = 1) {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
// 参数顺序相反：keyId(index) + bufferNum(bufferId)
|
return this._ok(this._impl.storeChar(index, bufferId - 1))
|
}
|
return this._impl.storeChar(bufferId, index)
|
},
|
insert: function(char) {
|
this.stop()
|
print("finger.insert 插入指纹数据: ", char)
|
let res = this.downChar(char, 1)
|
if (res != 0) {
|
return -1
|
}
|
let index = this.getIndex()
|
logger.info("finger.insert 找到的第一个未使用的索引: ", index)
|
res = this.storeChar(index, 1)
|
this.start()
|
return index
|
},
|
clear: function() {
|
this._ensureImpl()
|
if (this._type === "zaz") {
|
return this._ok(this._impl.delChar(1, this._total))
|
}
|
return this._impl.clearChar()
|
},
|
// 指纹对比，返回对比到的索引和得分
|
compare: function(index = 0, num = 0){
|
// 1，发送获取图像指令
|
// 2，生成特征(bufferId默认为1)
|
// 3，指纹搜索(bufferId默认为1)
|
let res = this.getImage()
|
if(res != 0){
|
return -1
|
}
|
res = this.genChar(1)
|
if(res != 0){
|
logger.info("finger.search 生成特征失败!")
|
return -2
|
}
|
res = this.search(1, index, num)
|
if(res != null && res.code != null && res.code == 0){
|
logger.info("搜索到指纹、指纹验证成功、指纹索引：" + res.pageIndex + "，指纹得分: " + res.score)
|
logger.info("finger.search: ", JSON.stringify(res))
|
return res.pageIndex
|
}
|
return -3
|
},
|
controlLed: function (color) {
|
if (driver.device.finger && this._type === "mz") {
|
try {
|
std.sleep(500)
|
fingerMz.controlLed(fingerMz.LED_COLOR[color])
|
} catch (error) {
|
logger.info(error)
|
}
|
}
|
}
|
}
|
|
driver.device = {
|
model: dxDriver.DRIVER.MODEL,
|
// 是否支持指纹（通过 /app/finger 标志文件判断；仅检测一次）
|
finger: (() => {
|
try {
|
return std.exist("/etc/app/finger.conf")
|
} catch (e) {
|
logger.error("检测指纹能力失败: ", e)
|
return false
|
}
|
})(),
|
}
|
|
driver.watchdog = {
|
MAIN_WORKER: 1,
|
CONTROLLER_WORKER: 2,
|
init: function () {
|
watchdog.init()
|
this.enable(this.MAIN_WORKER, true)
|
this.start(30000)
|
},
|
enable: function (channel, enable) {
|
watchdog.enable(channel, enable)
|
},
|
start: function (timeout) {
|
watchdog.start(timeout)
|
},
|
stop: function () {
|
watchdog.stop()
|
},
|
restart: function (channel) {
|
watchdog.restart(channel)
|
},
|
}
|
|
export default driver
|
