1299 lines
31 KiB
JavaScript
1299 lines
31 KiB
JavaScript
// 蓝牙设备结果集
|
||
let devices = []
|
||
|
||
// 当前连接的蓝牙设备
|
||
let device = ''
|
||
|
||
// 蓝牙设备id
|
||
let deviceId = ''
|
||
|
||
|
||
// 写了数据等待通知结果返回
|
||
let waitingForResult = false
|
||
|
||
// 连接状态
|
||
let isConnecting = false
|
||
let connected = false
|
||
|
||
// 服务 uuid 和 特征值 uuid
|
||
//正式
|
||
//测试
|
||
|
||
let service_uuid = "0000AE30-0000-1000-8000-00805F9B34FB"
|
||
let write_characteristic = "0000AE03-0000-1000-8000-00805F9B34FB"
|
||
let notify_characteristic = "0000AE03-0000-1000-8000-00805F9B34FB"
|
||
let notify_characteristic_2 = "0000AE02-0000-1000-8000-00805F9B34FB"//获取设备电量和设备mac地址
|
||
|
||
// 命名规则
|
||
let rule1 = "" // Android
|
||
let rule2 = "" // ios
|
||
|
||
// 手动断开
|
||
var manualDisconnect = true
|
||
|
||
// #################################################
|
||
// #
|
||
// # Callback Definitions
|
||
// #
|
||
// #################################################
|
||
|
||
// 回调事件
|
||
let connectCallback = '' // 连接成功回调
|
||
let scanCallback = '' // 搜索到蓝牙设备回调
|
||
let disconnectCallback = '' // 设备断开连接回调
|
||
let writeCallback = '' // 写成功回调
|
||
// 自定义 业务相关 回调事件
|
||
let realtimeCallback = '' // 实时发送指令的回调
|
||
let batteryCallback = '' // 电量回调
|
||
let macCallback = '' // MAC地址回调
|
||
let lastBatteryLevel = 'N/A';
|
||
|
||
// 自定义 业务相关 标识
|
||
let realtimeType = '' // 实时发送指令的标识
|
||
|
||
|
||
// 重连相关
|
||
let reconnectTimes = 0 // 重连次数
|
||
let reconnectTimer // 重连计时器
|
||
|
||
// 因为有心跳自动计时器发送，不是全是用户手动的操作，用户的手动操作设定为一个操作后才能操作下一个，但有自动心跳发送的话，可能会出现发送心跳时，
|
||
// 用户也正好操作了，那这时可能会出现，同时写两条指令情况，即没收到上一条的回复就发送了下一条指令，现用数组暂存
|
||
let cmdList = [] // 看这里！！！ 现在没有心跳，只有用户的操作，确保用户的操作都是有回复的，并且在队列内，等待前一条执行完才执行下一条
|
||
|
||
// 当前蓝牙适配器是否打开的状态
|
||
let isOpen = false
|
||
|
||
// 自动连接
|
||
let auto_connect = false
|
||
|
||
// 准备去自动连接的 deviceId
|
||
let auto_mac = []
|
||
let auto_mac_backup = [] // 备份
|
||
|
||
// 扫描到设备后，再等待个几秒计时器
|
||
let after_timer = ''
|
||
|
||
// 自动连接回调
|
||
let autoConnectCallback = ''
|
||
|
||
// 自动连接检测计时器
|
||
let autoConnectTimer = ''
|
||
|
||
|
||
/**
|
||
* 手机蓝牙是否开启了
|
||
*/
|
||
let isBleOn = false
|
||
|
||
|
||
|
||
let listener = function(res) {
|
||
console.log(res);
|
||
// 该方法回调中可以用于处理连接意外断开等异常情况
|
||
if (!res.connected) {
|
||
device = ''
|
||
cmdList = [] // 这里清空指令
|
||
isConnecting = false
|
||
connected = false
|
||
lastBatteryLevel = 'N/A';
|
||
if (disconnectCallback && typeof disconnectCallback == 'function') {
|
||
disconnectCallback()
|
||
}
|
||
uni.getBluetoothAdapterState({
|
||
success: (res) => {
|
||
if (!res.available) {
|
||
isOpen = false
|
||
auto_connect = true
|
||
}
|
||
reconnectDevice()
|
||
},
|
||
fail: (err) => {}
|
||
})
|
||
}
|
||
}
|
||
|
||
|
||
// 初始化拓展函数
|
||
String.prototype.padLeft = function(len, char) {
|
||
let str = this;
|
||
return new Array(len - str.length + 1).join(char || '') + str
|
||
}
|
||
String.prototype.transFloat = function() {
|
||
let str = this;
|
||
return str.indexOf('.') != -1 ? parseFloat(str).toFixed(1) : str
|
||
}
|
||
|
||
//
|
||
|
||
if (uni.getSystemInfoSync().platform){
|
||
uni.onBluetoothAdapterStateChange(function(res) {
|
||
if (!res.available) {
|
||
isOpen = false
|
||
isBleOn = false
|
||
} else {
|
||
isBleOn = true
|
||
}
|
||
})
|
||
}
|
||
|
||
|
||
|
||
|
||
// 获取 校验
|
||
function getCheckSum(cmd) {
|
||
// console.log(cmd, '我是cmd');
|
||
let checkSum = getCrc16(cmd);
|
||
// console.log(checkSum, '我是checkSum');
|
||
// console.log(splitByLen(checkSum, 2).reverse().map(e => parseInt(e, 16)), 'woshi ');
|
||
return splitByLen(checkSum, 2).reverse().map(e => parseInt(e, 16))
|
||
}
|
||
|
||
function getCrc16(cmd) {
|
||
let crc = 0xffff;
|
||
let len = cmd.length;
|
||
for (let i = 0; i < len; i++) {
|
||
crc = crc ^ (cmd[i] & 0xff)
|
||
for (let j = 0; j < 8; j++) {
|
||
if ((crc & 0x0001) == 1) {
|
||
crc >>= 1
|
||
crc ^= 0xA001
|
||
} else {
|
||
crc >>= 1
|
||
}
|
||
}
|
||
}
|
||
// console.log(crc.toString(16).padLeft(4, '0'), '0121454878');
|
||
return crc.toString(16).padLeft(4, '0')
|
||
}
|
||
|
||
|
||
// #################################################
|
||
// #
|
||
// # Module Setup & Configuration
|
||
// #
|
||
// #################################################
|
||
|
||
// 初始化蓝牙模块
|
||
export function initBlue() {
|
||
uni.onBluetoothDeviceFound((res) => {
|
||
res.devices.forEach(device => {
|
||
// 过滤掉没有名字的设备
|
||
if (!device.name) {
|
||
return;
|
||
}
|
||
|
||
const foundDevices = devices
|
||
const idx = inArray(foundDevices, 'deviceId', device.deviceId)
|
||
if (idx === -1) {
|
||
devices.push(device)
|
||
} else {
|
||
devices[idx] = device
|
||
}
|
||
|
||
// Always notify the UI of any found device
|
||
if (scanCallback && typeof scanCallback == "function") {
|
||
scanCallback() // 查找结果集回调
|
||
}
|
||
|
||
// console.log('auto_connect:', auto_connect);
|
||
// console.log('isConnecting:', isConnecting);
|
||
// console.log('deviceId:', deviceId);
|
||
if (auto_connect && !isConnecting && device.deviceId == deviceId) {
|
||
isConnecting = true
|
||
createBLEConnection(deviceId, true);
|
||
|
||
} else if (auto_connect) {
|
||
// console.log('111111100000000000000000//////////////');
|
||
if (!after_timer) {
|
||
after_timer = setTimeout(() => {
|
||
let valid = []
|
||
auto_mac = JSON.parse(JSON.stringify(auto_mac_backup))
|
||
auto_mac.forEach(item => {
|
||
valid.push(devices.some(e => e.deviceId == item))
|
||
})
|
||
valid.forEach((item, index) => {
|
||
if (!item) {
|
||
auto_mac.splice(index, 1)
|
||
}
|
||
})
|
||
console.log('valid mac ', auto_mac)
|
||
if (auto_mac.length > 0) {
|
||
uni.showLoading({
|
||
title: '自动连接中...',
|
||
mask: true
|
||
})
|
||
let mac = auto_mac[0]
|
||
createBLEConnection(mac)
|
||
auto_mac.splice(0, 1)
|
||
} else {}
|
||
clearTimeout(after_timer)
|
||
after_timer = ''
|
||
}, 1000 * 6)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 设置连接成功回调
|
||
export function setCallback(e) {
|
||
connectCallback = e
|
||
}
|
||
|
||
// 设置搜索到蓝牙设备回调
|
||
export function setScanCallback(e) {
|
||
scanCallback = e
|
||
}
|
||
|
||
// 设置设备断开连接回调
|
||
export function setDisconnectCallback(e) {
|
||
disconnectCallback = e
|
||
}
|
||
|
||
// 设置写成功回调
|
||
export function setWriteCallback(e) {
|
||
writeCallback = e;
|
||
}
|
||
|
||
export function setBatteryCallback(e) {
|
||
batteryCallback = e;
|
||
if (lastBatteryLevel !== 'N/A' && typeof batteryCallback === 'function') {
|
||
batteryCallback(lastBatteryLevel);
|
||
}
|
||
}
|
||
|
||
export function setMacCallback(e) {
|
||
macCallback = e;
|
||
}
|
||
|
||
export function getDeviceId(){
|
||
return deviceId
|
||
}
|
||
|
||
export function getConnectedDevice() {
|
||
return device;
|
||
}
|
||
|
||
// 业务相关回调
|
||
function setRealtimeCallback(type, e) {
|
||
realtimeType = type
|
||
// console.log('业务相关回调', e);
|
||
realtimeCallback = e
|
||
// console.log('set realtimeType ', realtimeType)
|
||
}
|
||
|
||
|
||
// #################################################
|
||
// #
|
||
// # Core BLE Command Functions
|
||
// #
|
||
// #################################################
|
||
|
||
// 转换16进制
|
||
/**
|
||
* @param {number} num 几位
|
||
*/
|
||
function conversion(str, num) {
|
||
const result = [];
|
||
for (let i = 0; i < str.length; i += num) {
|
||
let temp = str.slice(i, i + num);
|
||
// temp.toString(16);
|
||
result.push(parseInt(temp, 16));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// 切换灯的模式
|
||
export function sendLightType(type, e){
|
||
setRealtimeCallback(type, e)
|
||
let str1 = `FA${e}000100FF`;
|
||
let arr = [];
|
||
arr = conversion(str1, 2);
|
||
executeCmd(arr);
|
||
}
|
||
|
||
// 调节灯亮度
|
||
export function setLight(type, e, num) {
|
||
setRealtimeCallback(type, e)
|
||
// let str = `FA05${parseInt(num, 16)}00FF`;
|
||
let str = `FA050001${num.toString(16).padLeft(2,'0')}FF`;
|
||
let arr = conversion(str, 2);
|
||
console.log('light数组', arr);
|
||
executeCmd(arr);
|
||
}
|
||
|
||
/**
|
||
* @description 设置单位、部门、名字...
|
||
* @param { Array } arr
|
||
*/
|
||
export function sendImg(arr,e) {
|
||
let dataArr = conversion(arr, 2);
|
||
console.log(dataArr);
|
||
executeCmd(dataArr);
|
||
}
|
||
|
||
|
||
// 如未空（未收到回复，收到回复会清掉第一个指令）进队列， 空直接执行
|
||
function executeCmd(cmd) {
|
||
// if (cmdList.length == 0) {
|
||
// writeBLECharacteristicValue(write_characteristic, cmd)
|
||
|
||
// }
|
||
// cmdList.push(cmd)
|
||
writeBLECharacteristicValue(write_characteristic, cmd)
|
||
}
|
||
|
||
// 清掉第一个指令，然后检查队列是否为空，不为空继续发送
|
||
function continueExecute() {
|
||
cmdList.splice(0, 1)
|
||
if (cmdList.length != 0) {
|
||
writeBLECharacteristicValue(write_characteristic, cmdList[0])
|
||
}
|
||
}
|
||
|
||
|
||
// #################################################
|
||
// #
|
||
// # Core BLE Connection Logic
|
||
// #
|
||
// #################################################
|
||
|
||
|
||
// step 1
|
||
// 打开蓝牙功能
|
||
export function openBluetoothAdapter(search, callback) {
|
||
const operation = () => {
|
||
openBleAdapter((err) => {
|
||
if (!err) {
|
||
// On success (no error), start scanning for devices.
|
||
startBluetoothDevicesDiscovery();
|
||
}
|
||
// Always call the page's callback to notify it of the result.
|
||
if (callback) {
|
||
callback(err);
|
||
}
|
||
});
|
||
};
|
||
|
||
if (search) {
|
||
// First close any existing adapter session, then perform the operation.
|
||
uni.closeBluetoothAdapter({
|
||
complete: operation,
|
||
});
|
||
} else {
|
||
operation();
|
||
}
|
||
}
|
||
|
||
function openBleAdapter(callback) {
|
||
uni.openBluetoothAdapter({
|
||
success: (res) => {
|
||
isOpen = true;
|
||
isBleOn = true;
|
||
if (callback) callback(); // Success, no error object.
|
||
},
|
||
fail: (err) => {
|
||
// Log the full error to help diagnose release version issues
|
||
console.error('openBluetoothAdapter failed with error:', JSON.stringify(err));
|
||
|
||
if (err.errCode === 10001) {
|
||
uni.showModal({
|
||
content: '请打开手机蓝牙',
|
||
showCancel: false,
|
||
});
|
||
} else {
|
||
// For other errors, show a detailed modal for debugging in the release version.
|
||
uni.showModal({
|
||
title: '蓝牙启动失败',
|
||
content: `错误: ${JSON.stringify(err)}`,
|
||
showCancel: false
|
||
});
|
||
}
|
||
isOpen = false;
|
||
isBleOn = false;
|
||
// Propagate the error to the calling page
|
||
if (callback) callback(err);
|
||
},
|
||
});
|
||
}
|
||
|
||
// step 2
|
||
//开始搜索蓝牙设备
|
||
function startBluetoothDevicesDiscovery() {
|
||
console.log('开始搜索');
|
||
let option = {
|
||
allowDuplicatesKey: false,
|
||
success: (res) => {
|
||
console.log('搜索成功,有设备', res);
|
||
onBluetoothDeviceFound();
|
||
},
|
||
fail: (err) => {
|
||
console.log('当前搜索蓝牙设备失败', err);
|
||
if(err.errCode == 10008) {
|
||
uni.showToast({
|
||
title: '扫描太过频繁，请稍后再试',
|
||
icon: 'none'
|
||
});
|
||
}
|
||
// resetDevices();
|
||
// devices = []
|
||
// openBluetoothAdapter(true);
|
||
}
|
||
}
|
||
if (auto_connect) {
|
||
option.services = [
|
||
service_uuid
|
||
]
|
||
}
|
||
uni.startBluetoothDevicesDiscovery(option)
|
||
}
|
||
|
||
|
||
|
||
let hexString = ''
|
||
// step 3
|
||
// 设备查找结果处理
|
||
function onBluetoothDeviceFound() {
|
||
uni.onBluetoothDeviceFound((res) => {
|
||
res.devices.forEach(device => {
|
||
// 过滤掉没有名字的设备
|
||
if (!device.name) {
|
||
return;
|
||
}
|
||
|
||
const foundDevices = devices
|
||
const idx = inArray(foundDevices, 'deviceId', device.deviceId)
|
||
if (idx === -1) {
|
||
devices.push(device)
|
||
} else {
|
||
devices[idx] = device
|
||
}
|
||
|
||
// Always notify the UI of any found device
|
||
if (scanCallback && typeof scanCallback == "function") {
|
||
scanCallback() // 查找结果集回调
|
||
}
|
||
|
||
// console.log('auto_connect:', auto_connect);
|
||
// console.log('isConnecting:', isConnecting);
|
||
// console.log('deviceId:', deviceId);
|
||
if (auto_connect && !isConnecting && device.deviceId == deviceId) {
|
||
isConnecting = true
|
||
createBLEConnection(deviceId, true);
|
||
|
||
} else if (auto_connect) {
|
||
// console.log('111111100000000000000000//////////////');
|
||
if (!after_timer) {
|
||
after_timer = setTimeout(() => {
|
||
let valid = []
|
||
auto_mac = JSON.parse(JSON.stringify(auto_mac_backup))
|
||
auto_mac.forEach(item => {
|
||
valid.push(devices.some(e => e.deviceId == item))
|
||
})
|
||
valid.forEach((item, index) => {
|
||
if (!item) {
|
||
auto_mac.splice(index, 1)
|
||
}
|
||
})
|
||
console.log('valid mac ', auto_mac)
|
||
if (auto_mac.length > 0) {
|
||
uni.showLoading({
|
||
title: '自动连接中...',
|
||
mask: true
|
||
})
|
||
let mac = auto_mac[0]
|
||
createBLEConnection(mac)
|
||
auto_mac.splice(0, 1)
|
||
} else {}
|
||
clearTimeout(after_timer)
|
||
after_timer = ''
|
||
}, 1000 * 6)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// connect step 1
|
||
// 连接蓝牙设备
|
||
export function createBLEConnection(id, advertisData, sameDevice, closeConnectLoading) { //直接连接设备
|
||
console.log(id, advertisData, sameDevice, '连接蓝牙设备');
|
||
closeBLEConnection(false, () => {
|
||
|
||
// #ifdef MP-WEIXIN
|
||
uni.offBLEConnectionStateChange(listener) // 先移除
|
||
// #endif
|
||
|
||
//监听蓝牙连接状态
|
||
uni.onBLEConnectionStateChange(listener)
|
||
uni.createBLEConnection({
|
||
deviceId: id,
|
||
timeout: 5000,
|
||
success: (res) => {
|
||
console.log(res, '蓝牙连接状态');
|
||
auto_connect = false // 重置
|
||
auto_mac = [] // 重置
|
||
closeAutoConnect() // 关闭全局自动连接
|
||
if (autoConnectCallback && typeof autoConnectCallback == 'function') {
|
||
autoConnectCallback()
|
||
}
|
||
stopBluetoothDevicesDiscovery() // 停止扫描蓝牙设备
|
||
device = devices.find(item => item.deviceId == id)
|
||
isConnecting = false
|
||
connected = true
|
||
manualDisconnect = false
|
||
deviceId = id
|
||
console.log('连接的设备ID', deviceId);
|
||
getBLEDeviceServices(deviceId) // 获取服务，初始化特征值
|
||
uni.setStorageSync('deviceId', deviceId);
|
||
// uni.setStorageSync('deviceName', name);
|
||
},
|
||
fail: (err) => {
|
||
console.log('设备连接失败', err);
|
||
isConnecting = false;
|
||
if (auto_connect) {
|
||
if (auto_mac.length > 0) {
|
||
let mac = auto_mac[0]
|
||
createBLEConnection(mac)
|
||
auto_mac.splice(0, 1)
|
||
} else {
|
||
if (autoConnectCallback && typeof autoConnectCallback == 'function') {
|
||
autoConnectCallback()
|
||
}
|
||
}
|
||
} else {
|
||
console.log('设备连接失败');
|
||
uni.hideLoading()
|
||
uni.showToast({
|
||
title: '设备连接失败！' + err.errMsg,
|
||
icon: 'none',
|
||
duration: 2000,
|
||
})
|
||
}
|
||
if (typeof closeConnectLoading === 'function') {
|
||
closeConnectLoading();
|
||
}
|
||
},
|
||
complete: () => {
|
||
uni.hideLoading();
|
||
}
|
||
})
|
||
}, sameDevice) // 关闭当前蓝牙连接
|
||
console.log('结束连接方法');
|
||
}
|
||
|
||
// connect step 2
|
||
// 获取服务
|
||
function getBLEDeviceServices(deviceId) {
|
||
console.log('我获取服务成功接收到的Id是', deviceId);
|
||
//#ifdef APP-PLUS
|
||
setTimeout(() => {
|
||
uni.getBLEDeviceServices({
|
||
deviceId,
|
||
success: (res) => {
|
||
// console.log(res, '获取蓝牙设备所有服务2');
|
||
// console.log('测试1',res.services[i].uuid, service_uuid.toUpperCase())
|
||
for (let i = 0; i < res.services.length; i++) {
|
||
// console.log('测试2',res.services[i].uuid, service_uuid.toUpperCase())
|
||
// 消息服务
|
||
if (res.services[i].uuid == service_uuid ||
|
||
res.services[i].uuid == service_uuid.toUpperCase()) {
|
||
getBLEDeviceCharacteristics(deviceId, res.services[i].uuid)
|
||
}
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
console.log(err, '获取服务失败')
|
||
}
|
||
})
|
||
}, 6000)
|
||
//#endif
|
||
|
||
|
||
//#ifdef MP-WEIXIN
|
||
uni.getBLEDeviceServices({
|
||
deviceId,
|
||
success: (res) => {
|
||
console.log(res, '获取蓝牙设备所有服务');
|
||
for (let i = 0; i < res.services.length; i++) {
|
||
console.log(res.services[i].uuid, service_uuid)
|
||
// 消息服务
|
||
if (res.services[i].uuid == service_uuid ||
|
||
res.services[i].uuid == service_uuid.toUpperCase()) {
|
||
getBLEDeviceCharacteristics(deviceId, res.services[i].uuid)
|
||
}
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
console.log(err, '获取服务失败')
|
||
}
|
||
})
|
||
//#endif
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
// connect step 3
|
||
// 初始化特征值
|
||
function getBLEDeviceCharacteristics(deviceId, serviceId) {
|
||
uni.getBLEDeviceCharacteristics({
|
||
deviceId,
|
||
serviceId,
|
||
success: (res) => {
|
||
console.log(res,'通知特征值')
|
||
for (let i = 0; i < res.characteristics.length; i++) {
|
||
let item = res.characteristics[i]
|
||
|
||
const itemUUID = item.uuid.toUpperCase();
|
||
const primaryNotifyUUID = notify_characteristic.toUpperCase();
|
||
const secondaryNotifyUUID = notify_characteristic_2.toUpperCase();
|
||
|
||
// Check if the characteristic is one of the notification sources
|
||
if (itemUUID === primaryNotifyUUID || itemUUID === secondaryNotifyUUID) {
|
||
if (item.properties.notify || item.properties.indicate) {
|
||
uni.notifyBLECharacteristicValueChange({
|
||
deviceId,
|
||
serviceId,
|
||
characteristicId: item.uuid,
|
||
state: true,
|
||
success: () => {
|
||
console.log(`已成功监听特征值: ${item.uuid}`);
|
||
},
|
||
fail: (err) => {
|
||
console.error(`监听特征值 ${item.uuid} 失败:`, err);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
if (itemUUID === write_characteristic.toUpperCase()) {
|
||
if (item.properties.write) {}
|
||
}
|
||
}
|
||
},
|
||
fail: (res) => {
|
||
console.error('getBLEDeviceCharacteristics', res)
|
||
}
|
||
})
|
||
// notify的回调函数，操作之前先监听，保证第一时间获取数据
|
||
// 针对不同特征值的回调处理
|
||
uni.onBLECharacteristicValueChange((res) => {
|
||
let result = ab2hex(res.value)
|
||
|
||
// 打印来自 notify_characteristic_2 的数据
|
||
if (res.characteristicId.toUpperCase() === notify_characteristic_2.toUpperCase()) {
|
||
console.log(`接收到来自 [notify_characteristic_2] 的原始Hex数据: ${result}`);
|
||
|
||
if (result.startsWith('fc') && result.endsWith('ff')) {
|
||
const macHex = result.substring(2, result.length - 2);
|
||
const macAddress = macHex.match(/.{1,2}/g).reverse().join(':').toUpperCase();
|
||
console.log(`[notify_characteristic_2] 解析后的MAC地址: ${macAddress}`);
|
||
if (macCallback && typeof macCallback === 'function') {
|
||
macCallback(macAddress);
|
||
}
|
||
return;
|
||
} else if (result.startsWith('fb') && result.endsWith('ff')) {
|
||
const dataHex = result.substring(2, result.length - 2);
|
||
const batteryHex = dataHex.substring(0, 2);
|
||
const batteryLevel = parseInt(batteryHex, 16);
|
||
lastBatteryLevel = batteryLevel;
|
||
console.log(`[notify_characteristic_2] 解析后的电量: ${batteryLevel}%`);
|
||
if (batteryCallback && typeof batteryCallback === 'function') {
|
||
batteryCallback(batteryLevel);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
// This is the original logic for the primary notification characteristic.
|
||
// It is now generalized to handle responses from either characteristic if not handled above.
|
||
console.log('通知特征值',result)
|
||
|
||
let length = result.length
|
||
let len = parseInt(splitByLen(result.substr(2, 4), 2).reverse().join(''), 16)
|
||
// console.log(len)
|
||
let checkArrHex = splitByLen(result.substr(0, length - 4), 2)
|
||
// console.log(checkArrHex)
|
||
let checkArr = checkArrHex.map(e => parseInt(e, 16))
|
||
// console.log(checkArr)
|
||
let sendCheckSum = result.substr(-4)
|
||
let checkSum = getCheckSum(checkArr).map(e => e.toString(16).padLeft(2, '0')).join('')
|
||
// console.log(checkSum)
|
||
// console.log(sendCheckSum)
|
||
// console.log(sendCheckSum === checkSum)
|
||
if (sendCheckSum === checkSum) {
|
||
let type = parseInt(result.substr(8, 2), 16)
|
||
// console.log(type)
|
||
// console.log(realtimeType)
|
||
if (realtimeType == type && realtimeCallback && typeof realtimeCallback == 'function') {
|
||
realtimeType = undefined
|
||
let tempCallback = realtimeCallback
|
||
realtimeCallback = undefined
|
||
tempCallback(result)
|
||
// console.log('realtimeType ', realtimeType)
|
||
}
|
||
continueExecute()
|
||
} else {
|
||
uni.hideLoading() // 校验值不对的情况
|
||
continueExecute()
|
||
}
|
||
})
|
||
connectCallback(deviceId)
|
||
}
|
||
|
||
|
||
// 获取当前是否连接上
|
||
export function getConnected() {
|
||
return connected
|
||
}
|
||
|
||
// 设置自动连接的 mac 地址
|
||
function setAutoMac(arr) {
|
||
auto_mac_backup = arr
|
||
auto_connect = true
|
||
openBluetoothAdapter()
|
||
startAutoConnect()
|
||
}
|
||
|
||
/**
|
||
* 开启全局自动连接
|
||
*/
|
||
function startAutoConnect() {
|
||
auto_connect = true
|
||
autoConnectTimer = setInterval(() => {
|
||
if (auto_connect) {
|
||
if (!connected) {
|
||
console.log('自动连接扫描 ', isOpen)
|
||
if (isOpen) {
|
||
|
||
} else {
|
||
if (isBleOn) {
|
||
openBluetoothAdapter()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}, 1000 * 3)
|
||
}
|
||
|
||
/**
|
||
* 关闭全局自动连接
|
||
*/
|
||
function closeAutoConnect() {
|
||
auto_connect = false
|
||
clearInterval(autoConnectTimer)
|
||
}
|
||
|
||
/**
|
||
* 取消全局自动连接
|
||
*/
|
||
function cancelAutoConnect() {
|
||
auto_connect = false
|
||
auto_mac = []
|
||
autoConnectCallback = ''
|
||
clearInterval(autoConnectTimer)
|
||
closeBluetoothAdapter()
|
||
}
|
||
|
||
|
||
// 获取暂存的扫描到的设备数组
|
||
function getDevices() {
|
||
if (device) {
|
||
devices.push(device)
|
||
}
|
||
return devices
|
||
}
|
||
|
||
// 重置扫描到的设备数组
|
||
export function resetDevices() {
|
||
devices = [];
|
||
}
|
||
|
||
// write msg 发送指令
|
||
// msg 为 hexstring 形式
|
||
function writeBLECharacteristicValue(characteristicId, msg) {
|
||
if (connected == false) {
|
||
reconnectDevice();
|
||
return;
|
||
}
|
||
let buffer = hexArr2ab(msg);
|
||
waitingForResult = true; //等待通知返回结果。
|
||
let len = buffer.byteLength
|
||
let arr = []
|
||
if (len > 20) {
|
||
for (let i = 0, j = 0; i < len; i += 20) {
|
||
let start = j * 20;
|
||
let end = start + 20 > len ? len - start : 20
|
||
let data = Uint8Array.from(new Uint8Array(buffer, start, end))
|
||
// console.log(data)
|
||
// let tempBuffer = data.buffer.slice(start, end)
|
||
// console.log(tempBuffer)
|
||
arr.push(data.buffer)
|
||
j++
|
||
}
|
||
stopFlag = false
|
||
writeData(characteristicId, arr)
|
||
} else {
|
||
stopFlag = false
|
||
writeData(characteristicId, [buffer])
|
||
}
|
||
|
||
}
|
||
|
||
let stopFlag = false
|
||
let timeoutTimer = ''
|
||
let timeoutCallback = ''
|
||
|
||
function writeData(characteristicId, buffer) {
|
||
console.log('准备发送');
|
||
clearTimeout(timeoutTimer)
|
||
// console.log(buffer)
|
||
if (stopFlag) {
|
||
return
|
||
}
|
||
uni.writeBLECharacteristicValue({
|
||
deviceId,
|
||
serviceId: service_uuid,
|
||
characteristicId,
|
||
value: buffer[0],
|
||
success: (res) => {
|
||
if (realtimeCallback) {
|
||
let str = `写入 ${ab2hex(buffer[0])}`
|
||
console.log(str)
|
||
}
|
||
// 写入一次进度条就前进
|
||
if (writeCallback && typeof writeCallback == 'function') {
|
||
let str = `写入 ${ab2hex(buffer[0])}`
|
||
console.log('分包发送了一次');
|
||
writeCallback(str);
|
||
}
|
||
|
||
if (!stopFlag && buffer.length > 1) {
|
||
writeData(characteristicId, buffer.slice(1))
|
||
} else {
|
||
let time = new Date().getTime()
|
||
// console.log('time ', time)
|
||
timeoutTimer = setTimeout(() => {
|
||
if (timeoutCallback && typeof timeoutCallback == 'function') {
|
||
timeoutCallback()
|
||
}
|
||
}, 2000)
|
||
}
|
||
},
|
||
fail: (res) => {
|
||
cmdList = [] // 这里清空指令， 放弃队列中所有指令，为后续新指令的到来做准备
|
||
waitingForResult = false;
|
||
console.error('write failed ', res);
|
||
uni.showToast({
|
||
title: '请重新连接'
|
||
});
|
||
uni.navigateTo({
|
||
url: '/pages/search/index'
|
||
})
|
||
},
|
||
})
|
||
}
|
||
// 550800019301112f
|
||
// 550800019105118c
|
||
|
||
//重连设备
|
||
function reconnectDevice() {
|
||
// #ifdef MP-WEIXIN
|
||
uni.offBLEConnectionStateChange(listener) // 先移除
|
||
// #endif
|
||
reconnectTimes = 0;
|
||
clearInterval(reconnectTimer)
|
||
if (manualDisconnect) // 主动断开的不做处理
|
||
return
|
||
uni.hideLoading()
|
||
uni.showLoading({
|
||
mask: true,
|
||
title: '重连中...'
|
||
})
|
||
reconnect()
|
||
reconnectTimer = setInterval(
|
||
() => {
|
||
console.log('重连?>>>>>>>');
|
||
reconnect()
|
||
}, 3000); // 7000
|
||
}
|
||
|
||
function reconnect() {
|
||
if (connected) //已连接
|
||
{
|
||
reconnectTimes = 0;
|
||
clearInterval(reconnectTimer)
|
||
return
|
||
}
|
||
if (reconnectTimes >= 2) //超时 // 9
|
||
{
|
||
reconnectTimes = 0;
|
||
clearInterval(reconnectTimer)
|
||
uni.hideLoading()
|
||
showModal()
|
||
return
|
||
} else {
|
||
reconnectTimes += 1
|
||
if (isOpen) {
|
||
if (!auto_connect) {
|
||
connectNow()
|
||
}
|
||
} else {
|
||
if (isBleOn) {
|
||
openBluetoothAdapter(true)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function connectNow() {
|
||
if (!isConnecting) {
|
||
isConnecting = true
|
||
// #ifdef MP-WEIXIN
|
||
uni.offBLEConnectionStateChange(listener) // 先移除
|
||
// #endif
|
||
//监听蓝牙连接状态
|
||
uni.onBLEConnectionStateChange(listener)
|
||
uni.createBLEConnection({
|
||
deviceId: deviceId,
|
||
timeout: 3000,
|
||
success: (res) => {
|
||
uni.hideLoading()
|
||
device = devices.find(item => item.deviceId == deviceId)
|
||
isConnecting = false
|
||
connected = true
|
||
reconnectTimes = 0;
|
||
clearInterval(reconnectTimer) //结束循环
|
||
getBLEDeviceServices(deviceId)
|
||
|
||
|
||
},
|
||
fail: (res) => {
|
||
isConnecting = false
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
|
||
// 获取当前状态
|
||
// 用于下拉刷新
|
||
function getBluetoothAdapterState() {
|
||
uni.getBluetoothAdapterState({
|
||
success: (res) => {
|
||
if (!res.available) {
|
||
openBluetoothAdapter()
|
||
} else {
|
||
uni.stopBluetoothDevicesDiscovery({
|
||
complete: () => {
|
||
startBluetoothDevicesDiscovery();
|
||
}
|
||
})
|
||
}
|
||
},
|
||
fail: (err) => {}
|
||
})
|
||
}
|
||
|
||
// 断开蓝牙设备连接
|
||
function closeBLEConnection(close, callback, sameDevice) {
|
||
try {
|
||
// console.log('123', close)
|
||
if (close) {
|
||
manualDisconnect = true;
|
||
}
|
||
console.log('123', deviceId)
|
||
if (deviceId) {
|
||
uni.closeBLEConnection({
|
||
deviceId: deviceId,
|
||
success: (res) => {
|
||
handleCloseBle(close, callback, sameDevice)
|
||
},
|
||
fail: (err) => {
|
||
if (err.errCode == 10006) {
|
||
handleCloseBle(close, callback, sameDevice)
|
||
}
|
||
}
|
||
})
|
||
} else {
|
||
// console.log('123', typeof callback == 'function')
|
||
if (callback && typeof callback == 'function') {
|
||
callback()
|
||
}
|
||
}
|
||
} catch (error) {
|
||
uni.hideLoading()
|
||
console.log(error)
|
||
}
|
||
}
|
||
|
||
function handleCloseBle(close, callback, sameDevice) {
|
||
if (!sameDevice) {
|
||
deviceId = ''
|
||
}
|
||
connected = false
|
||
lastBatteryLevel = 'N/A';
|
||
// 手动断开连接处理
|
||
if (close) {
|
||
closeBluetoothAdapter(true)
|
||
}
|
||
if (callback && typeof callback == 'function') {
|
||
callback()
|
||
}
|
||
}
|
||
|
||
// 关闭蓝牙扫描
|
||
function stopBluetoothDevicesDiscovery() {
|
||
isConnecting = false;
|
||
uni.stopBluetoothDevicesDiscovery({
|
||
success: (res) => {
|
||
}
|
||
})
|
||
}
|
||
|
||
export const stopBlue = stopBluetoothDevicesDiscovery;
|
||
|
||
// 关闭蓝牙适配器
|
||
function closeBluetoothAdapter(doCallback) {
|
||
uni.stopBluetoothDevicesDiscovery({
|
||
success: (result) => {
|
||
uni.closeBluetoothAdapter({
|
||
success: (res) => {
|
||
// 手动断开连接处理
|
||
}
|
||
})
|
||
}
|
||
})
|
||
}
|
||
|
||
// 蓝牙断开 弹窗提示 (重连不可连上)
|
||
function showModal() {
|
||
deviceId = ''
|
||
devices = []
|
||
// auto_connect = true // 开启全局自动连接
|
||
openBluetoothAdapter(true)
|
||
// startAutoConnect()
|
||
uni.showModal({
|
||
content: '设备重连失败，已断开连接！',
|
||
showCancel: false,
|
||
success() {
|
||
uni.reLaunch({
|
||
url: '/pages/search/index'
|
||
});
|
||
}
|
||
})
|
||
}
|
||
|
||
// #################################################
|
||
// #
|
||
// # Utility Functions
|
||
// #
|
||
// #################################################
|
||
|
||
/////////////////// 工具函数 /////////////////////
|
||
function splitByLen(str, len) {
|
||
let length = str.length
|
||
let newArr = []
|
||
for (let i = 0; i < length; i += len) {
|
||
newArr.push(str.substr(i, len))
|
||
}
|
||
return newArr
|
||
}
|
||
|
||
function arrayBufferToString(arr) {
|
||
if (typeof arr === 'string') {
|
||
return arr;
|
||
}
|
||
var dataview = new DataView(arr);
|
||
var ints = new Uint8Array(arr.byteLength);
|
||
for (var i = 0; i < ints.length; i++) {
|
||
ints[i] = dataview.getUint8(i);
|
||
}
|
||
arr = ints;
|
||
var str = '',
|
||
_arr = arr;
|
||
for (var i = 0; i < _arr.length; i++) {
|
||
var one = _arr[i].toString(2),
|
||
v = one.match(/^1+?(?=0)/);
|
||
if (v && one.length == 8) {
|
||
var bytesLength = v[0].length;
|
||
var store = _arr[i].toString(2).slice(7 - bytesLength);
|
||
for (var st = 1; st < bytesLength; st++) {
|
||
store += _arr[st + i].toString(2).slice(2);
|
||
}
|
||
str += String.fromCharCode(parseInt(store, 2));
|
||
i += bytesLength - 1;
|
||
} else {
|
||
str += String.fromCharCode(_arr[i]);
|
||
}
|
||
}
|
||
return str;
|
||
}
|
||
|
||
|
||
function inArray(arr, key, val) {
|
||
for (let i = 0; i < arr.length; i++) {
|
||
if (arr[i][key] === val) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// 字符串转为ArrayBuffer对象，参数为字符串，注意这里的字符串为非hex字符串
|
||
function stringToArrayBuffer(str) {
|
||
var bytes = new Array();
|
||
var len, c;
|
||
len = str.length;
|
||
for (var i = 0; i < len; i++) {
|
||
c = str.charCodeAt(i);
|
||
if (c >= 0x010000 && c <= 0x10FFFF) {
|
||
bytes.push(((c >> 18) & 0x07) | 0xF0);
|
||
bytes.push(((c >> 12) & 0x3F) | 0x80);
|
||
bytes.push(((c >> 6) & 0x3F) | 0x80);
|
||
bytes.push((c & 0x3F) | 0x80);
|
||
} else if (c >= 0x000800 && c <= 0x00FFFF) {
|
||
bytes.push(((c >> 12) & 0x0F) | 0xE0);
|
||
bytes.push(((c >> 6) & 0x3F) | 0x80);
|
||
bytes.push((c & 0x3F) | 0x80);
|
||
} else if (c >= 0x000080 && c <= 0x0007FF) {
|
||
bytes.push(((c >> 6) & 0x1F) | 0xC0);
|
||
bytes.push((c & 0x3F) | 0x80);
|
||
} else {
|
||
bytes.push(c & 0xFF);
|
||
}
|
||
}
|
||
var array = new Int8Array(bytes.length);
|
||
for (var i in bytes) {
|
||
array[i] = bytes[i];
|
||
}
|
||
return array.buffer;
|
||
}
|
||
|
||
function hexArr2ab(hexArr) {
|
||
let buffer = new ArrayBuffer(hexArr.length)
|
||
let dataView = new DataView(buffer)
|
||
for (var i = 0; i < hexArr.length; i++) {
|
||
dataView.setUint8(i, hexArr[i])
|
||
}
|
||
return buffer;
|
||
}
|
||
|
||
function hexStr2ab(hexStr) {
|
||
let buffer = new ArrayBuffer(hexStr.length / 2)
|
||
let dataView = new DataView(buffer)
|
||
for (var i = 0, j = 0; i < hexStr.length; i += 2, j++) {
|
||
let _str = "0x" + hexStr.substr(i, 2)
|
||
dataView.setUint8(j, parseInt(_str, 16))
|
||
}
|
||
return buffer;
|
||
}
|
||
// ArrayBuffer转16进度字符串示例
|
||
function ab2hex(buffer) {
|
||
var hexArr = Array.prototype.map.call(
|
||
new Uint8Array(buffer),
|
||
function(bit) {
|
||
return ('00' + bit.toString(16)).slice(-2)
|
||
}
|
||
)
|
||
return hexArr.join('');
|
||
}
|
||
|
||
function hexStr2HexArr(hexStr) {
|
||
var a = [];
|
||
for (var i = 0; i < hexStr.length; i += 2) {
|
||
let _str = "0x" + hexStr.substr(i, 2)
|
||
a.push(parseInt(_str, 16));
|
||
}
|
||
return a;
|
||
}
|
||
|
||
function hexArr2HexStr(hexArr) {
|
||
let arr = []
|
||
hexArr.forEach(item => {
|
||
arr.push(item.toString(16).padLeft(2, '0'))
|
||
})
|
||
return arr.join('')
|
||
}
|
||
|
||
// 10进制转16进制补0
|
||
function dec2hex(dec, len) { //10进制转16进制补0
|
||
var hex = "";
|
||
while (dec) {
|
||
var last = dec & 15;
|
||
hex = String.fromCharCode(((last > 9) ? 55 : 48) + last) + hex;
|
||
dec >>= 4;
|
||
}
|
||
if (len) {
|
||
while (hex.length < len) hex = '0' + hex;
|
||
}
|
||
return hex;
|
||
}
|
||
// 10进制转16进制补0
|
||
function string_hex2int(hex) { //16进制转10进制
|
||
var len = hex.length,
|
||
a = new Array(len),
|
||
code;
|
||
for (var i = 0; i < len; i++) {
|
||
code = hex.charCodeAt(i);
|
||
if (48 <= code && code < 58) {
|
||
code -= 48;
|
||
} else {
|
||
code = (code & 0xdf) - 65 + 10;
|
||
}
|
||
a[i] = code;
|
||
}
|
||
return a.reduce(function(acc, c) {
|
||
acc = 16 * acc + c;
|
||
return acc;
|
||
}, 0);
|
||
}
|
||
|
||
//校验和
|
||
function checkSumResult(hexStr, len) //返回校验和的hexstring
|
||
{
|
||
let abData = hexStr2HexArr(hexStr)
|
||
var ucI = 0,
|
||
ucJ = 0;
|
||
var uiCrcValue = 0xffff;
|
||
for (ucI = 0; ucI < len; ucI++) {
|
||
uiCrcValue = (uiCrcValue ^ (abData[ucI] & 0xff));
|
||
for (ucJ = 0; ucJ < 8; ucJ++) {
|
||
if ((uiCrcValue & 0x0001) == 1) {
|
||
uiCrcValue = ((uiCrcValue >> 1) ^ 0x8408);
|
||
} else {
|
||
uiCrcValue = (uiCrcValue >> 1);
|
||
}
|
||
}
|
||
}
|
||
//校验和为uiCrcValue 的高低位互换
|
||
var hexStr = dec2hex(uiCrcValue, 4);
|
||
var resultStr = hexStr.substr(2, 2) + hexStr.substr(0, 2)
|
||
return resultStr;
|
||
}
|
||
|
||
function Uint8ToStr(arr) {
|
||
for (var i = 0, str = ''; i < arr.length; i++)
|
||
str += String.fromCharCode(arr[i]);
|
||
return str;
|
||
}
|
||
|
||
function strToUint8(str) {
|
||
for (var i = 0, arr = []; i < str.length; i++) {
|
||
arr.push(str.charCodeAt(i));
|
||
}
|
||
return new Uint8Array(arr);
|
||
}
|
||
|
||
export function getDiscoveredDevices() {
|
||
return [...devices];
|
||
}
|
||
|
||
// 手动断开蓝牙
|
||
export function manualDisconnectDevice() {
|
||
closeBLEConnection(true);
|
||
}
|