蓝牙编程

蓝牙技术,很早以前就被有了,如今已更新4.0版本。很多热门技术都是基于它工作的,如Android平台的NFC,iOS的iBeancon,Apple Watch的WatchConnectivity框架等,现在的智能家居基本也是基于蓝牙4.0与APP进行通信,可见蓝牙在实践工作中的重要性。在iOS中,蓝牙是基于4.0标准的,设备间低功耗通信。

核心成员

在开始前我们回忆下传统的Socket编程,里面有Server服务端与Client端的区别。那么在蓝牙编程也是如此,其中Peripheral外设相当于Socket编程中的Server服务端,Central中心相当于Client客户端(ps吐槽下,Central中心,作为服务端,不更适合吗!)

你可以理解外设是一个广播数据的设备,它开始告诉外面的世界说它这儿有一些数据,并且能提供一些服务。另一边中心开始扫描周边有没有合适的设备,如果发现后,会和外设做连接请求,一旦连接确定后,两个设备就可以传输数据了。

在iOS6之后,iOS 设备可以是外设,也可以是中心,就像Socket编程中一样,你可以是服务端也可以是客户端。

服务(service)和特征(characteristic)

每个蓝牙4.0的设备都是通过服务和特征来展示自己的,一个设备必然包含一个或多个服务,每个服务下面又包含若干个特征。特征是与外界交互的最小单位。比如说,智能音响设备,用服务A标识播放模块,特征A1来表示播放上一首,特征A2来表示播放下一首;服务B标识设置模块,特征B1设置彩灯颜色。这样做的目的主要为了模块化

外设,服务,特征都有一个UUID来标识

上面说了设备可以是外设,也可以是中心,也就是会有二种模式

  • 本地中心 -> 远程外设
  • 本地外设 -> 远程中心

不过在智能家居开发中,大部分硬件蓝牙都是担任外设的角色,也就是说我们应用只要扮演中心即可了。

开始

本篇只讲述第一种模式的本地中心,远程外设端可借助 蓝牙调试神器LightBlue For Mac。需要了解第二种模式可以移步创建外设

更新:LightBlue For Mac只可以做为Central,不可以做为Peripheral,如需模拟请下载iOS版本

蓝牙交互的流程大致为

建立中心角色 —> 扫描外设(discover)—> 发现外设后连接外设(connect) —> 扫描外设中的服务和特征(discover) —> 与外设做数据交互(explore and interact) —> 断开连接(disconnect)。

下面我们一一讲到

建立中心角色

在本地中心角色中,使用CBCentralManager类管理,我们创建一个CBCentralManager类

1
2
let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
let centralMgr = CBCentralManager(delegate: self, queue: queue)

上面的delegate为CBCentralManagerDelegate,后续蓝牙相关的回调都会在此。Queue代表蓝牙在哪个队列里面操作,如果传入nil默认为主队列,值得注意的是后续的回调也是在传入的队列中调用的,所以如果传入的是非主线程的队列,在delegate中需要操作UI时需要手动切换到主线程

CBCentralManager对象创建后会回调到centralManagerDidUpdateState方法来检测蓝牙可用状态,这时我们可以提醒用户设备是否支持蓝牙,是否打开了蓝牙

扫描外设

1
2
3
4
5
let serviceUUIDS: Array<CBUUID> = [CBUUID(string: "FFDD")]
self.centralMgr.scanForPeripheralsWithServices(serviceUUIDS, options: [CBCentralManagerScanOptionAllowDuplicatesKey : true])

//停止扫描
self.centralMgr.stopScan()

如果serviceUUIDS为nil则会扫描周围所有的设外设,否则只会扫描UUID匹配的外设。CBCentralManagerScanOptionAllowDuplicatesKey默认为false,表示扫描中发现过设备则跳过不回调,我们这里传入true,因为下面做外设掉线的处理时需要用到

传入的serviceUUIDS数组元素为CBUUID类型,千万不要传入String,后面的操作也是如此,不然会碰到很多奇葩问题

发现外设后会回调到centralManager(central:didDiscoverPeripheral:advertisementData:RSSI:) ,perpheral则代表着外设,我们需要保存起来,后续的对外设的操作都是基于perpheral对象的

