l'iPhone ne permet pas de découvrir des Services sur un Bluetooth LE tag sur la reconnexion

J'ai été confronté à un problème similaire avec CoreBluetooth pour se connecter à des appareils Bluetooth LE, dans mon cas, la connexion à des appareils iOS (périphériques) à partir de mon Mac (centre).

Si je reçois correctement, le modèle est tout à fait cohérente, la première fois que j'utilise mon Mac app pour le débogage, il est toujours détecté et connecté à tous les appareils bluetooth LE devices (périphériques), le plus important, il a également découvrir leur services/caractéristiques amende. Le problème commence dans la deuxième manche (par exemple, changer une partie du code, frappé cmd-R pour relancer le débogage). La centrale détecte les périphériques et les relie entre eux, mais il ne parvient pas à découvrir tous les services/caractéristiques. En d'autres termes, le délégué peripheral:didDiscoverServices: et peripheral:didDiscoverCharacteristicsForService:error: jamais appelée.

De la solution après beaucoup d'essais et d'erreurs, et il est étonnamment simple. Il semble que CoreBluetooth caches services et characteristics pour les périphériques qui sont toujours connecté, même si localement on dirait qu'il a été déconnecté de l'application, le périphérique maintient toujours une connexion bluetooth pour le système. Pour ce type de connexions, il n'est pas nécessaire de (re)découvrir les services et caractéristiques, il suffit d'accéder directement à partir de la périphérie de l'objet, vérifier nil à savoir si l'on doit découvrir. Aussi, comme mentionné, depuis le périphérique est dans un état qui est entre les connexions, il est préférable de faire appel à cancelPeripheralConnection: droit avant de tenter de se connecter. L'essentiel comme suit, en supposant que nous avons déjà découvert le périphérique se connecte à:

-(void) centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI
{
    [central cancelPeripheralConnection:peripheral]; //IMPORTANT, to clear off any pending connections    
    [central connectPeripheral:peripheral options:nil];
}

-(void) centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral
{
    peripheral.delegate = self;

    if(peripheral.services)
        [self peripheral:peripheral didDiscoverServices:nil]; //already discovered services, DO NOT re-discover. Just pass along the peripheral.
    else
        [peripheral discoverServices:nil]; //yet to discover, normal path. Discover your services needed
}

-(void) peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error
{
    for(CBService* svc in peripheral.services)
    {
        if(svc.characteristics)
            [self peripheral:peripheral didDiscoverCharacteristicsForService:svc error:nil]; //already discovered characteristic before, DO NOT do it again
        else
            [peripheral discoverCharacteristics:nil
                                     forService:svc]; //need to discover characteristics
    }
}

-(void) peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error
{
    for(CBCharacteristic* c in service.characteristics)
    {
        //Do some work with the characteristic...
    }
}

Cela fonctionne bien pour moi que pour un CBCentralManager dans le Mac app. Jamais testé en iOS, mais je suppose que ça doit être assez similaire.

OriginalL'auteur P.L.

J'ai eu le même problème. il semble se produire environ 1/3 du temps dans mon cas. J'ai essayé la solution proposée par P. L. mais je n'ai eu aucun succès sur iOS. Il y a peut-être beaucoup de pièces en mouvement à l'œuvre ici, qui peuvent contribuer à ce problème (bluetooth firmware de l'appareil, CoreBluetooth, etc.) mais je l'ai résolu par un simple suivi des dispositifs qui sont en attente de service/caractéristique de la découverte dans un NSMutableDictionary et en utilisant le PGCD de vérifier si elle avait terminé, c'est de la découverte dans un laps de temps raisonnable, et d'essayer à nouveau si nécessaire. Donc quelque chose comme ceci:

- (void)requestDiscoverServicesForPeripheral:(CBPeripheral *)peripheral 
{
      peripheral.delegate = self;
      NSString *uuid =[self stringUUIDForUUID:peripheral.UUID];
      NSLog(@"discovering %d services ", self.interestingServices.count);
      [peripheral discoverServices:self.interestingServices];
      [self.pendingConnectionDevices setObject:peripheral forKey:uuid];
       __weak typeof(self) weakSelf = self;
      dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 *NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        if ([weakSelf.pendingConnectionDevices objectForKey:uuid]) {

               //request discover services again
               NSLog(@"services did not discover, requesting again!");
               [weakSelf.btManager cancelPeripheralConnection:peripheral];
               [weakSelf.btManager connectPeripheral:peripheral options:nil];
         }
    });
 }

Puis, quand peripheral:didDiscoverServices:error appelle de nouveau je le supprime de mon pendingConnectionDevices dictionnaire. Cela semble fonctionner assez bien. Je l'ai vu essayer de découvrir des services jusqu'à 3 fois avant de réussir. J'espère que cette aide.

OriginalL'auteur Grahambo

J'ai essayé d'appliquer toutes les réponses ci-dessus, mais ça ne marchait pas pour moi parce que j'ai été absent CBPeripheralDelegate de la classe.

class BLEHandler : NSObject, CBCentralManagerDelegate, CBPeripheralDelegate{

  func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {

    peripheral.delegate = self

    peripheral.discoverServices(nil)

    print("Connected: \(peripheral.state == .connected ? "YES" : "NO")")
  }

  func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {

    for service: CBService in peripheral.services! {
        peripheral.discoverCharacteristics(nil, for: service)
        print(service)
    }
  }

}

OriginalL'auteur Maihan Nijat

Mon mal de tête a été causée par le manque de une forte référence au périphérique

J'ai donc ajouter la référence et le problème a disparu

private var activePeripheral: CBPeripheral?

func connect(_ peripheral: CBPeripheral) {
        disconnect(peripheral)
        activePeripheral = peripheral
        self.central.connect(peripheral, options: nil)
    }

OriginalL'auteur HotJard