iOS 通信协议—— 蓝牙通信

深碍√TFBOYSˉ_ 2022-11-12 13:49 823阅读 0赞

这几天小伙伴又给我提了一个新需求，要求给他们的项目提供一个iOS端的蓝牙通信App，虽然iOS也做过一些，Objective C和Swift多少也知道一些，不过并没有深入的研究过iOS的开发，为了节省工期囫囵吞枣的看了一些资料，像之前那篇文章一样，我这里就不舞大刀，我把我参考的资料就放在下面这里，你如果需要可以去看看。

《[iOS/swift]蓝牙连接》

Github代码仓库：MichaelLynx/BleDemo

《Swift CoreBluetooth 蓝牙库》

我参考这些资料和代码的基础上，重写了其中一部分代码，并且做了一定的封装，你可以直接复制黏贴，并且在自己的工程里使用。版本为Swift的，不使用Objective C是因为觉得写起来比较浪费时间，而且如果遇到了需要和底层数据打交到的地方，我依然可以用Objective C做封装就好了。

首先是这个BluetoothLowEnergy类的实现。

  1. //
  2. // BluetoothLowEnergyHandler.swift
  3. // PetoiSerialSwift
  4. //
  5. // Created by Orlando Chen on 2021/3/23.
  6. //
  8. import Foundation
  9. import CoreBluetooth
  12. class BluetoothLowEnergy: NSObject { 
  14.     // 一个蓝牙设备当中可能包含多个信道，一个UUID就是一个信道标记
  15.     var uuids: [CBCharacteristic] = []
  17.     // 中心对象
  18.     var central : CBCentralManager!
  20.     // 把中心设备扫描的外置设备保存起来
  21.     var deviceList: [CBPeripheral] = []
  23.     // 接收到的数据
  24.     var peripheralData: Data?
  27.     // MARK: 0. 初始化
  28.     override init() { 
  29.         super.init()
  31.         // 初始化中心设备管理器
  32.         // 它的delegate函数为centralManagerDidUpdateState
  33.         // 其回调消息处理函数为：centralManager
  34.         self.central = CBCentralManager.init(delegate:self, queue:nil, options:[CBCentralManagerOptionShowPowerAlertKey:false])
  36.         // 初始化设备列表
  37.         self.deviceList = []
  38.     }
  40.     // MARK: 1. 扫描设备
  41.     func startScanPeripheral(serviceUUIDS: [CBUUID]?,
  42.                              options: [String: AnyObject]?) { 
  43.         // 清空列表
  44.         deviceList = []  // 清空设备列表
  45.         uuids = [] // 清空信道列表
  47.         // 开始进行扫描
  48.         self.central?.scanForPeripherals(withServices: serviceUUIDS, options: options)
  49.     }
  51.     // MARK: 2. 停止扫描
  52.     func stopScanPeripheral() { 
  53.         self.central?.stopScan()
  54.     }
  56.     // MARK: 3.1. 获取搜索到的外接设备
  57.     func getPeripheralList()-> [CBPeripheral] { 
  58.         return deviceList
  59.     }
  61.     // MARK: 3.2. 获取到当前蓝牙设备可用的消息信道
  62.     func getCharacteristic() -> [CBCharacteristic] { 
  63.         return uuids
  64.     }
  66.     // MARK: 3.3. 指定监听信道
  67.     func setNotifyCharacteristic(peripheral: CBPeripheral, notify: CBCharacteristic) { 
  68.         peripheral.setNotifyValue(true, for: notify)
  69.     }
  71.     // MARK: 4.1. 连结设备
  72.     // 连接设备之前要先设置代理，正常情况，当第一次获取外设peripheral的时候就会同时设置代理
  73.     func connect(peripheral: CBPeripheral) { 
  74.         if (peripheral.state != CBPeripheralState.connected) { 
  75.             central?.connect(peripheral , options: nil)
  77.             // 将外接设备的回掉函数连结到self
  78.             // 回掉消息处理函数为：peripheral
  79.             peripheral.delegate = self
  80.         }
  81.     }
  83.     // MARK: 4.2. 检测是否建立了连结
  84.     func isConnected(peripheral: CBPeripheral) -> Bool { 
  85.         return peripheral.state == CBPeripheralState.connected
  86.     }
  88.     // MARK: 5.1. 发送数据
  89.     func sendData(data: Data, peripheral: CBPeripheral, characteristic: CBCharacteristic,
  90.                   type: CBCharacteristicWriteType = CBCharacteristicWriteType.withResponse) { 
  92.         let step = 20
  93.         for index in stride(from: 0, to: data.count, by: step) { 
  94.             var len = data.count - index
  95.             if len > step { 
  96.                 len = step
  97.             }
  98.             let pData: Data = (data as NSData).subdata(with: NSRange(location: index, length: len))
  99.             peripheral.writeValue(pData, for: characteristic, type: type)
  100.         }
  101.     }
  103.     // MARK: 5.2. 接收数据
  104.     func recvData() -> Data { 
  105.         return peripheralData ?? Data([0x00])
  106.     }
  108.     // MARK: 6. 断开连结
  109.     func disconnect(peripheral: CBPeripheral) { 
  110.         central?.cancelPeripheralConnection(peripheral)
  111.     }
  112. }
  114. extension BluetoothLowEnergy: CBCentralManagerDelegate { 
  116.     // MARK: 检查运行这个App的设备是不是支持BLE。
  117.     func centralManagerDidUpdateState(_ central: CBCentralManager) { 
  119.         switch central.state { 
  120.         case .poweredOn:
  121.             NSLog("BLE poweredOn")
  122.         case .poweredOff:
  123.             NSLog("BLE powered off")
  124.         case .unknown:
  125.             NSLog("BLE unknown")
  126.         case .resetting:
  127.             NSLog("BLE ressetting")
  128.         case .unsupported:
  129.             NSLog("BLE unsupported")
  130.         case .unauthorized:
  131.             NSLog("BLE unauthorized")
  132.         @unknown default:
  133.             NSLog("BLE default")
  134.         }
  135.     }
  137.     // MARK: 以ANCS协议请求的端，授权状态发生改变
  138.     func centralManager(_ central: CBCentralManager, didUpdateANCSAuthorizationFor peripheral: CBPeripheral) { 
  139. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(peripheral)")
  141.         // TODO
  142.     }
  144.     // MARK: 状态的保存或者恢复
  145.     func centralManager(_ central: CBCentralManager, willRestoreState dict: [String : Any]) { 
  146. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(dict)")
  148.         // TODO
  149.     }
  151.     // MARK:
  152.     func centralManager(_ central: CBCentralManager, connectionEventDidOccur event: CBConnectionEvent, for peripheral: CBPeripheral) { 
  153. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(peripheral)")
  155.         // TODO
  156.     }
  158.     // 开始扫描之后会扫描到蓝牙设备，扫描到之后走到这个代理方法
  159.     // MARK: 中心管理器扫描到了设备
  160.     func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) { 
  162. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(peripheral)")
  164.         guard !deviceList.contains(peripheral), let deviceName = peripheral.name, deviceName.count > 0 else { 
  165.             return
  166.         }
  168.         // 把设备加入到列表中
  169.         deviceList.append(peripheral)
  171.         // TODO
  172.     }
  174.     // MARK: 连接外设成功，开始发现服务
  175.     func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) { 
  176. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(peripheral)")
  178.          // 设置代理
  179.          peripheral.delegate = self
  181.          // 开始发现服务
  182.          peripheral.discoverServices(nil)
  183.     }
  186.     // MARK: 连接外设失败
  187.     func centralManager(_ central: CBCentralManager, didFailToConnect peripheral:
  188.                             CBPeripheral, error: Error?) { 
  189. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(String(describing: peripheral.name))\n error:\(String(describing: error))")
  191.         // TODO
  192.     }
  194.     // MARK: 连接丢失
  195.     func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) { 
  197. // NSLog("\(#file) \(#line) \(#function)\n central:\(central)\n peripheral:\(String(describing: peripheral.name))\n error：\(String(describing: error))")
  199.        // TODO
  200.     }
  201. }
  204. // MARK: 外置设备被绑定后的事件响应
  205. extension BluetoothLowEnergy: CBPeripheralDelegate { 
  207.     // MARK: 匹配对应服务UUID
  208.     func peripheral(_ peripheral: CBPeripheral,
  209.                     didDiscoverServices error: Error?) { 
  211.         if error != nil {  // failed
  212. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))\n error:\(String(describing: error))")
  213.             return
  214.         }
  216. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))")
  219.         for service in peripheral.services ?? [] { 
  220.             peripheral.discoverCharacteristics(nil, for: service)
  221.         }
  222.     }
  225.     // MARK: 服务下的特征
  226.     func peripheral(_ peripheral: CBPeripheral,
  227.                     didDiscoverCharacteristicsFor service:
  228.                         CBService, error: Error?) { 
  230.         if error != nil {  // failed
  231. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))\n service:\(String(describing: service))\n error:\(String(describing: error))")
  232.             return
  233.         }
  235. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))\n service:\(String(describing: service))")
  237.         for characteristic in service.characteristics ?? [] { 
  238.             uuids.append(characteristic)
  239.         }
  240.     }
  243.     // MARK: 获取外设发来的数据
  244.     // 注意，所有的，不管是 read , notify 的特征的值都是在这里读取
  245.     func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) { 
  247.         if error != nil { 
  248. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))\n characteristic:\(String(describing: characteristic.description))\n error:\(String(describing: error))")
  249.             return
  250.         }
  252. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))\n characteristic:\(String(describing: characteristic.description))")
  254.         if let data = characteristic.value { 
  255.             self.peripheralData = data
  256.         }
  257.     }
  259.     //MARK: 检测中心向外设写数据是否成功
  260.     func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) { 
  261.         if let error = error { 
  262. // NSLog("\(#file) \(#line) \(#function)\n peripheral:\(String(describing: peripheral.name))\n characteristic:\(String(describing: characteristic.description))\n error:\(String(describing: error))")
  263.         }
  265.         // TODO
  266.     }
  267. }

