小程序连接蓝牙

1.授予蓝牙权限

//1.蓝牙授权
const authBlue = (callback, initApp) => {
    app = initApp;
    //鉴定是否授权蓝牙
    wx.getSetting().then(res => {
        if (!res.authSetting['scope.bluetooth']) {
            //未授予蓝牙权限
            return wx.authorize({
                scope: 'scope.bluetooth',
            })
        } else {
            //已授予
            if (callback != null) {
                callback({
                    blueAuth: true
                }) 
                // init() //2.蓝牙初始化
            }

            return new Promise(() => {})
        }
    }).then(() => {
        if (callback != null) {
            callback({
                blueAuth: true
            }) //回调-app.js-蓝牙权限
            // init() //2.蓝牙初始化
        }
        return new Promise(() => {})
    }).catch(err => {
        if (callback != null)
            callback({
                blueAuth: false
            })
        console.err(err);
    })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2.蓝牙初始化

//2.蓝牙初始化
const init = (onFound) => {
    console.log("2.蓝牙初始化");
    //打开蓝牙适配器
    wx.openBluetoothAdapter({
        mode: 'central'
    }).then(res => {
        app.globalData.isOpenBleAdapter = true //蓝牙适配器已打开
        wx.onBluetoothAdapterStateChange((res) => { //回调---蓝牙适配器状态改变
            if (!res.available) { //蓝牙适配器是否可用
                wx.showModal({
                    title: '温馨提示',
                    content: '蓝牙蓝牙适配器不可用，请重新启动',
                    showCancel: false
                })
            }
        })
        onFound(); //监听+寻找 新设备 -- 回调函数
    }).catch(() => {
        //失败
        wx.showToast({
            title: '请检查手机蓝牙是否打开',
            icon: 'none',
        })
    })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3.监听寻找新设备

//3.监听寻找新设备
const onDeviceFound = (addDevicesList) => {
    console.log("3.监听寻找新设备");
    wx.onBluetoothDeviceFound((res) => {
        const devicesList = []
        for (const item of res.devices) {
            if (!item.connectable) continue; //无法连接 --> 跳过
        	//过滤设备，找出自己想连接的设备  filterDevices
            let device = Device.filterDevices(item)
        	//addDevicesList 是一个回调函数，将数据更新到 View
            if (device && addDevicesList != null) {
                // 判断是否已经存在相同id的对象
                var existingObjIndex = devicesList.findIndex(function (obj) {
                    return obj.deviceId === device.deviceId;
                });
                if (existingObjIndex !== -1) { // 存在相同id的对象
                    // 更新对应位置上的对象属性值
                    Object.assign(devicesList[existingObjIndex], device);
                } else { // 不存在相同id的对象
                    // 将新对象添加到数组末尾
                    devicesList.push(device);
                }
            }
        }
        //更新到设备列表
        addDevicesList(devicesList)
    })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

4.搜索新设备

//4.搜索新设备
const startDevicesDiscovery = (obj) => {
    wx.startBluetoothDevicesDiscovery({
        allowDuplicatesKey: true, //允许上报同一台设备
        interval: 1000, //上报间隔时间
        success: (res) => {
            console.log("4.搜索新设备");
            // getBluetoothDevices()		// 获取蓝牙设备列表
        },
        fail: function (res) {
            wx.showToast({
                title: '搜索蓝牙外围设备失败,请重新初始化蓝牙!',
                icon: 'none',
            })
        }
    })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.建立连接⭐⭐⭐⭐⭐⭐⭐

/** 5.建立连接 
 * @param {*} deviceId 要连接的设备MAC
 * @param {*} func 连接后要执行的命令
 * 1.建立连接
 * 2.设置MTU    setBLEMTU
 * 3.获取蓝牙服务 UUID  getBLEDeviceServices
 * 4.获取蓝牙服务列表 UUIDS   getBLEDeviceCharacteristics
 * 5.判断UUIDS中哪个服务可用于indicate | notify，使用该UUID订阅特征变化 notifyBLECharacteristicValueChange
 * 6.监听特征值变化：onBLECharacteristicValueChange
 * 7.func({isConnect: true}) //连接成功
 */
const createConnect = (deviceId, func) => {
    let mtu = 209 //协商设置蓝牙低功耗的最大传输单元
    let serviceId = '0000FFE0-0000-1000-8000-00805F9B34FB';	//特定的UUID
    let characteristics;
    wx.createBLEConnection({
        deviceId
    }).then((res) => { //2.设置MTU
        if (res.errCode === 0 || res.errCode === -1) {
            console.log('1.连接成功');
            const systemInfo = wx.getSystemInfoSync();
            const platform = systemInfo.platform; //Android | IOS
            if (platform === 'android') {
                return wx.setBLEMTU({
                    deviceId,
                    mtu
                });
            } else if (platform === 'ios') {
                return {
                    mtu
                }
            } else {
                return {
                    mtu
                }
            }
        } else {
            console.log('连接失败');
            func({
                isConnect: false
            }) //连接失败
            return new Promise(() => {})
        }
    }, error => {
        console.log(error)
        func({ isConnect: false}) //连接失败
        return new Promise(() => {})
    }).then((res) => { //3.获取蓝牙服务
        console.log("2.MTU设置成功，协商MTU：", res.mtu, deviceId, serviceId);
        return wx.getBLEDeviceServices({deviceId});
    }, (res) => {
        console.log("2.MTU设置失败：", res);
        func({ isConnect: false}) //连接失败
        return new Promise(() => {})
    }).then((res) => {//4.获取蓝牙服务列表
        console.log("3.获取蓝牙服务成功", res);
        for (let i = 0; i < res.services.length; i++) {
            console.log("+++++++++发现服务：", res.services[i].uuid);
            if (res.services[i].uuid === '0000FFE0-0000-1000-8000-00805F9B34FB') {
                return wx.getBLEDeviceCharacteristics({
                    deviceId,
                    serviceId
                });
            }
        }
    },(err) => {
        console.error("3.获取蓝牙服务失败", err);
        func({ isConnect: false}) //连接失败
        return new Promise(() => {})
    }).then((res) => { //5.判断哪个服务可用于indicate | notify
        console.log("4.获取UUIDS成功", res);
        characteristics = res.characteristics

        for (let i = 0; i < characteristics.length; i++) {
            const item = characteristics[i];
            if (item.properties.notify || item.properties.indicate) {
                return wx.notifyBLECharacteristicValueChange({
                    deviceId: deviceId,
                    serviceId: serviceId,
                    characteristicId: item.uuid,
                    state: true
                });
            }
        }
    }, (res) => {
        console.log("4.获取UUIDS失败", res);
        func({ isConnect: false}) //连接失败
        return new Promise(() => {})
    }).then((res) => { //6.监听特征值变化
        console.log('5.订阅特征变化成功', res);
        for (let i = 0; i < characteristics.length; i++) {
            let item = characteristics[i];
            if (item.uuid.substr(0, 8) == '0000FFE1') {
                app.globalData.characteristicId = item.uuid
                break;
            }
        }
        func({ isConnect: true}) //连接成功
    }, (err) => {
        console.log("5.订阅特征变化失败", res);
        func({ isConnect: false}) //连接失败
        return new Promise(() => {})
    }).catch((err) => {
        func({ isConnect: false}) //连接失败
        console.error(err);
    });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

6.监听蓝牙低功耗连接状态改变事件

//6.监听蓝牙低功耗连接状态改变事件--主动连接或断开连接，设备丢失，连接异常断开
const onConnectionStateChange = (listenBleStatus) => {
    wx.onBLEConnectionStateChange(res => listenBleStatus(res))
}
1
2
3
4

8.监听特征值变化

//8.监听特征值变化   --  onBleValueChange  回调函数
const onCharacteristicValueChange = (onBleValueChange) => {
    wx.onBLECharacteristicValueChange(res => onBleValueChange(res))
}

/**
 * 监听蓝牙设备传输的数据
 * @param {*} res deviceId、serviceId、characteristicId、【value	ArrayBuffer	特征最新的值】
 */
function onBleValueChange(res) {
    console.log("监听到数据", res);
    //处理数据
    .
    .
    .
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

9.发送数据

/** 9.发送数据
 * @param {*} deviceId 设备ID
 * @param {*} command  命令
 */
const writeCharacteristicValue = (deviceId, command) => {
    return wx.writeBLECharacteristicValue({
        characteristicId: app.globalData.characteristicId,
        deviceId: deviceId,
        serviceId: app.globalData.serviceId,
        value: command,
    })
}
1
2
3
4
5
6
7
8
9
10
11
12