1
2
3
4
5
6
7
8
func centralManager(central: CBCentralManager!, didDiscoverPeripheral peripheral: CBPeripheral!, advertisementData: [NSObject : AnyObject]!, RSSI: NSNumber!) {
for i in 0..<discoveredPeripheralers.count {
var peripheraler = discoveredPeripheralers[i]
if(!peripheral.identifier.isEqual(peripheraler.peripheral.identifier)){ //未发现过才保存
discoveredPeripheralers.append(peripheraler)
}
}
}

连接外设

1
self.centralMgr.connectPeripheral(peripheral, options: nil)

传入上面保存的外设对象,如果连接失败后会回调到 centralManager(central:didFailToConnectPeripheral:error:),连接成功后会回调到 centralManager(central:didConnectPeripheral:),这个时候我们只是连接上外设而已,还需要发现外设中的服务与特征

发现服务与特征

外设连接成功后我们把peripheral保存好,并设置好peripheral的delegate(CBPeripheralDelegate),然后调用discoverServices来发现服务,同扫描外设时一样,discoverServices也可以传入一个serviceUUIDs参数来只获取需要的服务

注意,注意,注意,重要的话说三遍。以下的回调都是CBPeripheralDelegate的了,不再是CBCentralManagerDelegate的回调

1
2
3
4
5
6
func centralManager(central: CBCentralManager!, didConnectPeripheral peripheral: CBPeripheral!) {
self.peripheral = peripheral
self.peripheral.delegate = self
let serviceUUIDS: Array<CBUUID> = [CBUUID(string: "FF12")]
self.peripheral.discoverServices(serviceUUIDS)
}

发现服务后回调到peripheral(peripheral:didDiscoverServices:),这时我们就可以访问所有发现的服务一一去发现服务下的特征

1
2
3
4
5
6
7
8
9
10
11
func peripheral(peripheral: CBPeripheral!, didDiscoverServices error: NSError!) {
if(error != nil) {
log(error)
return
}
for item in peripheral.services {
let service = item as! CBService
let characteristicUUIDs: Array<CBUUID> = [CBUUID(string: "FF02"), CBUUID(string: "FF04")]
peripheral.discoverCharacteristics(characteristicUUIDs, forService: service) //发现特征
}
}

同样特征也可以传入characteristicUUIDs数组来过滤,发现特征后回调

1
2
3
4
5
6
7
8
9
10
11
12
func peripheral(peripheral: CBPeripheral!, didDiscoverCharacteristicsForService service: CBService!, error: NSError!) {
if(error != nil){
log(error)
return
}
for item in service.characteristics {
let characteristic = item as! CBCharacteristic
if(characteristic.properties == .Notify) { //如果特征为订阅属性则开启订阅
peripheral.setNotifyValue(true, forCharacteristic: characteristic)
}
}
}

每进入一次回调代表发现一个服务中的特征而不是外设所有的特征,外设、服务、特征从左至右都是上下级一对多的关系。
每个特征都有个属性,代表着它是可写、可读等,一个特征可同时拥有读写权限,如上面的订阅其实是一种订阅者模式的读取数据

发送数据

拿到可写的特征后,通过writeValue发送数据包

1
2
3
4
5
6
7
let data = "hello".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: true)
//自动判断写特征的类型
var type: CBCharacteristicWriteType = .WithoutResponse
if(writeCharacteristic.properties == CBCharacteristicProperties.Write) {
type = .WithResponse
}
self.peripheral!.writeValue(data, forCharacteristic: writeCharacteristic, type: type)

把要发送的文本转换为二进制,发送到相应的特征即可。值得注意的是第三个参数type写类型需要与特征的属性一致,其中WithoutResponse与WithResponse区别在于前者发送数据后是没有回调的,后者会回调到 peripheral(peripheral:didWriteValueForCharacteristic:error:) 来检测是否发送成功,如果发送数据传入的类型与特征不同时总是会失败