所有的NSlog都是可以根据需要打开，方便调试使用的。TODO部分是你可以在上面进一步扩展的地方，当然修改原代码也是可以的。

至于如何使用？

首先，在iOS工程需要先在plist增加

  1. Privacy - Bluetooth Always Usage Description

然后在某个类里实例化这个BLE类，如果是全局都需要进行蓝牙数据传输，那么就把这个类实例在AppDelegate文件里，并且设置为静态，这样就可以全局使用了。

用户需要具体调用的几个函数如下：

  1. // MARK: 1. 扫描设备
  2. func startScanPeripheral(serviceUUIDS: [CBUUID]?, options: [String: AnyObject]?) 
  4. // MARK: 2. 停止扫描
  5. func stopScanPeripheral()
  7. // MARK: 3. 获取搜索到的外接设备
  8. func getPeripheralList()-> [CBPeripheral] 
  10. // MARK: 4.1. 连结设备
  11. func connect(peripheral: CBPeripheral)
  13. // MARK: 4.2. 检测是否建立了连结
  14. func isConnected(peripheral: CBPeripheral) -> Bool
  16. // MARK: 4.3. 获取到当前蓝牙设备可用的消息信道
  17. func getCharacteristic() -> [CBCharacteristic]
  19. // MARK: 4.4. 指定监听信道
  20. func setNotifyCharacteristic(peripheral: CBPeripheral, notify: CBCharacteristic)
  22. // MARK: 5.1. 发送数据
  23. func sendData(data: Data, peripheral: CBPeripheral, characteristic: CBCharacteristic, type: CBCharacteristicWriteType = CBCharacteristicWriteType.withResponse) 
  25. // MARK: 5.2. 接收数据
  26. func recvData() -> Data 
  28. // MARK: 6. 断开连结
  29. func disconnect(peripheral: CBPeripheral)

由于蓝牙设备的通信过程是一个异步过程，等价于创建了一个后台线程对数据服务进行监听，所以如果对于音频流这一类实时会接受大量数据的应用，你可能需要增加一个标记或者其他方式以便处理，具体处理函数为

  1. func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?)

只不对对于文本数据，这个代码已经足够使用了，比较简单的一种处理方法，就是用个定时器，每隔几十毫秒查询一次数据；而比较实时的处理方法，就是做一个回调函数，不过这些都由你自己决定怎么做吧，好运！

发表评论

表情：
评论列表 （有 0 条评论，823人围观）

还没有评论，来说两句吧...

相关阅读

    相关 iOS蓝牙BLE4.0通信功能

    概述 iOS蓝牙BLE4.0通信功能，最近刚学的苹果，为了实现蓝牙门锁的项目，找了一天学习了下蓝牙的原理，亲手测试了一次蓝牙的通信功能，结果成功了，那么就把我学习的东西分

    布满荆棘的人生布满荆棘的人生/ 0 赞/ 319 阅读