import std from './dxStd.js'
|
import dxUart from './dxUart.js'
|
import dxCommon from './dxCommon.js'
|
import log from './dxLogger.js'
|
|
const dxFingerZaz = {}
|
|
let options = {
|
id : 'fingerUart',
|
total: 5000,
|
timeout : 500,
|
type : '3',
|
path : '/dev/ttySLB1',
|
baudrate : '115200-8-N-1'
|
}
|
|
|
/**
|
* 测试指纹模块命令
|
* @returns {boolean} 返回true表示测试成功，返回false表示测试失败
|
*/
|
dxFingerZaz.test = function () {
|
send({prefix: 0x55AA, cmd: 0x0100, data: ''})
|
let resp = receive({prefix: 0xAA55, cmd: 0x0100})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.test:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 获取指定编号范围内可注册的首个编号
|
* @param {number} startId - 起始编号
|
* @param {number} endId - 结束编号
|
* @returns {number} 返回空闲的指纹编号，返回false表示获取失败（失败原因可参考ret）
|
*/
|
dxFingerZaz.getEmptyId = function (startId, endId) {
|
if(startId === undefined || startId === null || startId < 1 || startId > options.total){
|
throw new Error("dxFingerZaz.getEmptyId: 'startId' parameter should be between 1 and " + options.total)
|
}
|
if(endId === undefined || endId === null || endId < 1 || endId > options.total){
|
throw new Error("dxFingerZaz.getEmptyId: 'endId' parameter should be between 1 and " + options.total)
|
}
|
|
let data = toEndianHexExtended(startId, 2) + toEndianHexExtended(endId, 2)
|
send({prefix: 0x55AA, cmd: 0x4500, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4500})
|
if(resp && resp.ret == 0x00){
|
return fromEndianHexExtended(resp.data, 2)
|
} else {
|
log.error("dxFingerZaz.getEmptyId:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 获取指定编号的模板注册状态
|
* @param {number} keyId - 指纹编号
|
* @returns {number} 返回0表示未注册，返回1表示已注册，返回false表示获取失败
|
*/
|
dxFingerZaz.getStatus = function (keyId) {
|
if (keyId === undefined || keyId === null) {
|
throw new Error("dxFingerZaz.getStatus: 'keyId' parameter should not be null or empty")
|
}
|
|
send({prefix: 0x55AA, cmd: 0x4600, data: toEndianHexExtended(keyId, 2)})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4600})
|
if(resp && resp.ret == 0x00){
|
return fromEndianHexExtended(resp.data, 1)
|
} else {
|
log.error("dxFingerZaz.getStatus:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 采集指纹图像
|
* @returns {boolean} 返回true表示采集成功，返回false表示采集失败（失败原因可参考ret）
|
*/
|
dxFingerZaz.getImage = function () {
|
send({prefix: 0x55AA, cmd: 0x2000, data: ""})
|
let resp = receive({prefix: 0xAA55, cmd: 0x2000})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
// log.error("dxFingerZaz.getImage:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 从暂存在ImageBuffer中的指纹图像产生模板
|
* @param {number} bufferNum - 指纹模板编号（0-2）
|
* @returns {boolean} 返回true表示生成成功，返回false表示生成失败（失败原因可参考ret）
|
*/
|
dxFingerZaz.generate = function (bufferNum) {
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.generate: 'bufferNum' parameter should be between 0 and 3")
|
}
|
send({prefix: 0x55AA, cmd: 0x6000, data: toEndianHexExtended(bufferNum, 2)})
|
let resp = receive({prefix: 0xAA55, cmd: 0x6000})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.generate:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 合并指纹模板
|
* @param {number} mergeCount - 合并模板数量（2|3） 2:合成 Ram Buffer0 和 Ram Buffer1，3:合成 Ram Buffer0、Ram Buffer1 和 Ram Buffer2
|
* @param {number} bufferNum - 指纹合并后模板编号（0-2）
|
* @returns {boolean} 返回true表示合并成功，返回false表示合并失败
|
*/
|
dxFingerZaz.merge = function (mergeCount, bufferNum) {
|
if(mergeCount === undefined || mergeCount === null || mergeCount < 2 || mergeCount > 3){
|
throw new Error("dxFingerZaz.merge: 'mergeCount' parameter should be between 2 and 3")
|
}
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.merge: 'bufferNum' parameter should be between 0 and 3")
|
}
|
|
let data = toEndianHexExtended(bufferNum, 2) + toEndianHexExtended(mergeCount, 1)
|
send({prefix: 0x55AA, cmd: 0x6100, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x6100})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.merge:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 保存指纹模板数据到模块指纹库
|
* @param {number} keyId - 指纹编号
|
* @param {number} bufferNum - 指纹模板编号（0-2）
|
* @param {boolean} [overwrite=false] - 是否覆盖已存在的指纹
|
* @returns {boolean} 返回true表示存储成功，返回false表示存储失败
|
*/
|
dxFingerZaz.storeChar = function (keyId, bufferNum, overwrite = false) {
|
if(keyId === undefined || keyId === null){
|
throw new Error("dxFingerZaz.storeChar: 'keyId' parameter should be between 0 and 255")
|
}
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.storeChar: 'bufferNum' parameter should be between 0 and 3")
|
}
|
if (overwrite) {
|
const delRet = dxFingerZaz.delChar(keyId, keyId)
|
if (!delRet) {
|
log.error("dxFingerZaz.storeChar: failed to delete existing fingerprint for keyId", keyId)
|
return false
|
}
|
}
|
let data = toEndianHexExtended(keyId, 2) + toEndianHexExtended(bufferNum, 2)
|
send({prefix: 0x55AA, cmd: 0x4000, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4000})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.storeChar:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 读取模块中的指纹并暂存在RamBuffer中
|
* @param {number} keyId - 指纹编号
|
* @param {number} bufferNum - 指纹模板编号（0-2）
|
* @returns {boolean} 返回true表示存储成功，返回false表示存储失败
|
*/
|
dxFingerZaz.loadChar = function (keyId, bufferNum) {
|
if(keyId === undefined || keyId === null){
|
throw new Error("dxFingerZaz.loadChar: 'keyId' parameter should be between 0 and 255")
|
}
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.loadChar: 'bufferNum' parameter should be between 0 and 3")
|
}
|
|
let data = toEndianHexExtended(keyId, 2) + toEndianHexExtended(bufferNum, 2)
|
send({prefix: 0x55AA, cmd: 0x4100, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4100})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.loadChar:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 将保存于指定编号的Ram Buffer 中的 Template 上传至HOST
|
* @param {number} bufferNum - 指纹模板编号（0-2）
|
* @returns {string} 返回设备信息，返回false表示获取失败
|
*/
|
dxFingerZaz.upChar = function (bufferNum) {
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.upChar: 'bufferNum' parameter should be between 0 and 3")
|
}
|
|
let data = toEndianHexExtended(bufferNum, 2)
|
send({prefix: 0x55AA, cmd: 0x4200, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4200})
|
if(resp && resp.ret == 0x00){
|
log.info("resp.data:", fromEndianHexExtended(resp.data, 2))
|
resp = receive({prefix: 0xA55A, cmd: 0x4200, len: fromEndianHexExtended(resp.data, 2)})
|
if(resp && resp.ret == 0x00){
|
return dxCommon.uint8ArrayToHexString(resp.data)
|
} else {
|
log.error("dxFingerZaz.upChar:", resp)
|
return false
|
}
|
} else {
|
log.error("dxFingerZaz.upChar:", resp)
|
return false
|
}
|
}
|
|
|
|
/**
|
* 从HOST下载 Template到模块指定编号的 Ram Buffer
|
* @param {number} bufferNum - 指纹模板编号（0-2）
|
* @param {string} template - 指纹模板数据
|
* @returns {string} 返回设备信息，返回false表示获取失败
|
*/
|
dxFingerZaz.downChar = function (bufferNum, template) {
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.downChar: 'bufferNum' parameter should be between 0 and 3")
|
}
|
if(template === undefined || template === null){
|
throw new Error("dxFingerZaz.downChar: 'template' parameter should not be null or empty")
|
}
|
let data = toEndianHexExtended(bufferNum, 2) + template
|
log.info("template.length:", toEndianHexExtended(data.length / 2, 2))
|
send({prefix: 0x55AA, cmd: 0x4300, data: toEndianHexExtended(data.length / 2, 2)})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4300})
|
if(resp && resp.ret == 0x00){
|
send({prefix: 0x5AA5, cmd: 0x4300, data: data})
|
resp = receive({prefix: 0xA55A, cmd: 0x4300})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.downChar:", resp)
|
return false
|
}
|
} else {
|
log.error("dxFingerZaz.downChar:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 获取指纹模块设备信息
|
* @returns {string} 返回设备信息，返回false表示获取失败
|
*/
|
dxFingerZaz.getEnrolledIdList = function () {
|
send({prefix: 0x55AA, cmd: 0x4900, data: ""})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4900})
|
if(resp && resp.ret == 0x00){
|
resp = receive({prefix: 0xA55A, cmd: 0x4900, len: fromEndianHexExtended(resp.data, 2)})
|
if(resp && resp.ret == 0x00){
|
return resp.data
|
} else {
|
log.error("dxFingerZaz.getDeviceInfo:", resp)
|
return false
|
}
|
} else {
|
log.error("dxFingerZaz.getDeviceInfo:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 搜索指纹模板
|
* @param {number} bufferNum - 指纹模板编号（0-2）
|
* @param {number} startId - 搜索起始编号
|
* @param {number} endId - 搜索结束编号
|
* @returns {number} 返回搜索到的指纹编号，返回false表示搜索失败
|
*/
|
dxFingerZaz.search = function (bufferNum, startId, endId) {
|
if(bufferNum === undefined || bufferNum === null || bufferNum < 0 || bufferNum > 2){
|
throw new Error("dxFingerZaz.search: 'bufferNum' parameter should be between 0 and 3")
|
}
|
if(startId === undefined || startId === null || startId < 1 || startId > options.total){
|
throw new Error("dxFingerZaz.search: 'startId' parameter should be between 1 and " + options.total)
|
}
|
if(endId === undefined || endId === null || endId < 1 || endId > options.total){
|
throw new Error("dxFingerZaz.search: 'endId' parameter should be between 1 and " + options.total)
|
}
|
|
let data = toEndianHexExtended(bufferNum, 2) + toEndianHexExtended(startId, 2) + toEndianHexExtended(endId, 2)
|
send({prefix: 0x55AA, cmd: 0x6300, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x6300})
|
if(resp && resp.ret == 0x00){
|
return fromEndianHexExtended(resp.data.slice(0, 2), 2)
|
} else {
|
log.error("dxFingerZaz.search:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 获取指纹模块参数
|
* @param {number} paramType - 参数类型（0-4）[0: 设备Id, 1: 安全等级, 2: 重复检查, 3: 波特率, 4: 自动学习]
|
* @returns {number} 返回参数值，返回false表示获取失败
|
*
|
* 设备Id：[1-255]
|
* 安全等级：[1-5]
|
* 重复校验：[0/1]
|
* 波特率：[1:9600, 2:19200, 3:38400, 4:57600, 5:115200, 6:230400, 7:460800, 8:921600]
|
* 自动学习：[0/1]
|
*/
|
dxFingerZaz.getParam = function (paramType) {
|
if(paramType === undefined || paramType === null || paramType < 0 || paramType > 4){
|
throw new Error("dxFingerZaz.getParam: 'paramType' parameter should be between 0 and 4")
|
}
|
|
let data = toEndianHexExtended(paramType, 2)
|
send({prefix: 0x55AA, cmd: 0x0300, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x0300})
|
if(resp && resp.ret == 0x00){
|
return fromEndianHexExtended(resp.data, 4)
|
} else {
|
log.error("dxFingerZaz.getParam:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 设置指纹模块参数
|
* @param {number} paramType - 参数类型（0-4）[0: 设备Id, 1: 安全等级, 2: 重复检查, 3: 波特率, 4: 自动学习]
|
* @param {number} paramValue - 参数值
|
* @returns {boolean} 返回true表示设置成功，返回false表示设置失败
|
*
|
* 设备Id：[1-255]
|
* 安全等级：[1-5]
|
* 重复校验：[0/1]
|
* 波特率：[1:9600, 2:19200, 3:38400, 4:57600, 5:115200, 6:230400, 7:460800, 8:921600]
|
* 自动学习：[0/1]
|
*/
|
dxFingerZaz.setParam = function (paramType, paramValue) {
|
if(paramType === undefined || paramType === null || paramType < 0 || paramType > 4){
|
throw new Error("dxFingerZaz.setParam: 'paramType' parameter should be between 0 and 4")
|
}
|
if(paramValue === undefined || paramValue === null || paramValue < 0 || paramValue > 255){
|
throw new Error("dxFingerZaz.setParam: 'paramValue' parameter should be between 0 and 255")
|
}
|
|
let data = toEndianHexExtended(paramType, 1) + toEndianHexExtended(paramValue, 4)
|
send({prefix: 0x55AA, cmd: 0x0200, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x0200})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.setParam:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 获取指纹模块设备信息
|
* @returns {string} 返回设备信息，返回false表示获取失败
|
*/
|
dxFingerZaz.getDeviceInfo = function () {
|
send({prefix: 0x55AA, cmd: 0x0400, data: ""})
|
let resp = receive({prefix: 0xAA55, cmd: 0x0400})
|
if(resp && resp.ret == 0x00){
|
resp = receive({prefix: 0xA55A, cmd: 0x0400, len: fromEndianHexExtended(resp.data, 2)})
|
if(resp && resp.ret == 0x00){
|
return dxCommon.utf8HexToStr(dxCommon.uint8ArrayToHexString(resp.data.slice(0, resp.length - 3)))
|
} else {
|
log.error("dxFingerZaz.getDeviceInfo:", resp)
|
return false
|
}
|
} else {
|
log.error("dxFingerZaz.getDeviceInfo:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 指纹检测
|
* @returns {number} 返回1:有指纹输入，0:无指纹输入，返回false表示检测失败
|
*/
|
dxFingerZaz.fingerDetect = function () {
|
send({prefix: 0x55AA, cmd: 0x2100, data: ""})
|
let resp = receive({prefix: 0xAA55, cmd: 0x2100})
|
if(resp && resp.ret == 0x00){
|
return fromEndianHexExtended(resp.data, 1)
|
} else {
|
log.error("dxFingerZaz.fingerDetect:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 删除指纹模板
|
* @param {number} startId - 删除起始编号
|
* @param {number} endId - 删除结束编号
|
* @returns {boolean} 返回true表示删除成功，返回false表示删除失败
|
*/
|
dxFingerZaz.delChar = function (startId, endId) {
|
if(startId === undefined || startId === null || startId < 1 || startId > options.total){
|
throw new Error("dxFingerZaz.delChar: 'startId' parameter should be between 1 and " + options.total)
|
}
|
if(endId === undefined || endId === null || endId < 1 || endId > options.total){
|
throw new Error("dxFingerZaz.delChar: 'endId' parameter should be between 1 and " + options.total)
|
}
|
|
let data = toEndianHexExtended(startId, 2) + toEndianHexExtended(endId, 2)
|
send({prefix: 0x55AA, cmd: 0x4400, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4400})
|
if(resp && resp.ret == 0x00){
|
return true
|
} else {
|
log.error("dxFingerZaz.delChar:", resp)
|
return false
|
}
|
}
|
|
|
/**
|
* 获取指定编号范围内已注册的指纹总数
|
* @param {number} startId - 起始编号
|
* @param {number} endId - 结束编号
|
* @returns {number} 返回指定编号范围内已注册的指纹总数，返回false表示获取失败
|
*/
|
dxFingerZaz.getEnrollCount = function (startId, endId) {
|
if(startId === undefined || startId === null || startId < 1 || startId > options.total){
|
throw new Error("dxFingerZaz.getEnrollCount: 'startId' parameter should be between 1 and " + options.total)
|
}
|
if(endId === undefined || endId === null || endId < 1 || endId > options.total){
|
throw new Error("dxFingerZaz.getEnrollCount: 'endId' parameter should be between 1 and " + options.total)
|
}
|
|
let data = toEndianHexExtended(startId, 2) + toEndianHexExtended(endId, 2)
|
send({prefix: 0x55AA, cmd: 0x4800, data: data})
|
let resp = receive({prefix: 0xAA55, cmd: 0x4800})
|
if(resp && resp.ret == 0x00){
|
return fromEndianHexExtended(resp.data, 2)
|
} else {
|
log.error("dxFingerZaz.getEnrollCount:", resp)
|
return false
|
}
|
}
|
|
|
|
/**
|
* 初始化指纹模块
|
* @param {Object} params
|
* @param {string} params.type - 串口类型（默认 3）
|
* @param {string} params.path - 串口路径（默认 '/dev/ttySLB1'）
|
* @param {number} params.baudrate - 波特率（默认 '115200-8-N-1'）
|
* @param {number} params.id - id（默认 'fingerUart'）
|
* @param {number} params.total - 指纹总数（默认 5000）
|
* @param {number} params.timeout - 超时时间（默认 500）
|
*/
|
dxFingerZaz.init = function (params) {
|
options.id = params.id ? params.id : options.id
|
options.timeout = params.timeout ? params.timeout : options.timeout
|
options.total = params.total ? params.total : options.total
|
options.type = params.type ? params.type : options.type
|
options.path = params.path ? params.path : options.path
|
options.baudrate = params.baudrate ? params.baudrate : options.baudrate
|
|
dxUart.open(options.type, options.path, options.id)
|
dxUart.ioctl(6, options.baudrate, options.id)
|
}
|
|
|
|
/**
|
* 将数字转换为指定字节数的十六进制字符串
|
* @param {number} number - 要转换的数字
|
* @param {number} bytes - 字节数（默认2字节）
|
* @param {boolean} isLittleEndian - 是否小端序（默认true）
|
* @returns {string} 转换后的十六进制字符串
|
*/
|
function toEndianHexExtended(number, bytes, isLittleEndian = true) {
|
// 计算所需的十六进制位数（每个字节占2位）
|
const hexLength = bytes * 2;
|
let hexStr = number.toString(16).padStart(hexLength, '0');
|
|
// 分割为字节数组
|
const bytesArray = [];
|
for (let i = 0; i < hexLength; i += 2) {
|
bytesArray.push(hexStr.substr(i, 2));
|
}
|
|
// 根据字节序反转数组
|
if (isLittleEndian) bytesArray.reverse();
|
|
return bytesArray.join('');
|
}
|
|
/**
|
* 将字节数组转换为数字（支持大小端序）
|
* @param {Uint8Array|number[]} bytesArray - 字节数组（如 Uint8Array 或普通数组）
|
* @param {number} bytes - 字节数（必须与实际数据长度一致）
|
* @param {boolean} isLittleEndian - 是否小端序（默认true）
|
* @returns {number} 转换后的数字
|
*/
|
function fromEndianHexExtended(bytesArray, bytes, isLittleEndian = true) {
|
// 参数校验
|
if (!bytesArray || bytesArray.length !== bytes) {
|
throw new Error(`Invalid bytes array. Expected length: ${bytes}`);
|
}
|
|
// 处理小端序：反转字节顺序
|
const adjustedBytes = isLittleEndian
|
? Array.from(bytesArray).reverse()
|
: Array.from(bytesArray);
|
|
// 转换为十六进制字符串
|
const hexStr = adjustedBytes
|
.map(byte => byte.toString(16).padStart(2, "0"))
|
.join("");
|
|
// 转换为数字（支持大整数）
|
return parseInt(hexStr, 16);
|
}
|
|
|
|
/**
|
* 发送数据
|
* @param {Object} params
|
* @param {number} params.prefix
|
* @param {number} params.cmd
|
* @param {string} params.data
|
*/
|
function send(params) {
|
if (!params || typeof params !== 'object') {
|
throw new Error("Parameters should be an object containing prefix, cmd and data");
|
}
|
|
const { prefix, cmd, data } = params;
|
const sid = 0x00; // 默认源地址 0x00
|
const did = 0x00; // 默认目标地址 0x00
|
|
const hexParts = data.match(/[\da-f]{2}/gi) || [];
|
|
const bytes = new Uint8Array(hexParts.map(h => parseInt(h, 16)));
|
|
let dataBytes
|
if (prefix === 0x55AA) {
|
dataBytes = new Uint8Array(16);
|
dataBytes.set(bytes.subarray(0, 16), 0);
|
|
} else if (prefix === 0x5AA5) {
|
dataBytes = new Uint8Array(500);
|
dataBytes.set(bytes.subarray(0, 500), 0);
|
}
|
|
// 构造基础数据包
|
const packet = new Uint8Array(8 + dataBytes.length + 2); // 包头(8) + 数据 + 校验(2)
|
const view = new DataView(packet.buffer);
|
|
// 填充包头
|
view.setUint16(0, prefix, false); // 大端序 PREFIX (2 bytes)
|
packet[2] = sid; // SID (1 byte)
|
packet[3] = did; // DID (1 byte)
|
view.setUint16(4, cmd, false); // 大端序 CMD (2 bytes)
|
view.setUint16(6, hexParts.length, true); // 大端序 LEN (2 bytes)
|
|
// 填充数据
|
packet.set(dataBytes, 8);
|
|
// 计算校验和
|
let checksum = 0;
|
for (let i = 0; i < 8 + dataBytes.length; i++) {
|
checksum += packet[i];
|
}
|
checksum &= 0xFFFF; // 取低 16 位
|
|
// 填充校验和（大端序）
|
packet[8 + dataBytes.length] = checksum & 0xFF;
|
packet[8 + dataBytes.length + 1] = (checksum >> 8) & 0xFF;
|
|
// // TODO 临时日志打印 start
|
// let str = ''
|
// for (let i = 0; i < packet.length; i++) {
|
// str += packet[i].toString(16).padStart(2, '0') + ' '
|
// }
|
// log.info("send:", str)
|
// // TODO 临时日志打印 end
|
|
// 发送数据
|
let ret = dxUart.send(packet.buffer, options.id);
|
if(!ret){
|
throw new Error("fingerZazUart.send fail")
|
}
|
}
|
|
|
|
/**
|
* 接收数据
|
* @param {Object} params
|
* @param {number} params.prefix
|
* @param {number} params.cmd
|
* @param {number} params.len
|
* @returns {Object} 返回数据
|
*/
|
function receive(params) {
|
// 重试5次, 避免读取太快模组未响应
|
for(let i = 0; i < 5; i++){
|
const prefix1 = dxUart.receive(1, options.timeout, options.id);
|
if (!prefix1 || (prefix1[0] !== 0xAA && prefix1[0] !== 0xA5)) {
|
std.sleep(50)
|
continue
|
}
|
|
const prefix2 = dxUart.receive(1, options.timeout, options.id);
|
if (!prefix2 || (prefix2[0] !== 0x55 && prefix2[0] !== 0x5A)) {
|
std.sleep(50)
|
continue
|
}
|
|
// 定义通用字段
|
let prefix, sid, did, cmd, len, ret, data, checksum;
|
|
prefix = (prefix1[0] << 8) | prefix2[0];
|
|
const value1 = dxUart.receive(6, options.timeout, options.id);
|
sid = value1[0];
|
did = value1[1];
|
cmd = (value1[2] << 8) | value1[3];
|
len = (value1[5] << 8) | value1[4];
|
|
let value2 = dxUart.receive(len, options.timeout, options.id)
|
if(value2 && value2.length === len){
|
ret = value2[1] << 8 | value2[0];
|
data = value2.subarray(2, len)
|
} else {
|
throw new Error("fingerZazUart.receive fail: data length mismatch")
|
}
|
|
|
let value3
|
if(prefix1[0] === 0xAA && prefix2[0] === 0x55){
|
// 校验字在最后
|
value3 = dxUart.receive((26 - 2 - 8 - len + 2), options.timeout, options.id)
|
checksum = value3[value3.length - 2] | (value3[value3.length - 1] << 8);
|
} else {
|
// 校验字在前面
|
value3 = dxUart.receive(2, options.timeout, options.id)
|
checksum = value3[0] | (value3[1] << 8);
|
}
|
|
|
// 计算校验和（从prefix到data）
|
let sum = prefix1[0];
|
sum += prefix2[0];
|
for (let i=0; i < value1.length; i++) sum += value1[i];
|
for (let i=0; i < value2.length; i++) sum += value2[i];
|
if ((sum & 0xFFFF) !== checksum) throw "Response Packet Checksum mismatch";
|
|
// // TODO 临时日志打印 start
|
// let str = prefix1[0].toString(16).padStart(2, '0') + ' ' + prefix2[0].toString(16).padStart(2, '0') + ' '
|
// for (let i = 0; i < value1.length; i++) str += value1[i].toString(16).padStart(2, '0') + ' '
|
// for (let i = 0; i < value2.length; i++) str += value2[i].toString(16).padStart(2, '0') + ' '
|
// for (let i = 0; i < value3.length; i++) str += value3[i].toString(16).padStart(2, '0') + ' '
|
// log.info("receive:", str)
|
// // TODO 临时日志打印 end
|
|
if (params.prefix == prefix && params.cmd == cmd) {
|
return {
|
prefix: prefix,
|
sid,
|
did,
|
command: cmd,
|
length: len,
|
ret: ret,
|
data: Array.from(data),
|
cks: true
|
};
|
} else {
|
throw new Error("fingerZazUart.receive fail:")
|
}
|
}
|
}
|
|
|
|
export default dxFingerZaz;
|
