iOS开发 蓝牙swift＜一＞

蓝牙开发分为中心者模式和管理者模式（也有人说是中心模式和外设模式）：1.常用的就是使用中心者模式作为开发，我们手机作为主机，连接蓝牙外设；2.管理者模式，这个基本用到的比较少，我们手机自己作为外设，自己创建服务和特征，然后有其他的设备连接我们的手机。

基本概念：一个中心设备可以连接多个外部设备，一个外部设备包含一个或多个服务（services），一个服务包含一个或多个特征（characteristic）。其中1.服务可以理解为一个模块的窗口，它是蓝牙外设对外广播一定要有的。2.特征位于服务下面，是具体实现功能的窗口，一般特征都会有value，也就是特征值，特征是与外界交互的最小单位。3.UUID：相当与使用这个模块对映的应用的标识。4.RSSI：信号强度，利用此信息可进行蓝牙测距

流程主要分为以下几步：1、建立中心设备 2、扫描外部设备 3、连接外部设备 4、扫描外备中的服务和特征 5、利用相关的特征与外部设备收发数据。

CoreBluetooth中涉及以下对象类：

CBCentralManager：中心设备类

CBPeripheral：外围设备类

CBCharacteristic：设备特征类

下篇文章会结合实例代码讲解蓝牙开发流程。

1，建立中心设备

引入蓝牙库，声明变量。CBCentralManager 初始化之后，就会回调func centralManagerDidUpdateState(_ central: CBCentralManager)代理方法，检测蓝牙的状态。

        //MARK:----1,创建中心管理对象
        if (self.CBCManager == nil) {
            self.CBCManager = CBCentralManager.init(delegate: self, queue: nil, options: nil)



 func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        //MARK:-- 连接外设
        let peripheral = (self.peripheralDic?.allValues[indexPath.row] as! CBPeripheral)
        
        self.CBCManager?.connect(peripheral, options: nil)
        
    }
    
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        var sta = ""
        
        switch central.state {
        case .unknown:
            sta = "未知"
            break
        case .unsupported:
            sta = "不支持蓝牙"
            break
        case .unauthorized:
            sta = "未授权"
            break
        case .poweredOff:
            sta = "蓝牙关闭"
            break
        case .poweredOn:
            sta = "蓝牙开启"
            break
        default: break
        
        }
        print(sta)
    }

2，扫描外设

    @objc func scanBtnAction()  {
        //MARK:--搜索周边设备
        //参数可过滤外设
        self.CBCManager?.scanForPeripherals(withServices: nil, options: nil)
    }

    //MARK:--扫描外设的回调
    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        
        print( peripheral.name as Any)
        
        if (((self.peripheralDic?.object(forKey: peripheral.name as Any)) != nil) == false) {
            if (peripheral.name != nil) {
                self.peripheralDic?.setObject(peripheral, forKey: peripheral.name! as NSCopying)
                self.tab?.reloadData()
            }
        }
    }

3，连接外设

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        //MARK:-- 连接外设
        let peripheral = (self.peripheralDic?.allValues[indexPath.row] as! CBPeripheral)
        
        self.CBCManager?.connect(peripheral, options: nil)
        
    }

    //MARK:--连接外设的回调
    func centralManager(_ central: CBCentralManager, didConnectperipheral: CBPeripheral) {
        print("didConnectPeripheral--连接外设成功")
        self.CBCManager?.stopScan()
        peripheral?.delegate = self
        //MARK:外设发现特殊服务
        peripheral?.discoverServices([CBUUID.init(string: serviceUUID)])
    }
    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
        print("didFailToConnectPeripheral--连接外设失败,%s",error as Any)
    }
    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
        print("didDisconnectPeripheral--丢失连接")
    }

4，扫描外设中的服务和特征

    //MARK:获得外设服务的回调
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        
        var service:CBService?
        
        for index in 1...peripheral.services!.count {
            service = peripheral.services![index]
            if service!.uuid == CBUUID.init(string: serviceUUID) {
                self.peripheral = peripheral
                //MARK:--发现发现特殊服务的特殊特征
                peripheral.discoverCharacteristics([CBUUID.init(string:charcterUUID)], for: service!)
                return
            }
        }
    }

    //MARK:--获得外设服务特征的回调
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        
        var character:CBCharacteristic?
        
        for index in 1...service.characteristics!.count {
            character = service.characteristics![index]
            if character!.uuid == CBUUID.init(string: charcterUUID) {
                
                self.character = character
                //发现服务特征后，注册特征通知，这样中心设备就可以读取外围发过来的数据了：
                self.peripheral!.setNotifyValue(true, for: character!)
                //MARK:--将指令写入蓝牙
                let data = "".data(using: .utf8)
                self.peripheral!.writeValue(data!, for: character!, type: .withResponse)
                self.peripheral!.discoverDescriptors(for: character!)
                return
            }
        }
    }

5、利用相关的特征与外部设备收发数据

    //MARK:--特征数据写入回调
    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
        print("characteristic写入了")
    }
    
    //MARK:--从外围设备读取数据
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
            let data = characteristic.value
            print(data as Any)
            //解析data
    }
    //中心读取外设实时数据
    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
        
        if characteristic.isNotifying {
            peripheral.readValue(for: characteristic)
        }else{
            self.CBCManager?.cancelPeripheralConnection(peripheral)
        }
    }