écoutant pour un événement bluetooth de périphérique de dégagement dans swift

Question

J'ai un bouton de tableau de bord qui fonctionne avec Bluetooth basse énergie. Je peux scanner et trouver, me connecter et découvrir ses services.

Maintenant, je veux écouter pour voir si son bouton est pressé ou non. Mais il semble que j'ai de sérieux problèmes avec la pièce. Je suis un peu nouveau chez Swift, alors si vous m'aidez s'il vous plaît comment le résoudre, je l'apprécie vraiment.

ceci est mon code rapide:

import CoreBluetooth 
import UIKit 

struct DisplayPeripheral{ 
    var peripheral: CBPeripheral? 
    var lastRSSI: NSNumber? 
    var isConnectable: Bool? 
} 

class PeripheralViewController: UIViewController { 

    @IBOutlet weak var statusLabel: UILabel! 
    @IBOutlet weak var bluetoothIcon: UIImageView! 
    @IBOutlet weak var scanningButton: ScanButton! 

    var centralManager: CBCentralManager? 
    var peripherals: [DisplayPeripheral] = [] 
    var viewReloadTimer: Timer? 
    let BEAN_NAME = "Security Tag" 
    let BEAN_SCRATCH_UUID = CBUUID(string: "90946c81-e466-4a43-9974-949e465d35a1") 
    let BEAN_SERVICE_UUID = CBUUID(string: "00001c00-d102-11e1-9b23-000efb0000a7") 

    var selectedPeripheral: CBPeripheral? 

    @IBOutlet weak var tableView: UITableView! 

    required init?(coder aDecoder: NSCoder) { 
     super.init(coder: aDecoder) 

     //Initialise CoreBluetooth Central Manager 
     centralManager = CBCentralManager(delegate: self, queue: DispatchQueue.main) 
    } 

    override func viewWillAppear(_ animated: Bool) { 
     super.viewWillAppear(animated) 

     viewReloadTimer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(PeripheralViewController.refreshScanView), userInfo: nil, repeats: true) 
    } 

    override func viewWillDisappear(_ animated: Bool) { 
     super.viewWillDisappear(animated) 

     viewReloadTimer?.invalidate() 
    } 

    func updateViewForScanning(){ 
     statusLabel.text = "Scanning BLE Devices..." 
     bluetoothIcon.pulseAnimation() 
     bluetoothIcon.isHidden = false 
     scanningButton.buttonColorScheme(true) 
    } 

    func updateViewForStopScanning(){ 
     let plural = peripherals.count > 1 ? "s" : "" 
     statusLabel.text = "\(peripherals.count) Device\(plural) Found" 
     bluetoothIcon.layer.removeAllAnimations() 
     bluetoothIcon.isHidden = true 
     scanningButton.buttonColorScheme(false) 
    } 

    @IBAction func scanningButtonPressed(_ sender: AnyObject){ 
     if centralManager!.isScanning{ 
      centralManager?.stopScan() 
      updateViewForStopScanning() 
     }else{ 
      startScanning() 
     } 
    } 

    func startScanning(){ 
     peripherals = [] 
     self.centralManager?.scanForPeripherals(withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: true]) 
     updateViewForScanning() 
     let triggerTime = (Int64(NSEC_PER_SEC) * 10) 
     DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + Double(triggerTime)/Double(NSEC_PER_SEC), execute: {() -> Void in 
      if self.centralManager!.isScanning{ 
       self.centralManager?.stopScan() 
       self.updateViewForStopScanning() 
      } 
     }) 
    } 

    func refreshScanView() 
    { 
     if peripherals.count > 1 && centralManager!.isScanning{ 
      tableView.reloadData() 
     } 
    } 

    override func prepare(for segue: UIStoryboardSegue, sender: Any?) { 
     if let destinationViewController = segue.destination as? PeripheralConnectedViewController{ 
      destinationViewController.peripheral = selectedPeripheral 
     } 
    } 
} 

extension PeripheralViewController: CBCentralManagerDelegate{ 
    func centralManagerDidUpdateState(_ central: CBCentralManager){ 
     //if (central.state == CBCentralManagerState.poweredOn){ 
      startScanning() 
     //}else{ 
      // do something like alert the user that ble is not on 
     //} 
    } 

    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber){ 

     for (index, foundPeripheral) in peripherals.enumerated(){ 
      if foundPeripheral.peripheral?.identifier == peripheral.identifier{ 
       peripherals[index].lastRSSI = RSSI 
       return 
      } 
     } 

     let isConnectable = advertisementData["kCBAdvDataIsConnectable"] as! Bool 
     if(peripheral.name == BEAN_NAME) 
     { 
      print(peripheral.name) 
      print(peripheral.identifier) 
      print("is?",isConnectable) 
      let displayPeripheral = DisplayPeripheral(peripheral: peripheral, lastRSSI: RSSI, isConnectable: isConnectable) 
      peripherals.append(displayPeripheral) 
     } 

     tableView.reloadData() 
    } 


} 

extension PeripheralViewController: CBPeripheralDelegate { 
    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) { 
     print("Error connecting peripheral: \(error?.localizedDescription)") 
    } 

    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) 
    { 
     print("Peripheral connected") 
     performSegue(withIdentifier: "PeripheralConnectedSegue", sender: self) 
     peripheral.discoverServices(nil) 

    } 
    func peripheral(peripheral: CBPeripheral, didDiscoverServices error: NSError?) 
    { 
     print("jdbsud") 

     for service in peripheral.services! 
     { 
      let thisService = service as CBService 

      if service.uuid == BEAN_SERVICE_UUID { 
       peripheral.discoverCharacteristics(nil,for: thisService) 
      } 
     } 
    } 


} 

extension PeripheralViewController: UITableViewDataSource { 
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell{ 

     let cell = self.tableView.dequeueReusableCell(withIdentifier: "cell")! as! DeviceTableViewCell 
     cell.displayPeripheral = peripherals[indexPath.row] 
     cell.delegate = self 
     return cell 
    } 

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int{ 
     return peripherals.count 
    } 
} 

extension PeripheralViewController: DeviceCellDelegate{ 
    func connectPressed(_ peripheral: CBPeripheral) { 
     if peripheral.state != .connected { 
      selectedPeripheral = peripheral 
      peripheral.delegate = self 
      centralManager?.connect(peripheral, options: nil) 
      //you can listen to the commands here 


     } 
    } 

    } 

J'ai imprimé quelque chose dans le fonc périphérique (périphérique: CBPeripheral, erreur de didDiscoverServices: NSError) pour vérifier si je rentre même là ou non, apparemment, je ne suis pas entrez cette partie du code.

Answer 1

après avoir travaillé dur sur le problème, j'ai moi-même réussi à le résoudre.

après avoir trouvé les services que j'aurais ajouté ces deux fonctions au code et cela fonctionne comme un charme:

func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) { 
    debugPrint("Enabling ...") 

    for characteristic in service.characteristics! { 
     let thisCharacteristic = characteristic as CBCharacteristic 

     debugPrint("Characteristic: ", thisCharacteristic.uuid) 

     if thisCharacteristic.uuid == BEAN_SCRATCH_UUID { 
      debugPrint("Set to notify: ", thisCharacteristic.uuid) 

      // Prepare to show data 

      self.peripheral.setNotifyValue(true, for: thisCharacteristic) 
     } 
    } 
} 

func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) { 
    if characteristic.uuid == BEAN_SCRATCH_UUID { 
     let content = String(data: characteristic.value!, encoding: String.Encoding.utf8) 

     debugPrint("Notified.") 
    } 
}