uniapp蓝牙门锁功能（开门，录入指纹，密码，门卡，OTA升级，门锁设置音量语言等） ，蓝牙连接，发送应答，OTA升级分包，重发机制，蓝牙中断
蓝牙连接流程图
import store from '@/store'
import {
getDeviceKey,
getOpenPwd,
postFamilyLog,
postFamilyPolice,
updateElectric
} from '@/request'
import {
calculateCRC16Modbus,
strToHexCharCode,
data_encrypt,
data_decrypt,
hex2ArrayBuffer,
hex2String,
string2Hex,
get_sum,
arrayBuffer2Hex,
hex2int,
get_time_ts,
get_msg_len,
get_hex_str,
get_num2hex,
get_bin2hex
} from './srv_request.js'
import CryptoJS from 'crypto-js'
import SparkMD5 from "spark-md5"
export class BtTask {
constructor(id) {
this.task_member_passwd_status = "init"
this.msg_reset_lock_cnt = 0
this.productId = "" //绑定连接设备id
this.productInfo = {} //绑定连接设备信息
this.task_bt_pair_status = "init" //绑定的流程判断
this.bindKey = "" //绑定设备秘钥
this.deviceNum = id //后台的设备deviceNum
this.deviceId = "" //蓝牙搜索出的设备id
this.bt_product_list = [] //搜索到的设备列表
this.characteristics0 = "" //特征值数据 暂时先保留
this.characteristics1 = "" //特征值数据
this.writeuuid = "" //蓝牙写入uuid
this.notifyuuid = "" //蓝牙监听uuid
this.serviceId = "" //服务id 用来获取蓝牙特征值
this.dev_crc16 = "" //用于匹配对应蓝牙的crc(根据deviceId加密而来)
this.dev_key = "" //加密秘钥
this.dev_key_md5 = "" //秘钥MD5
this.dev_key_md5_hex = "" //十六进制秘钥MD5
this.dev_pid = "" // 锁信息
this.dev_soft_version = "" // 锁信息
this.dev_passwd = "" // 锁信息
this.dev_lock_status = "" // 锁信息
this.dev_open_status = -1 //开门状态
this.dev_open_err_code = -1 //开锁失败原因码
this.srv_passwd = "" //开锁秘钥
// 指纹
this.dev_add_fp_step = 0 //录入指纹步骤
this.dev_add_fp_step_sum = 0 //录入指纹所需次数
this.dev_add_fp_hw_id = 0 //录入指纹成员id
this.dev_fp_sample_cnt = 0 //录入第几次
// 卡片
this.dev_add_card_step = 0
this.dev_add_card_step_sum = 0
this.dev_add_card_hw_id = 0
this.dev_card_sample_cnt = 0
// 文件
this.file_update_offset = 0
this.file_update_page_index = 0
this.file_update_page_max = 0
// 升级
this.update_start = false
this.pkg_size = 0 //每包传输大小
this.page_num = 0 //总包数
this.current_page = 0 //当前包数
this.update_status = 0
this.update_file_data = '' //OTA升级数据
this.upgradeCallback = {} //升级最后一包数据回调 ---- 回调里去获取重新当前设备版本号对比判断是否更新成功
this.searchTimer = null, //蓝牙搜索不到处理定时
this.bluetoothState = 0 //蓝牙连接状态 0断开 1连接 2连接中
this.bluetoothSearchState = 0 //蓝牙搜索状态 0未搜索 1搜索中
this.update_hardler_status = "init" //硬件升级
this.task_update = {}
this.task_normal = {}
this.update_hardler_cnt = 0
this.app_pkg_data_start_cnt = 0
this.app_update_cmd_start_cnt = 0
this.update_hardler_system_cnt = 0
this.app_pkg_data_ng_cnt = 0
this.isBind = false
this.hardwareId = 0
this.record_sync_flag = false
this.remove_passwd_callback = {}
this.user_id = 0
this.update_volume_callback = {}
this.update_language_callback = {}
this.remove_fp_callback = {} //删除指纹回调
this.get_dev_info_callback = {} //获取锁信息回调
this.remove_card_callback = {} //删除卡片回调
this.set_new_admin_passwd_callback = {} //设置密码回调
this.bindStepCallback = {} //绑定步骤回调
this.addNewFingerCallback = {} //添加指纹回调
this.addNewCardCallback = {} //添加卡片回调
// 同步指纹
this.syncFingerData = '' //同步指纹数据总包
this.syncFingerStep = 0 //同步指纹数据包序号
this.syncFingerMemberId = '' //同步指纹数据成员id
this.syncFingerCallback = {} //同步指纹数据回调
this.syncCardCallback = {} //同步卡片数据回调
// 采集器
this.fingerStep = '' //采集器当前步骤
this.fingerData = '' //采集器指纹包数据
this.serialNumber = '' //采集器当前包序号
this.msg_collect_finger_callback = {} //采集器添加指纹回调
this.cardData = '' //采集器卡片数据
this.msg_collect_card_callback = {} //采集器删除卡片回调
// 重发
this.repeatFailTimer = null //重发的定时器
this.second = 0 //重发次数
}
// 获取蓝牙连接状态
get_bluetooth_state() {
return this.bluetoothState
}
//开启蓝牙
bt_open_start() {
this.closeBLEConnection()
this.openBluetoothAdapter()
}
//获取锁的密钥
bt_load_init(bindKey, productInfo, productId, deviceNum) {
this.bindKey = bindKey
this.productInfo = productInfo
this.productId = productId
this.deviceNum = deviceNum
var hex = string2Hex(this.deviceNum)
console.log('@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@hex', hex)
this.dev_crc16 = calculateCRC16Modbus(strToHexCharCode(this.deviceNum)).padStart(4, 0).toUpperCase()
console.log("###################this.dev_crc16", this.dev_crc16);
this.task_bt_pair_status = 'bt_pair_begin'
this.get_key_by_dev_id()
}
//bt 配对任务 之前版本的写法，看着就头疼
task_bt_pair() {
console.log('配对任务------')
// if ("init" == this.task_bt_pair_status) {
// //task_bt_pair_status = "get_lock_info_start"
// }
// if ("bt_pair_connect_start" == this.task_bt_pair_status) {
// //this.task_bt_pair_status = "bt_pair_connect_ok"
// } else
// if (this.task_bt_pair_status == "bt_pair_connect_ok") //连接
// {
// console.log('@@@@@@@@@ bt_pair_get_key_by_dev_id_start获取密钥')
// // this.task_bt_pair_status = "bt_pair_reset_lock"
// } else
if ("bt_pair_connect_ok" == this.task_bt_pair_status) //复位锁
{
console.log('bt_pair_reset_lock复位锁')
// 连接之后延迟去操作锁
if (this.msg_reset_lock_cnt++ > 4) {
this.msg_reset_lock_cnt = 0
this.msg_reset_lock()
}
} else if ("bt_pair_get_lock_info_start" == this.task_bt_pair_status) //获取锁信息
{
console.log('@@@@@@@@@ bt_pair_get_lock_info_start获取锁信息')
this.msg_get_dev_info()
} else if ("bt_pair_get_lock_info_end" == this.task_bt_pair_status) //进入锁设置页面
{
uni.hideLoading()
uni.navigateTo({
url: `/page_lock/bind_device_submit/bind_device_submit?msg=${JSON.stringify(this.productInfo)}&deviceNum=${this.deviceNum}&bindKey=${this.bindKey}`
})
this.bindStep = 3
this.bindStepCallback(3)
console.log('@@@@@@@@@ bt_pair_get_lock_info_start进入锁设置页面')
this.clear_task()
this.task_bt_pair_status = "init"
}
// else if ("bt_pair_add_new_admin_passwd_wait" == this.task_bt_pair_status) //添加管理员密码
// {
// console.log('@@@@@@@@@ bt_pair_add_new_admin_passwd_wait添加管理员密码')
// } else if ("bt_pair_add_new_admin_passwd_start" == this.task_bt_pair_status) {
// console.log('@@@@@@@@@ bt_pair_add_new_admin_passwd_start')
// this.isBind = true
// this.msg_add_new_admin_passwd(this.dev_input_passwd)
// }
// else if ("bt_pair_srv_create_bt_dev_start" == this.task_bt_pair_status) //后台建立节点
// {
// console.log('@@@@@@@@@ bt_pair_srv_create_bt_dev_start后台建立节点')
// this.srv_create_bt_dev()
// this.isBind = false
// } else if ("bt_pair_ok" == this.task_bt_pair_status) {
// console.log('@@@@@@@@@ bt_pair_ok')
// this.task_bt_pair_status = "init"
// else if ("bt_pair_lock_status_busy" == this.task_bt_pair_status) {
// console.log('@@@@@@@@@ bt_pair_lock_status_busy')
// }
}
task_normal_hardler(that) {
that.task_bt_pair()
//that.task_member_passwd()
}
task_create(callback) {
this.bindStepCallback = callback
clearInterval(this.task_normal)
this.task_normal = setInterval(this.task_normal_hardler, 500, this);
}
clear_task() {
clearInterval(this.task_normal)
}
//获取密钥
get_key_by_dev_id() {
getDeviceKey({
deviceNum: this.deviceNum
}).then(res => {
this.dev_key = res.data["secretKey"]
this.dev_key_md5 = CryptoJS.MD5(this.dev_key).toString().toUpperCase()
this.dev_key_md5_hex = hex2String(this.dev_key_md5)
if(this.task_bt_pair_status =='bt_pair_begin'){
this.task_bt_pair_status = 'bt_pair_connect_start'
this.bt_open_start()
}
})
}
console_time(str) {
var timestamp = new Date().getTime()
var tmp = str + timestamp.toString()
console.log(tmp);
}
// 锁电量上报
rev_electric_hardler(data, len){
var value = hex2int(data.slice(2, 6))
console.log('锁电量上报',data,value);
updateElectric({
deviceNum:this.deviceNum,
electricity:value
}).then(res=>{
this.msg_rev_electric()
})
}
// 应答电量上报
msg_rev_electric(){
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "08"
var msg_type = "02"
var msg_flag = "00"
var msg_data = msg_type + msg_flag
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.do_send_bt_msg(msg0,1)
}
//获取操作记录回应 （锁端不再上传相同记录）
msg_get_open_record_ack() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "01"
var msg_len = "0000"
var msg_type = "00"
var msg_flag = "00"
console.log('############ 获取操作记录msg_get_open_record_ack')
var msg_data = msg_type + msg_flag
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.do_send_bt_msg(msg0, 1)
}
//获取操作记录
msg_get_open_record() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "01"
var msg_len = "0006"
var msg_type = "00"
var msg_flag = "01"
var msg_ts = get_time_ts(0)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_type + msg_flag + msg_ts
var msg0_hex = hex2String(msg0)
var md5 = SparkMD5.hashBinary(msg0_hex).toString().toUpperCase()
var sum_data = get_sum(msg0 + md5)
var msg = msg0 + md5 + sum_data
var hex2 = hex2String(msg)
console.log('************ 获取操作记录', msg)
var encrypted = data_encrypt(hex2, this.dev_key_md5_hex)
var data = string2Hex(encrypted.out)
this.write(data)
}
//接受到操作记录反馈
rev_open_record_hardler(data, len) {
var ops_flag = data.slice(2, 4)
var ops_step = data.slice(4, 6)
var pkg_num = data.slice(6, 8)
var len_pkg = (len - 4) / 6 //记录数量
console.log("@@@@@@@@@@@@@@@@@ rev_open_record_hardler接受到操作记录反馈", data, ops_flag, ops_step);
console.log('有无操作记录',ops_flag == "01" && ops_step == "00")
if (ops_flag == "01" && ops_step == "00") //有操作记录
{
var i = 0
var jsonArr_open = []
var jsonArr_ops = []
var jsonArr_police = []
for (i = 0; i < len_pkg; i++) {
var offset = i * 12
var type_tran = []
var type = data.slice(8 + offset, 10 + offset)
var id = data.slice(10 + offset, 12 + offset)
var ts = data.slice(12 + offset, 20 + offset)
var ts_val = hex2int(ts)
var id_val = hex2int(id)
var type_val = hex2int(type)
//由于与后台枚举不一致 故作转换
type_tran[1] = 1
type_tran[2] = 2
type_tran[3] = 3
type_tran[4] = 4
type_tran[5] = 5
type_tran[6] = 6
type_tran[7] = 7
type_tran[8] = 8
type_tran[9] = 9
type_tran[0x0A] = 0x0A
type_tran[0x0B] = 0x0B
type_tran[0x0C] = 0
type_tran[0x0D] = 0
type_tran[0x0E] = 0
type_tran[0x0F] = 0
type_tran[0x10] = 0
type_tran[0x11] = 0
type_tran[0x12] = 0
type_tran[0x13] = 0
type_tran[0x14] = 0
type_tran[0x15] = 0
type_tran[0x16] = 1
type_tran[0x17] = 2
type_tran[0x18] = 3
type_tran[0x19] = 4
type_tran[0x20] = 5
var type_tran_val = type_tran[type_val]
var jobj = {
deviceNum: this.deviceNum,
openType: type_tran_val,
reportTime: ts_val * 1000,
hardwareId: id_val
}
//不同类型使用不同的后台API
if (type_val >= 0x01 && type_val <= 0x0B) {
jsonArr_open.push(jobj);
} else if (type_val >= 0x0C && type_val <= 0x15) {
jsonArr_ops.push(jobj);
} else if (type_val >= 0x16 && type_val <= 0x19) {
jsonArr_police.push(jobj);
}
}
console.log("jsonArr_open", jsonArr_open);
console.log("jsonArr_police", jsonArr_police);
let arr = []
if (jsonArr_open.length > 0) {
arr.push(postFamilyLog(jsonArr_open))
// this.srv_add_record(jsonArr_open, 1)
}
if (jsonArr_police.length > 0) {
arr.push(postFamilyPolice(jsonArr_police))
// this.srv_add_record(jsonArr_police, 2)
}
// 两个列表都成功了才应答
Promise.all(arr).then(res=>{
this.msg_get_open_record_ack()
})
// if (report_type == 1) {
// // postFamilyLog(myJSON).then(res => {
// // this.msg_get_open_record_ack()
// // })
// } else if (report_type == 2) {
// // postFamilyPolice(myJSON).then(res => {
// // this.msg_get_open_record_ack()
// // })
// }
} else {
}
}
//复位锁端
msg_reset_lock() {
console.log('############ msg_reset_lock复位锁')
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "14"
var msg_len = "0006"
var msg_type = "00"
var msg_flag = "FF"
var msg_ts = ""
msg_ts = get_time_ts(0)
var msg_data = msg_type + msg_flag
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
//复位锁反馈
rev_reset_lock_hardler(data, len) {
var ack = data.slice(2, 4)
console.log("### rev_reset_lock_hardler ack复位锁反馈", ack)
if(this.task_bt_pair_status == 'bt_pair_connect_ok'){
this.task_bt_pair_status = "bt_pair_get_lock_info_start"
this.bindStep = 2
this.bindStepCallback(2)
}
}
// 获取开锁的一个秘钥srv_passwd
get_admin_passwd() {
getOpenPwd({
deviceNum: this.deviceNum
}).then(res => {
console.log('get_admin_passwd', res)
this.srv_passwd = res.data["password"]
})
}
//开锁
msg_open_door() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "02"
var msg_len = "0006"
var msg_type = "00"
var msg_flag = "01"
var msg_ts = ""
this.dev_open_status = -1
this.dev_open_err_code = -1
console.log('############ start msg_open_door开锁', this.srv_passwd)
msg_ts = get_time_ts(0)
var msg_passwd = calculateCRC16Modbus(strToHexCharCode(this.srv_passwd)).padStart(4, 0).toUpperCase()
// console.log('@@@@@@@@@ msg_passwd crc', msg_passwd)
var msg_data = msg_ts + msg_passwd
// console.log('************ msg_data', msg_data)
var msg_len = get_msg_len(msg_data)
// console.log('************ msg_len', msg_len)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
// console.log('************ msg0', msg0)
this.do_send_bt_msg(msg0, 1)
}
//开锁返回信息
rev_open_door_hardler(data, len) {
console.log("### rev_open_door_hardler开锁反馈")
var open_status = data.slice(2, 4)
var err_code = data.slice(4, 6)
this.dev_open_status = open_status
this.dev_open_err_code = err_code
console.log("open_status", open_status)
console.log("err_code", err_code)
}
get_open_door_status() {
return this.dev_open_status
}
get_open_door_err_code() {
return this.dev_open_err_code
}
//添加卡片
msg_add_new_card(memberId, callback = {}) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "06"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
var msg_hw_id = "FF"
var msg_user_id = get_hex_str(memberId, 2) //成员id
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_step = "00" //开始
this.addNewCardCallback = callback
var msg_data = msg_type + msg_step + msg_user_id + msg_hw_id + msg_ts_start + msg_ts_end
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
//添加卡片反馈
rev_add_new_card_hardler(data, len) {
this.clear_add_new_card()
var step = data.slice(2, 4)
var user_id = data.slice(4, 6)
var hw_id = data.slice(6, 8)
var ack = hex2int(data.slice(8, 10))
// if(ack != 0x00){
// this.res_fail_dispose(ack)
// }
console.log("### rev_add_new_card_hardler添加新卡片反馈",'应答码：',ack,'步骤：',step)
this.dev_add_card_step = hex2int(step)
if (this.dev_add_card_step == 0x00) //录入开始
{
this.addNewCardCallback()
} else if (this.dev_add_card_step == 0xFC) //录入进行
{
} else if (this.dev_add_card_step == 0xFF) //录入完成
{
this.dev_add_card_hw_id = hex2int(hw_id)
} else if (this.dev_add_card_step == 0xFD ) //0xFD录入失败 0xFE录入取消
{
}
}
//删除卡片
msg_remove_card(user_id, hw_id, callback) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "0F"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
this.remove_card_callback = callback
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_user_id = get_hex_str(user_id, 2)
var msg_hw_id = get_hex_str(hw_id, 2)
var msg_data = msg_type + msg_user_id + msg_hw_id
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
// 删除卡片反馈
rev_remove_card_hardler(data, len) {
console.log("### rev_remove_passwd_hardler删除卡片反馈")
var user_id = data.slice(2, 4)
var hw_id = data.slice(4, 6)
var ack = hex2int(data.slice(6, 8))
console.log("### 删除卡片反馈数据", user_id, hw_id, ack)
if(ack == 0x00){
this.remove_card_callback(1)
}else{
this.remove_card_callback(2)
this.res_fail_dispose(ack)
}
}
get_add_card_hw_id() {
return this.dev_add_card_hw_id
}
get_add_card_step() {
return this.dev_add_card_step
}
clear_add_new_card() {
this.dev_add_card_step = 0
this.dev_add_card_hw_id = 0
}
// 采集器 -------------------------------start//
//设置秘钥
set_dev_key(dev_key) {
this.dev_key = dev_key
this.dev_key_md5 = CryptoJS.MD5(this.dev_key).toString().toUpperCase()
this.dev_key_md5_hex = hex2String(this.dev_key_md5)
}
// 采集器指纹数据
get_fingerData() {
return this.fingerData
}
//采集器卡片数据
get_cardData() {
return this.cardData
}
// 当前结果 指纹卡片公用
get_fingerStep() {
return this.fingerStep
}
// 采集器指纹结束
clear_fp_data() {
this.cardData = ''
this.fingerStep = ''
this.fingerData = '' //采集器指纹包数据
this.serialNumber = '' //采集器当前包序号
this.msg_collect_finger_callback = {}
this.msg_collect_card_callback = {}
}
// 采集器录入指纹 state=1开始 2结束
msg_collect_finger_print(state, callback = {}) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "21"
var msg_ts = ""
var msg_type = "00"
var msg_step = state === 1 ? '0x00' : '0xFE'
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
console.log('msg_ts_start', msg_ts_start, msg_ts_end)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_data = msg_type + msg_step + msg_ts_start + msg_ts_end
var msg_len = get_msg_len(msg_data)
this.msg_collect_finger_callback = callback
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.do_send_bt_msg(msg0, 1)
}
// 采集器录入指纹反馈
res_collect_finger_print_hardler(data, len) {
var step = data.slice(2, 4) //录入阶段
console.log('采集器录入指纹阶段', step)
this.fingerStep = hex2int(step)
if (this.fingerStep == 0x00) {
this.msg_collect_finger_callback()
}
}
//采集器上发指纹数据反馈
rev_send_finger_print_hardler(data, len) {
console.log("### rev_send_finger_print_hardler采集器上发指纹数据反馈 ")
// 包序号
var serialNumber = data.slice(2, 4)
// 指纹数据 128字节 256位
var fingerprintData = data.slice(4, 260)
this.serialNumber = serialNumber
console.log('采集器录入数据接收--', '包序号：' + serialNumber, '数据：' + fingerprintData)
this.fingerData = this.fingerData + fingerprintData
console.log('总数据', this.fingerData)
// 接受成功再应答
this.msg_response_finger_print()
}
// 采集器上发指纹数据应答
msg_response_finger_print() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "22"
// var msg_len = "0002" //数据长度
var msg_ts = ""
var msg_type = "00"
var msg_data = msg_type + this.serialNumber
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('采集器数据接收应答', msg_data)
this.do_send_bt_msg(msg0, 1)
}
// 采集器添加卡片 state=1开始 2结束
msg_collect_card(state, callback = {}) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "23"
var msg_ts = ""
var msg_type = "00"
var msg_step = state === 1 ? '0x00' : '0xFE'
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_data = msg_type + msg_step + msg_ts_start + msg_ts_end
var msg_len = get_msg_len(msg_data)
this.msg_collect_card_callback = callback
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.do_send_bt_msg(msg0, 1)
}
// 采集器添加卡片反馈
res_collect_card_hardler(data, len) {
var step = data.slice(2, 4) //录入阶段
console.log('采集器添加卡片阶段', step)
this.fingerStep = hex2int(step)
if (this.fingerStep == 0x00) {
this.msg_collect_card_callback()
}
// 添加成功
if (this.fingerStep == 0xFF) {
var cardData = data.slice(4, 12) //卡片数据
console.log('卡片录入成功，卡片数据：', cardData)
this.cardData = cardData
}
}
//
/**
* 开始同步采集器指纹到门锁
* @param totalData 指纹数据总包
* @param memberId 成员id
* @param callback 结果回调
*/
start_sync_finger_print(totalData,memberId,callback={}){
this.msg_test_data()
this.clear_sync_finger()
this.syncFingerData = totalData
this.syncFingerMemberId = memberId
this.syncFingerCallback = callback
this.syncFingerStep = 0
console.log('start_sync_finger_print',this.syncFingerData,this.syncFingerMemberId)
setTimeout(()=>{
this.msg_send_finger_print()
},800)
}
/**
* 唤醒门锁蓝牙
*/
msg_test_data(){
var msg_head = "123"
this.write(msg_head)
}
// 发送同步指纹数据
msg_send_finger_print(){
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "11"
var msg_ts = ""
var msg_type = "00"
var msg_memberId = get_hex_str(this.syncFingerMemberId,2) //成员id
var hw_id = "FF" //硬件id 写死FF
var step = get_hex_str(this.syncFingerStep,2) //当前序号
// 每个序包的指纹数据 //16进制
// arrayBuffer2Hex
// string2Hex
var msg_fingerData = this.syncFingerData.slice(this.syncFingerStep*128*2,(this.syncFingerStep+1)*128*2)
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_data = msg_type + msg_memberId + hw_id + step + msg_fingerData + msg_ts_start + msg_ts_end
console.log('发送同步指纹数据',step,msg_fingerData)
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.do_send_bt_msg(msg0, 1)
}
// 同步指纹应答
res_sync_finger_print_hardler(data, len){
let state = hex2int(data.slice(2, 4)) // 0x00开始录入 0xFC录入进行 0xFD录入失败 0xFF录入成功
let memberId = data.slice(4, 6) //成员id
let hw_id = data.slice(6, 8) //硬件id
let sync_number = hex2int(data.slice(8, 10)) //接收到的包序号
let ack = hex2int(data.slice(10, 12)) //应答码
this.syncFingerStep = Number(sync_number)+1
console.log('同步指纹应答1',state,ack)
console.log('同步指纹应答',hw_id,sync_number,this.syncFingerStep)
//优先判断应答码
if(ack != 0x00){
this.res_fail_dispose(ack)
this.syncFingerCallback(2,hw_id)
this.clear_sync_finger()
return
}
// 成功或者失败回调
if( state ==0xFF || state == 0xFD){
let callbackState = state ==0xFF?1:2
this.syncFingerCallback(callbackState,hw_id)
this.clear_sync_finger()
return
}
// // 发的最后一包但是没返回结果，默认失败，停止发送
// if(sync_number == 15){
// this.syncFingerCallback(2,hw_id)
// this.clear_sync_finger()
// return
// }
this.msg_send_finger_print()
}
// 还原同步指纹操作
clear_sync_finger(){
this.syncFingerData = ''
this.syncFingerMemberId = ''
this.syncFingerCallback = {}
this.syncFingerStep = 0
}
// 发送同步门卡数据
msg_sync_card(data,memberId,callback){
this.msg_test_data()
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "12"
var msg_type = "00"
var msg_memberId = get_hex_str(memberId,2) //成员id
var hw_id = "FF" //硬件id 写死FF
var card_Data = data
this.syncCardCallback = callback
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
// 阶段/第几包/总包 000101
var msg_data = msg_type + '000101'+ msg_memberId + hw_id + card_Data + msg_ts_start + msg_ts_end
var msg_len = get_msg_len(msg_data)
console.log('msg',card_Data,msg_memberId)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
setTimeout(()=>{
this.do_send_bt_msg(msg0, 1)
},800)
}
// 同步卡片应答
res_sync_card_hardler(data, len){
let state = hex2int(data.slice(2, 4)) // 0x00开始录入 0xFC录入进行 0xFD录入失败 0xFF录入成功
let memberId = data.slice(4, 6) //成员id
let hw_id = data.slice(6, 8) //硬件id
let ack = hex2int(data.slice(10, 12)) //应答码
console.log('同步卡片应答1',state,memberId,hw_id,ack)
//优先判断应答码
if(ack == 0x00){
this.syncCardCallback(1,hw_id)
}else{
this.syncCardCallback(2,hw_id)
this.res_fail_dispose(ack)
}
}
// 采集器 -------------------------------end//
get_add_fp_hw_id() {
return this.dev_add_fp_hw_id
}
get_add_fp_step() {
return this.dev_add_fp_step
}
get_fp_sample_cnt() {
return this.dev_fp_sample_cnt
}
// 清空添加指纹步骤
//添加指纹
msg_add_new_finger_print(memberId, callback = {}) {
this.clear_add_new_fp()
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "05"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
var msg_hw_id = "FF" //硬件id
console.log('############ msg_add_new_finger_print添加指纹')
console.log('添加指纹成员id', memberId)
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_step ="00"//阶段
var memberId = get_hex_str(memberId, 2) //成员id
this.addNewFingerCallback = callback
var msg_data = msg_type + msg_step + memberId + msg_hw_id + msg_ts_start + msg_ts_end
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
// 取消录入指纹
msg_cancel_finger_print(memberId){
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "05"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
var msg_hw_id = "FF" //硬件id
console.log('############ msg_add_new_finger_print取消指纹')
console.log('添加指纹成员id', memberId)
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_step ="FE"//阶段 取消
var memberId = get_hex_str(memberId, 2) //成员id
var msg_data = msg_type + msg_step + memberId + msg_hw_id + msg_ts_start + msg_ts_end
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
//添加指纹反馈
rev_add_new_finger_print_hardler(data, len) {
console.log("### rev_add_new_finger_print_hardler添加指纹反馈")
var step = data.slice(2, 4)
this.dev_add_fp_step = hex2int(step)
var user_id = data.slice(4, 6)
var hw_id = data.slice(6, 8)
var sample_cnt = data.slice(8, 10)
//
if (this.dev_add_fp_step == 0x00) //录入开始
{
this.dev_fp_sample_cnt = 0
this.dev_add_fp_step_sum = hex2int(sample_cnt) //需录入次数
this.addNewFingerCallback()
} else if (this.dev_add_fp_step == 0xFC) //录入进行
{
this.dev_fp_sample_cnt = hex2int(sample_cnt)
} else if (this.dev_add_fp_step == 0xFF) //录入完成
{
this.dev_add_fp_hw_id = hex2int(hw_id)
this.dev_fp_sample_cnt = hex2int(sample_cnt)
} else //0xFD录入失败 0xFE录入取消
{
this.dev_fp_sample_cnt = hex2int(sample_cnt)
}
}
clear_add_new_fp() {
this.dev_fp_sample_cnt = 0
this.dev_add_fp_step = 0
this.dev_add_fp_hw_id = 0
this.addNewFingerCallback = {}
}
//删除指纹
msg_remove_finger_print(user_id, hw_id, callback) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "0D"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
this.remove_fp_callback = callback
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_user_id = get_hex_str(user_id, 2)
var msg_hw_id = get_hex_str(hw_id, 2)
var msg_data = msg_type + msg_user_id + msg_hw_id
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
// console.log('************ msg0', msg0)
this.repeat_send_bt_msg(msg0)
}
//删除指纹反馈接收处理
rev_remove_finger_print_hardler(data, len) {
console.log("### rev_remove_finger_print_hardler删除指纹反馈")
var user_id = data.slice(2, 4)
var hw_id = data.slice(4, 6)
var ack = hex2int(data.slice(6, 8))
console.log("删除指纹反馈", user_id, hw_id, ack)
if(ack == 0x00){
this.remove_fp_callback(1)
}else{
this.remove_fp_callback(2)
this.res_fail_dispose(ack)
}
}
//添加管理员新密码
msg_add_new_admin_passwd(passwd, callback = {}) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "07"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
var msg_hw_id = "FF"
this.set_new_admin_passwd_callback = callback
console.log('############ start msg_add_new_admin_passwd添加管理员新密码')
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_step = "00"
var admin = "01"
var memberId = "01" //管理员写死01
var msg_passwd_len = get_hex_str(passwd.length, 2)
var msg_passwd = get_num2hex(passwd)
var msg_data = msg_type + msg_step + admin + memberId + msg_hw_id + msg_ts_start + msg_ts_end +
msg_passwd_len + msg_passwd
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
//删除密码
msg_remove_passwd(user_id, hw_id, callback) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "0E"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
this.remove_passwd_callback = callback
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_user_id = get_hex_str(user_id, 2)
var msg_hw_id = get_hex_str(hw_id, 2)
var msg_data = msg_type + msg_user_id + msg_hw_id
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
//删除密码反馈
rev_remove_passwd_hardler(data, len) {
console.log("### rev_remove_passwd_hardler删除密码反馈")
var user_id = data.slice(2, 4)
var hw_id = data.slice(4, 6)
var ack = hex2int(data.slice(6, 8))
console.log("### 删除密码反馈数据", user_id, hw_id, ack)
if(ack == 0x00){
this.remove_passwd_callback(1)
}else{
this.remove_passwd_callback(2)
this.res_fail_dispose(ack)
}
}
/**
* 设置设备音量
*/
msg_update_volume(volume, callback) {
var msg_head = "55AA" //头部
var msg_ext = "00" //版本
var msg_cmd = "03" //命令
var msg_ts = ""
var msg_type = "03"
this.update_volume_callback = callback
var volume = get_hex_str(volume, 2)
// var msg_hw_id = get_hex_str(hw_id, 2)
// msg_type +
var msg_data = msg_type + volume
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('************ 设置音量', msg_data)
this.repeat_send_bt_msg(msg0)
}
/**
* 设置设备音量反馈
*/
rev_update_volume_hardler(data, len) {
var ack = hex2int(data.slice(2, 4))
console.log("^^^^^rev_update_volume_hardler音量反馈", ack)
if(ack == 0x00){
this.update_volume_callback(1)
}else{
this.update_volume_callback(2)
this.res_fail_dispose(ack)
}
}
/**
* 设置设备语言
*/
msg_update_language(language, callback) {
var msg_head = "55AA" //头部
var msg_ext = "00" //版本
var msg_cmd = "0A" //命令
var msg_len = "0000" //命令长度
var msg_ts = ""
var msg_type = "00"
this.update_language_callback = callback
var language = get_hex_str(language, 2)
var msg_data = msg_type + language
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('************ 设置语言', msg_data)
this.repeat_send_bt_msg(msg0)
}
/**
* 设置设备语言反馈
*/
rev_update_language_hardler(data, len) {
var ack = hex2int(data.slice(2, 4))
console.log("^^^^^rev_update_language_hardler设置语言回调", ack)
if(ack == 0x00){
this.update_language_callback(1)
}else{
this.update_language_callback(2)
this.res_fail_dispose(ack)
}
}
//添加普通用户新密码 添加密码
msg_add_new_passwd(password, memberId, callback = {}) {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "07"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
var msg_hw_id = "FF"
// console.log('############ start msg_add_new_passwd')
this.set_new_admin_passwd_callback = callback
// var msg_ts_start = get_time_ts(0)
// var msg_ts_end = get_time_ts(600)
var msg_ts_start = 'FFFFFFFF' //时间戳先写死
var msg_ts_end = 'FFFFFFFF' //时间戳先写死
var msg_step = "00"
var user = "00" //00普通成员 01管理员
var msg_user_id = get_hex_str(memberId, 2) //成员id
var msg_passwd_len = get_hex_str(password.length, 2) //密码长度
var msg_passwd = get_num2hex(password) //密码
var msg_data = msg_type + msg_step + user + msg_user_id + msg_hw_id + msg_ts_start + msg_ts_end +
msg_passwd_len + msg_passwd
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('************ msg0', msg0)
this.repeat_send_bt_msg(msg0)
}
//添加新密码反馈
rev_add_new_passwd_hardler(data, len) {
console.log("### rev_add_new_passwd_hardler添加新密码反馈", data)
var user_id = data.slice(4, 6)
var hw_id = hex2int(data.slice(6, 8))
var ack = hex2int(data.slice(8, 10)) //应答码 //判断是否添加成功
console.log("添加新密码反馈，ack：",ack,'user_id：', user_id,'hw_id：',hw_id)
this.hardwareId = hw_id
if ("bt_pair_add_new_admin_passwd_start" == this.task_bt_pair_status) {
this.task_bt_pair_status = "bt_pair_srv_create_bt_dev_start"
console.log('设置管理员密码')
}
if (this.task_member_passwd_status == "member_passwd_add_start") {
this.task_member_passwd_status = "member_passwd_add_ok"
}
if(ack == 0x00){
// 设置密码回调 (成功状态,固件id)
this.set_new_admin_passwd_callback(1, this.hardwareId)
}else{
this.set_new_admin_passwd_callback(2)
this.res_fail_dispose(ack)
}
}
/**
* @param {string} link 下载地址
* @param {Function} callback 回调
*/
download_update_fw(link, callback) {
var that = this
const downloadTask = uni.downloadFile({
url: link,
filePath: `${wx.env.USER_DATA_PATH}/ota.bin`,
success: (res) => {
if (res.statusCode === 200) {
console.log('###################下载成功');
uni.getFileSystemManager().readFile({
filePath: `${wx.env.USER_DATA_PATH}/ota.bin`,
encoding: 'hex',
position: 0,
success(res) {
// var md5 = SparkMD5.hashBinary(res.data).toString().toUpperCase()
that.update_file_data = res.data
console.log('that.update_file_data文件数据：',res.data.length )
console.log('************ 固件下载成功', get_hex_str(res.data.length,8))
callback(1)
},
fail(res) {
console.error(res)
uni.showToast({
title:'文件下载失败',
icon:'none'
})
callback(-1)
}
})
}
},
fail(err) {
uni.showToast({
title:'文件下载失败',
icon:'none'
})
callback(-1)
}
});
}
// OTA升级任务
task_update_hardler(callback={}) {
console.log('OTA升级任务')
this.msg_app_update_start()
this.upgradeCallback = callback
}
//校验设备是否可升级
msg_app_update_start() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "FA" //APP下发升级指令
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
var msg_update_status = "00" //升级状态(0x00有固件可升级 0x01升级开始 0x02升级成功 0x03升级失败)
var msg_update_type = "01" //固件类型(0x00模组固件 0x01MCU固件)
var msg_data = msg_type + msg_update_status + msg_update_type
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('************校验设备是否可升级msg0', msg0)
this.repeat_send_bt_msg(msg0)
}
//是否可升级反馈
rev_app_update_start_hardler(data, len) {
var ack = hex2int(data.slice(2, 4)) //(0x00允许升级 0x01电量不足拒绝升级 0x02其他原因)
// console.log("### update_hardler_status", this.update_hardler_status)
console.log("### rev_app_update_start_hardler是否可升级反馈", ack)
if (ack == 0x00 ) {
this.msg_app_update_pkg_start()
}else if(ack == 0x01){
uni.showToast({
title:'电量过低，无法升级',
icon:'error'
})
this.upgradeCallback('fail')
}
}
//开始下发升级包
msg_app_update_pkg_start() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "FB" //APP下发升级包
var msg_type = "00"
var msg_pkg_len = get_hex_str(this.update_file_data.length/2,8) //固件包大小(0000FC00=64512),4字节
var msg_data = msg_type + msg_pkg_len
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('************APP下发升级包msg0','包大小：', msg_pkg_len)
this.repeat_send_bt_msg(msg0)
}
//开始下发升级包反馈
rev_app_update_pkg_start_hardler(data, len) {
var pkg_size = data.slice(2, 4) //升级包传输大小选择(0x00分包大小64字节 0x01分包大小128字节 0x02分包大小256字节)
console.log("### rev_app_update_pkg_start传输开始反馈传输大小",this.update_file_data.length, pkg_size)
if (pkg_size == "00") {
this.pkg_size = 64 *2
} else if (pkg_size == "01") {
this.pkg_size = 128 *2
} else if (pkg_size == "02") {
this.pkg_size = 256 *2
}
// 计算需要发送几包
this.page_num = Math.ceil(this.update_file_data.length/this.pkg_size)
this.current_page = 0
this.msg_app_update_pkg_data_send()
}
//开始下发升级包数据
msg_app_update_pkg_data_send() {
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "FC" //APP下发传输数据
var msg_ts = ""
var msg_type = "00"
var msg_hw_id = "FF"
// 偏移量
var offset_str = get_hex_str(this.current_page*this.pkg_size/2,8)
// 文件数据包
var msg_file_data = this.update_file_data.slice(this.current_page*this.pkg_size,this.current_page*this.pkg_size+this.pkg_size)
var msg_data = msg_type + offset_str + msg_file_data
console.log('发送OTA升级数据', '第几包：',this.current_page,'偏移量：',offset_str,'数据：',msg_file_data)
var msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
this.repeat_send_bt_msg(msg0)
}
//下发升级包数据反馈
rev_app_update_pkg_data_send_hardler(data, len) {
let pack = hex2int(data.slice(2, 10))
let ack = hex2int(data.slice(10, 12))
console.log("### rev_app_update_pkg_data_send发包后反馈",ack, pack, this.current_page*this.pkg_size/2)
console.log("### rev_app_update_pkg_data_send发包后反馈",'当前包：',this.current_page,'总包：',this.page_num)
if (ack == 0x00 && (pack == this.current_page*this.pkg_size/2) ) {
this.upgradeCallback(this.current_page/(this.page_num-1))
if((this.current_page+1) ==this.page_num ){
// 最后一包发送成功
// setTimeout(()=>{},3000)
this.upgradeCallback('success')
return
}
console.log("### 发包成功")
this.current_page++
this.msg_app_update_pkg_data_send()
}else{
this.upgradeCallback('fail')
}
}
// 清空升级数据
clear_pkg_data(){
this.current_page = 0
this.pkg_size = 0
this.page_num = 0
this.update_file_data=""
this.upgradeCallback = {}
}
//获取锁信息
msg_get_dev_info(callback = {}) {
console.log('msg_get_dev_info获取锁信息...')
var msg_head = "55AA"
var msg_ext = "00"
var msg_cmd = "00"
var msg_len = "0000"
var msg_ts = ""
var msg_type = "00"
msg_ts = get_time_ts(0)
this.get_dev_info_callback = callback
console.log('deviceNum *****', this.deviceNum)
var msg_data = msg_type + msg_ts + string2Hex(this.deviceNum)
msg_len = get_msg_len(msg_data)
var msg0 = msg_head + msg_ext + msg_cmd + msg_len + msg_data
console.log('msg0 *****', msg0)
this.repeat_send_bt_msg(msg0)
}
//获取锁信息反馈
rev_lock_info_hardler(data, len) {
console.log("### rev_lock_info_hardler获取锁信息反馈")
this.dev_pid = data.slice(0, 15 * 2)
// this.dev_soft_version = data.slice(15 * 2, 18 * 2 )
// 版本号：每两位转成十进制再拼接
this.dev_soft_version ='' + hex2int(data.slice(15 * 2,16*2)) + hex2int(data.slice(16 * 2,17*2)) +hex2int(data.slice(17 * 2,18*2))
this.dev_passwd = data.slice(18 * 2, 20 * 2).toString().toUpperCase()
this.dev_lock_status = data.slice(20 * 2, 21 * 2)
// console.log("this.dev_pid", this.dev_pid)
// console.log("this.dev_soft_version", this.dev_soft_version)
// console.log("this.dev_passwd", this.dev_passwd)
// console.log("this.dev_lock_status", this.dev_lock_status)
if (JSON.stringify(this.get_dev_info_callback) != "{}") {
this.get_dev_info_callback(this.dev_soft_version)
}
if (this.dev_lock_status == "58") {
//this.task_bt_pair_status = "bt_pair_add_new_admin_passwd_start"
this.task_bt_pair_status = "bt_pair_get_lock_info_end"
} else {
uni.showToast({
title:'该设备未进入初始化模式',
icon:'none',
})
this.task_bt_pair_status = "bt_pair_lock_status_busy"
}
}
// report_type /family/log 开锁记录
// report_type /family/police 告警记录
srv_add_record(report_data, report_type) {
console.log('@@@@@@@@@ srv_add_record report_data记录上报', report_data)
var myJSON = JSON.stringify(report_data);
if (report_type == 1) {
// postFamilyLog(myJSON).then(res => {
// this.msg_get_open_record_ack()
// })
} else if (report_type == 2) {
// postFamilyPolice(myJSON).then(res => {
// this.msg_get_open_record_ack()
// })
}
Promise.all()
}
//实际发送数据
do_send_bt_msg(msg0, cnt) {
if (!this.writeuuid) {
console.log('UUID为空', this.writeuuid)
return
}
var msg0_hex = hex2String(msg0)
var md5 = SparkMD5.hashBinary(msg0_hex).toString().toUpperCase()
var msg = msg0 + md5
var sum_data = ''
sum_data = get_sum(msg)
msg = msg0 + md5 + sum_data
console.log('#######发送的完整信息', msg)
var hex2 = hex2String(msg)
var encrypted = data_encrypt(hex2, this.dev_key_md5_hex)
var data = string2Hex(encrypted.out)
for (let i = 0; i < cnt; i++) {
this.write(data)
}
}
//实际发送数据 有重发机制
repeat_send_bt_msg(msg0) {
if (!this.writeuuid) {
console.log('UUID为空', this.writeuuid)
return
}
var msg0_hex = hex2String(msg0)
var md5 = SparkMD5.hashBinary(msg0_hex).toString().toUpperCase()
var msg = msg0 + md5
var sum_data = ''
sum_data = get_sum(msg)
msg = msg0 + md5 + sum_data
console.log('#######发送的完整信息', msg)
var hex2 = hex2String(msg)
var encrypted = data_encrypt(hex2, this.dev_key_md5_hex)
var data = string2Hex(encrypted.out)
// 如果重复发送，清除之前的定时器
this.clear_Interval()
// 重发机制
var intervalFun = ()=>{
if(this.second>5){
console.log('重发数据失败')
this.clear_Interval()
if(JSON.stringify(this.upgradeCallback) != "{}") this.upgradeCallback('fail')
return uni.showToast({
title:'操作失败,请重试',
icon:'none'
})
}
this.second+=1
console.log('重发数据....',`次数:第${this.second}次`)
this.write(data)
// 第一次直接执行发送，所以写成这种形式
return intervalFun
}
this.repeatFailTimer = setInterval(intervalFun(),1000)
}
// 清除重发定时
clear_Interval(){
this.second = 0
if(this.repeatFailTimer)clearInterval(this.repeatFailTimer)
this.repeatFailTimer = null
}
//建立连接
createBLEConnection() {
if(this.searchTimer){
clearTimeout(this.searchTimer)
}
// let that = this;
uni.showLoading({
title: '连接中，请稍等',
mask: true,
});
console.log('建立连接-----this.deviceId', this.deviceId)
uni.createBLEConnection({
deviceId: this.deviceId,
success: (res) => {
console.log('##########蓝牙连接成功...')
this.getBLEDeviceServices(); // 获取蓝牙的服务
this.bluetoothState = 1
store.commit('setBluetoothState',1)
uni.hideLoading()
uni.showToast({
title: this.bt_info.name + "蓝牙连接成功！",
icon: "none",
});
},
fail: (err) => {
console.log('连接err',err)
uni.hideLoading()
this.bluetoothState = 0
store.commit('setBluetoothState',0)
uni.showToast({
title: (this.bt_info?.name || '') + "蓝牙连接失败",
icon: "none",
});
this.closeBLEConnection() //断开连接
this.unloadBluetooth()
},
complete:()=>{
this.stopBluetoothDevicesDiscovery(); // 停止搜索蓝牙
}
});
}
startBluetoothDeviceDiscovery() {
// 发现外围设备
console.log('##########进去搜索...')
setTimeout(()=>{
uni.showLoading({
title: "搜索中，请稍等",
mask: true
});
uni.startBluetoothDevicesDiscovery({
allowDuplicatesKey:true,
success: (res) => {
this.bluetoothSearchState = 1
console.log('##########成功搜索附近的蓝牙设备...')
this.onBluetoothDeviceFound()
// 10秒搜索时间失败处理
this.searchBTFail()
},
fail: err => {
this.bluetoothSearchState = 0
this.bluetoothState = 0
store.commit('setBluetoothState',0)
uni.hideLoading()
console.log(err, '开始搜索蓝牙设备备错误信息')
}
})
},300)
}
// 设置搜索蓝牙超时定时器
searchBTFail() {
this.searchTimer = setTimeout(() => {
uni.hideLoading()
this.stopBluetoothDevicesDiscovery(); // 停止搜索蓝牙
uni.showToast({
title: "蓝牙搜索超时，请靠近门锁",
icon: "error",
duration: 2000
})
this.bluetoothState = 0
clearTimeout(this.searchTimer)
this.searchTimer = null
}, 15*1000)
}
// 停止搜索蓝牙
stopBluetoothDevicesDiscovery() {
if(this.searchTimer)clearTimeout(this.searchTimer)
this.searchTimer = null
uni.stopBluetoothDevicesDiscovery({
success: e => {
this.loading = false
this.bluetoothSearchState = 0
console.log('##########停止搜索蓝牙设备:' + e.errMsg);
},
fail: e => {
console.log('停止搜索蓝牙设备失败，错误码：' + e.errCode);
}
});
}
getBLEDeviceServices() {
setTimeout(() => {
uni.getBLEDeviceServices({
// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
deviceId: this.deviceId,
success: (res) => {
console.log('##########获取蓝牙设备的所有服务', res)
// 可以和做硬件的沟通 他会直接给你一个 也可以自己从res里取值
// res.services 是所有的服务
this.serviceId = this.bt_info['advertisServiceUUIDs'][0]
// item["serviceId"] = item["advertisServiceUUIDs"][
// 0] //this.advertisServiceUUIDs[0] //'00004354-0000-1000-8000-00805F9B34FB';
// // //进入特征
this.getBLEDeviceCharacteristics();
// 监听蓝牙状态
}
}, (err) => {
console.log('##########获取蓝牙设备的所有服务失败', err)
});
}, 1000);
}
getBLEDeviceCharacteristics() {
let that = this
setTimeout(() => {
uni.getBLEDeviceCharacteristics({
deviceId: this.deviceId,
serviceId: this.serviceId,
success: (res) => {
// res.characteristics 特征值列表
// 读写都需要用到特征值
console.log("##########获取特征值列表", res.characteristics);
this.characteristics0 = res.characteristics[0]
this.characteristics1 = res.characteristics[1]
this.writeuuid = res.characteristics[0]['uuid']
this.notifyuuid = res.characteristics[1]['uuid']
console.log("#####uuid ", this.writeuuid, this.notifyuuid);
this.notifyBLECharacteristicValueChange()
this.onBLEConnectionStateChange()
},
fail: (res) => {
console.log('##########fail...获取特征值列表失败', res);
}
});
}, 1000);
}
// 16进制字符串转ArrayBuffer
hex2ArrayBuffer(hex_str) {
// let hex_str = 'AA5504B10000B5'
let typedArray = new Uint8Array(hex_str.match(/[\da-f]{2}/gi).map(function(h) {
return parseInt(h, 16)
}))
let buffer = typedArray.buffer
return buffer
}
//设置蓝牙接受函数
notifyBLECharacteristicValueChange() {
let that = this
uni.notifyBLECharacteristicValueChange({
state: true, // 启用 notify 功能
deviceId: that.deviceId,
serviceId: that.serviceId,
characteristicId: this.notifyuuid,
success: (res) => {
console.log("启用 notify 功能成功", res);
this.listenValueChange()
if (this.task_bt_pair_status == "bt_pair_connect_start" ) {
this.task_bt_pair_status = "bt_pair_connect_ok"
this.bindStep = 1
this.bindStepCallback(1)
uni.showLoading({
title:'设置中...',
mask:true
})
// this.bindStep = 1
// this.bindStepCallback(1)
}
},
fail: (res) => {
console.log("启用 notify 功能失败", res);
uni.hideLoading();
}
});
}
//蓝牙设备搜索
onBluetoothDeviceFound() {
uni.onBluetoothDeviceFound((res) => {
// res.devices 是所有的设备
if (res.devices[0]["localName"] == "Lenovo") {
console.log('onBluetoothDeviceFound监听搜索到新设备的事件', res.devices[0])
let bt_info = res.devices[0]
let ad_info = res.devices[0]["advertisData"]
let ad_info_i8 = new Uint8Array(ad_info)
let ad = ad_info_i8[0].toString(16).padStart(2, 0).toUpperCase() + ad_info_i8[1].toString(
16).padStart(2, 0).toUpperCase()
console.log('******** ad3 ',ad_info,ad_info_i8, ad)
bt_info.bt_mac = ad
console.log('bt_info...', bt_info, this.deviceNum, this.dev_crc16)
//当蓝牙的广播数据与设备号的crc16相同时认为是所搜索到的设备
if (bt_info.bt_mac == this.dev_crc16) {
uni.hideLoading()
console.log('******** 开始连接 ')
this.bt_info = bt_info
this.deviceId = this.bt_info.deviceId
this.createBLEConnection()
}
}
// 采集器蓝牙 deviceNum为空时
if (this.deviceNum =='' && res.devices[0]["localName"] == "E5B_HARVESTER") {
uni.hideLoading()
let bt_info = res.devices[0]
this.bt_info = bt_info
this.deviceId = this.bt_info.deviceId
this.createBLEConnection()
}
})
}
//蓝牙数据接受处理函数
listenValueChange() {
uni.onBLECharacteristicValueChange(res => {
try {
var rev_data = arrayBuffer2Hex(res.value)
var dcd = data_decrypt(hex2String(rev_data), this.dev_key_md5_hex)
var data = string2Hex(dcd.out)
console.log("###接收的明文数据data", data)
var vesion = ''
var cmd = ''
var data_len = ''
var head = ''
var data_input = ''
var head = data.slice(0, 4)
if (head == "55aa") {
vesion = data.slice(4, 6)
cmd = data.slice(6, 8)
data_input = data.slice(12)
data_len = hex2int(data.slice(8, 12))
var data_cal = data.slice(0, 12 + data_len * 2)
var md5_cal = SparkMD5.hashBinary(hex2String(data_cal)).toString()
var total_data = data_cal + md5_cal
var sum_cal = get_sum(total_data).padStart(2, '0').toLowerCase()
var md5 = data_input.slice(data_len * 2, -2)
var sum = data_input.slice((data_len) * 2 + 32)
// 锁端MD5和前端MD5对比,判断数据完整性
if (md5_cal == md5 && md5_cal != "" && md5 != "") {
if (sum_cal == sum && sum_cal != "" && sum != "") {
this.clear_Interval()
// console.log('cmd',cmd)
if (cmd == "00") //获取锁信息
{
this.rev_lock_info_hardler(data_input, data_len)
}
if (cmd == "01") //获取开锁记录
{
this.rev_open_record_hardler(data_input, data_len)
} else if (cmd == "02") //开锁反馈
{
this.rev_open_door_hardler(data_input, data_len)
} else if (cmd == "03") //音量反馈
{
this.rev_update_volume_hardler(data_input, data_len)
} else if (cmd == "05") //添加指纹反馈
{
this.rev_add_new_finger_print_hardler(data_input, data_len)
} else if (cmd == "06") //添加卡片反馈
{
this.rev_add_new_card_hardler(data_input, data_len)
} else if (cmd == "07") //添加密码反馈
{
this.rev_add_new_passwd_hardler(data_input, data_len)
}else if (cmd == "08") //锁电量上报反馈
{
this.rev_electric_hardler(data_input, data_len)
}
else if (cmd == "0a") //语言设置反馈
{
this.rev_update_language_hardler(data_input, data_len)
} else if (cmd == "14") //恢复锁反馈
{
this.rev_reset_lock_hardler(data_input, data_len)
} else if (cmd == "0e") //删除密码反馈
{
this.rev_remove_passwd_hardler(data_input, data_len)
} else if (cmd == "0d") //删除指纹反馈
{
this.rev_remove_finger_print_hardler(data_input, data_len)
} else if (cmd == "0f") //删除卡片反馈
{
this.rev_remove_card_hardler(data_input, data_len)
} else if (cmd == "fa") //开始进入升级反馈（校验是否可以升级）
{
this.rev_app_update_start_hardler(data_input, data_len)
} else if (cmd == "fb") //传输升级包信息反馈
{
this.rev_app_update_pkg_start_hardler(data_input, data_len)
} else if (cmd == "fc") //开始接受升级包反馈
{
this.rev_app_update_pkg_data_send_hardler(data_input, data_len)
} else if (cmd == "21") //采集器开始录入指纹反馈
{
this.res_collect_finger_print_hardler(data_input, data_len)
} else if (cmd == "22") //采集器上发指纹数据反馈
{
this.rev_send_finger_print_hardler(data_input, data_len)
} else if (cmd == "23") //采集器录入卡片接收反馈
{
this.res_collect_card_hardler(data_input, data_len)
}
else if (cmd == "11") //同步指纹数据到门锁
{
this.res_sync_finger_print_hardler(data_input, data_len)
}
else if (cmd == "12") //同步卡片数据到门锁
{
this.res_sync_card_hardler(data_input, data_len)
}
}else{
console.log("##### 长度不匹配!!!!!!! ")
}
} else {
console.log("##### rev sum is not ok MD5验证不通过!!!!!!! ")
console.log("##### rev this.update_hardler_status !!!!!!! ", this
.update_hardler_status)
//this.update_hardler_status = "app_pkg_data_ng"
}
}
} catch (err) {
console.log("##### rev err ", err);
}
})
}
/**
* 应答码错误处理提示
*/
res_fail_dispose(code){
let obj = [{
msg:'操作失败',
code:0x01,
},{
msg:'重复录入',
code:0x02,
},{
msg:'硬件ID分配完',
code:0x03,
},{
msg:'添加密码错误，字段为非数字',
code:0x04,
},{
msg:'添加密码错误，密码长度错误',
code:0x05,
},{
msg:'不支持添加的开锁方式',
code:0x06,
},{
msg:'当前正在录入指纹',
code:0x07,
},{
msg:'当前正在绑定门卡',
code:0x08,
},{
msg:'当前正在绑定人脸',
code:0x09,
},{
msg:'密码过于简单',
code:0x0A,
},{
msg:'错误硬件',
code:0x0B,
}]
obj.forEach(v=>{
if(v.code ==code){
uni.showToast({
title:`${v.msg}`,
icon:'none',
duration:2000,
mask:true
})
}
})
}
ab2hex(buffer, split = '') {
var hexArr = Array.prototype.map.call(new Uint8Array(buffer), function(bit) {
return ('00' + bit.toString(16)).slice(-2)
})
return hexArr.join(split)
}
/**
* 写入数据
* 微信小程序有数据大小限制，分包传输
*/
write(hexadecimal) {
var buf = hex2ArrayBuffer(hexadecimal)
return new Promise((resolve, reject) => {
var byte_cnt = 20
var index = Math.floor(buf.byteLength / byte_cnt)
if (buf.byteLength % byte_cnt > 0) {
index += 1
}
var i = 0
var offset = 0
for (i = 0; i < index; i++) {
var buf_tmp = buf.slice(offset, offset + byte_cnt)
offset += byte_cnt
uni.writeBLECharacteristicValue({
deviceId: this.deviceId,
serviceId: this.serviceId,
characteristicId: this.writeuuid,
value: buf_tmp,
success: (res) => {
},
fail: (err) => {
console.log('write写入失败', err)
}
})
}
})
}
openBluetoothAdapter() {
this.bluetoothState = 2
let that = this
uni.openBluetoothAdapter({ //打开蓝牙适配器接口
success: (res) => { //已打开
console.log('openBluetoothAdapter ok... ----蓝牙已打开')
this.dev_crc16 = calculateCRC16Modbus(strToHexCharCode(this.deviceNum)).padStart(4, 0)
.toUpperCase()
// 获取已搜索到的蓝牙设备
uni.getBluetoothDevices({
success:(res) => {
console.log('11111111获取之前搜索到的蓝牙设备',res)
let flag = true
res.devices.forEach(item=>{
if (item["localName"] == "Lenovo_E5B") {
console.log('onBluetoothDeviceFound监听搜索到新设备的事件', item)
let bt_info = item
let ad_info = item["advertisData"]
let ad_info_i8 = new Uint8Array(ad_info)
let ad = ad_info_i8[0].toString(16).padStart(2, 0).toUpperCase() + ad_info_i8[1].toString(
16).padStart(2, 0).toUpperCase()
console.log('******** ad3 ',ad_info,ad_info_i8, ad)
bt_info.bt_mac = ad
console.log('bt_info...', bt_info, this.deviceNum, this.dev_crc16)
//当蓝牙的广播数据与设备号的crc16相同时认为是所搜索到的设备
if (bt_info.bt_mac == this.dev_crc16) {
console.log('******** 开始连接 ')
this.bt_info = bt_info
flag = false
this.deviceId = this.bt_info.deviceId
this.createBLEConnection()
}
}
// 采集器蓝牙 deviceNum为空时
if (this.deviceNum =='' && res.devices[0]["localName"] == "E5B_HARVESTER") {
this.bt_info = item
flag = false
this.deviceId = this.bt_info.deviceId
this.createBLEConnection()
}
})
if(flag)this.startBluetoothDeviceDiscovery()
},fail:(err)=> {
console.log('getBluetoothDevices获取搜索过的设备失败',err)
this.startBluetoothDeviceDiscovery()
}
})
},
fail: err => { //未打开
this.bluetoothState = 0
console.log('打开蓝牙适配器err', err)
if (err.errMsg === 'openBluetoothAdapter:fail auth deny') {
uni.showModal({
title: '温馨提示',
content: `获取蓝牙权限失败，是否进入设置页开启您的权限？`,
confirmText: '开启授权',
success: (showModalRes) => {
if (showModalRes.confirm) {
uni.openSetting({
success: (openSettingRes) => {
this.openBluetoothAdapter()
// if (openSettingRes.authSetting['scope.bluetooth']) {
// }
}
});
}
}
})
} else if (err.errCode == 10001) {
uni.showToast({
icon: 'none',
title: '请查看手机蓝牙是否打开',
duration:2000
});
} else {
uni.showToast({
icon: 'none',
title: `蓝牙打开失败,${err.errMsg}`
});
}
}
})
}
closeBluetoothAdapter() {
uni.closeBluetoothAdapter({
success(res) {
console.log(res)
}
})
}
/**
* 卸载本机蓝牙的事件
*/
unloadBluetooth() {
uni.closeBluetoothAdapter();
}
/**
* 断开与低功耗蓝牙设备的连接
*/
closeBLEConnection(){
store.commit('setBluetoothState',0)
uni.closeBLEConnection({
deviceId:this.deviceId,
success(res) {
console.log(res)
}
})
}
/**
* 监听蓝牙适配器状态变化事件
* @param {function} cb 处理状态变化的函数
*/
onBluetoothStateChange(cb) {
uni.onBluetoothAdapterStateChange(res => {
const {
available,
discovering
} = res;
console.log('onBluetoothAdapterStateChange 监听蓝牙适配器状态变化事件',res)
// this.updateBluetoothState(res); // 更新蓝牙适配器状态
if (res.available && !res.discovering && !initSuccess) {
console.log('deviceManage 手机蓝牙打开')
}
// 适配器关闭
if (!res.available) {
console.log('deviceManage 手机蓝牙关闭')
initSuccess = false
this.bluetoothState = 0
// this.unloadBluetooth();
}
// 适配器打开并且处于搜索状态
if (res.available && res.discovering) {
console.log('deviceManage 处于搜索状态')
}
// 适配器打开并且处于停止搜索状态
if (!res.discovering && initSuccess) {
console.log('deviceManage 停止搜索状态')
}
})
}
/**
* 监听低功耗蓝牙连接状态的改变事件。
* 包括开发者主动连接或断开连接，设备丢失，连接异常断开等等
* 重连
*/
onBLEConnectionStateChange() {
uni.onBLEConnectionStateChange((res) => {
console.log('连接状态变更', res)
// 该方法回调中可以用于处理连接意外断开等异常情况
if (!res.connected) {
this.bluetoothState = 0
store.commit('setBluetoothState',0)
uni.showToast({
title: '蓝牙已断开',
icon: 'none',
mask:true,
duration:2000
})
// uni.showModal({
// title: "蓝牙连接断开",
// content: "是否重连",
// success: (e) => {
// if (e.confirm) this.reconnectBlue()
// }
// })
}
})
}
/**
* 蓝牙重连
*/
reconnectBlue() {
this.closeBLEConnection()
this.bluetoothState = 2
if(!this.deviceId){
this.bt_open_start()
}else {
uni.showLoading({
title: '连接中，请稍等...',
mask: true,
});
uni.createBLEConnection({
deviceId: this.deviceId,
success:()=> {
this.bluetoothState = 1
store.commit('setBluetoothState',1)
uni.hideLoading()
uni.showToast({
title: this.bt_info.name + "蓝牙连接成功！",
icon: "none",
});
this.getBLEDeviceServices(); // 获取蓝牙的服务
console.log("蓝牙重连成功！")
},
fail:(err)=> {
console.log("蓝牙重连失败",err)
uni.hideLoading()
// uni.showToast({
// title: this.bt_info.name + "蓝牙连接成功！",
// icon: "none",
// });
this.bluetoothState = 0
store.commit('setBluetoothState',0)
}
})
}
}
}
var APP_BT_TASK
var APP_BT_TASK_LIST
var APP_BT_TASK_LIST_MAP
export function unloadBluetooth() {
console.log('1111closeBluetoothAdapter')
uni.closeBluetoothAdapter();
}
export function create_bt_task(id) {
if (APP_BT_TASK_LIST_MAP) {
} else {
APP_BT_TASK_LIST_MAP = new Map();
}
if (false == APP_BT_TASK_LIST_MAP.has(id)) {
console.log("*********** new BtTask @@@@@@@");
var bt = new BtTask(id)
APP_BT_TASK_LIST_MAP.set(id, bt)
return APP_BT_TASK_LIST_MAP.get(id)
} else {
console.log("*********** seek BtTask @@@@@@@");
return APP_BT_TASK_LIST_MAP.get(id)
}
}
export function get_bt_task(id) {
if (true == APP_BT_TASK_LIST_MAP.has(id)) {
return APP_BT_TASK_LIST_MAP.get(id)
} else {
return false
}
}
export function stop_all_bt_task() {
if (APP_BT_TASK_LIST_MAP) {
APP_BT_TASK_LIST_MAP.forEach((item, key) => {
console.log("##########key ", key)
console.log("stop_all_bt_task item ", item)
item && item.clear_task()
})
}
}
2042
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