由于蓝牙的缓冲大小只有20bytes,那么如果我们发送的数据包大小不能大于20bytes,所以得分多次发送

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func writeValue(data: NSData, withCharacteristic characteristic: CBCharacteristic) -> Bool {
if(self.peripheral == nil) {
return false
}
var didSend = false
var sendDataIndex = 0
let NOTIFY_MTU = 20
while (data.length - sendDataIndex != 0) {
//剩下的数据大小
var amountToSend = data.length - sendDataIndex
// 不能大于20bytes
if (amountToSend > NOTIFY_MTU) {
amountToSend = NOTIFY_MTU
}
let chunk = NSData(bytes: data.bytes + sendDataIndex, length: amountToSend)
var type: CBCharacteristicWriteType = .WithoutResponse
if(characteristic.properties == CBCharacteristicProperties.Write) {
type = .WithResponse
}
self.peripheral!.writeValue(chunk, forCharacteristic: characteristic, type: type)
sendDataIndex += amountToSend
}
return true
}

读取数据

分为二种,直接读、订阅,顾名思义,直接读就是手动调用API读取,订阅则只要开启后,外设有消息都可以收到

直接读

1
self.peripheral!.readValueForCharacteristic(characteristic)

订阅

1
self.peripheral!.setNotifyValue(true, forCharacteristic: characteristic)

两种回调都会回调到 peripheral(peripheral:didUpdateValueForCharacteristic:error:),上面也提到因为蓝牙的缓冲大小,需要发送多次,那么在读取时也需要接收多次,才能保证数据的一体性,所以通常都会在数据包的开始用 EOM 来标识一段数据的开始,数据结束后再次用 EOM 来标识,所以我们接收数据时会这样

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
let updatingEOMFlag = "EOM"
func peripheral(peripheral: CBPeripheral!, didUpdateValueForCharacteristic characteristic: CBCharacteristic!, error: NSError!) {
if(error != nil) {
log(error)
return
}
if(characteristic.value != nil) {
var data = characteristic.value!
var string = NSString(data: data, encoding: NSUTF8StringEncoding)
log(string)

//接收多段数据
if(self.updatingEOMFlag != nil) {
if(self.updatingEOMFlag == string) {
var EOMEndFlag = false
for i in 0..<self.updatingDatas.count { //数据结束
var updatingData = self.updatingDatas[i]
if(updatingData.characteristic.UUID.isEqual(characteristic.UUID)) {
data = updatingData.data
string = NSString(data: data, encoding: NSUTF8StringEncoding)
self.updatingDatas.removeAtIndex(i) //删除缓存数据
EOMEndFlag = true
break
}
}
if(!EOMEndFlag) {//数据开始
let updatingData = UpdatingDataer(characteristic: characteristic, data: NSMutableData())
self.updatingDatas!.append(updatingData)
return
}
} else {
if var updatingData = (self.updatingDatas?.filter{ $0.characteristic.UUID.isEqual(characteristic.UUID) }) where updatingData.count == 1 && updatingData[0].data != nil { //数据中间
updatingData[0].data.appendData(data)
return
}
}
}
//在此最终得到完整数据
let stringData = StringData(string: string as? String, data: data)

//触发delegate与通知回调
...
}
}

断开连接

1
self.centralMgr.cancelPeripheralConnection(self.peripheral!)

至此,整个流程就完了

高级需求~

外设掉线检测

所谓掉线就是外设发现了后,过了一段时间失去信号了。喵了下系统框架,没有找到相关外设掉线的检测,唯一有点像的就是发现外设里面的RSSI,代表设备信号强度,值越小信息越好。

总结

  • 在蓝牙交互的二种角色中,通常APP端扮演中央Central的角色,设备扮演外设Peripheral的角色
  • 创建CBCentralManager对象时传入的Queue决定了后续CBCentralManagerDelegate、CBPeripheralDelegate等回调的所在线程
  • 一个外设设备可包含一个或多个服务,一个服务可包含一个或多个特征,读写操作最终是针对特征。
  • 蓝牙的缓冲大小只有20bytes,在发送数据时最多只能发送20bytes,所以得分多次发送,数据的一体性可以用 EOM 标识符表标识

更新: 提供了一个读写的Central端Demo,Peripheral端请用上述iOS版LightBlue模拟

参考

Core Bluetooth Programming Guide

译-iOS蓝牙编程指南

小小广告

本人目前是一名自由职业者,接受移动两端的项目开发,如果你有需求或者有资源请速与我联系吧,QQ865425695