Desarrollo de Bluetooth para iOS: conexión Bluetooth y lectura y escritura de datos

?3. Cree dos nuevos atributos de instancia y un atributo característico

@property (no atómico, fuerte) CBCentralManager *centralManager; //Gestor central

@property (no atómico, fuerte) CBPeripheral *periférico; //Periférico conectado a

@property (no atómico, fuerte) CBCharacteristic *characteristic //Características

p>

?4. Inicializar CBCentralManager para la gestión de Bluetooth

- (void)viewDidLoad {

[super viewDidLoad];

self.centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:dispatch_get_main_queue()]; //Crear una instancia para la gestión de Bluetooth

}

?//Si el administrador del centro es inicializado, se activará lo siguiente. Este método proxy se utiliza para determinar el estado del Bluetooth del teléfono móvil

- (void)centralManagerDidUpdateState:(CBCentralManager *)central {

// Bluetooth está disponible, comience a buscar periféricos

if (central.state == CBManagerStatePoweredOn) {

NSLog(@"Bluetooth disponible");

//Después el administrador central se enciende con éxito Realizar algunas operaciones

//Buscar y escanear periféricos

//Escanear periféricos según SERVICE_UUID Si SERVICE_UUID no está configurado, escanear todos los dispositivos Bluetooth

/ / [self.centralManager startAdvertising:@{CBAdvertisementDataServiceUUIDsKey:@[[CBUUID UUIDWithString:SERVICE_UUID]]}];

[central scanForPeripheralsWithServices:nil opciones:nil];

}

if(central.state == CBManagerStateUnsupported) {

NSLog(@"Este dispositivo no es compatible con Bluetooth");

}

if (central.state == CBManagerStatePoweredOff) {

NSLog(@"Bluetooth está apagado");

}

if ( central.state == CBManagerStateUnknown) {

NSLog(@"El estado actual de Bluetooth no está claro");

}

if (central.state = = CBManagerStateUnauthorized) {

NSLog(@"Bluetooth no autorizado");

}

}

5. ¿Buscar?

Buscar dispositivos periféricos

//Después de ejecutar la acción de escaneo, si se escanea un dispositivo periférico, se volverá a llamar automáticamente al siguiente método de protocolo

/** Si un dispositivo periférico que cumple con los requisitos, devolución de llamada */

- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral adsData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI {

NSLog (@"%@====",peripheral.name);

//Filtrar selectivamente los dispositivos Bluetooth conectados según los nombres de los periféricos

if ( [peripheral.name hasPrefix:@"TEAMOSA"]) {

//Los datos de transmisión transportados por el periférico se procesan aún más aquí

if ([self.peripheraNames containsObject:peripheral. nombre]) {

//Si está incluido en el array, no se agregará

return;

}

//Agregar al nombre del periférico en la matriz

[self.peripheraNames addObject:peripheral.name];

//Marcar el periférico para que su ciclo de vida sea consistente con el de el controlador

self.peripheral = periférico;

// Los periféricos se pueden filtrar según su nombre

// [central connectPeripheral:peripheral options:nil] ;

}

// Conectar periféricos

// [central connectPeripheral:opciones de periféricos:nil];

}

6. Conexión de dispositivos periféricos

//Conéctese a dispositivos periféricos. El administrador central se conecta exitosamente al dispositivo periférico. Si la conexión es exitosa, se volverá a llamar a este método de protocolo.

/** Conexión exitosa*/

- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral{

//Después de que la conexión sea exitosa , servicios y características se pueden descubrir. Detenga la acción de escaneo del dispositivo de administración central. De lo contrario, cuando se esté comunicando con un periférico conectado, si otro periférico transmite y cumple con sus condiciones de conexión, su dispositivo iOS también se conectará a este dispositivo (porque iOS BLE4.0 admite uno). a muchas conexiones), lo que resulta en confusión de datos.

//Detener la acción de escaneo

[self.centralManager stopScan];

//Configurar el proxy periférico

periférica.delegate = self;

// Buscar servicios basados ​​en UUID

// [periférico discoverServices:@[[CBUUID UUIDWithString:SERVICE_UUID]]];

// Servicios de descubrimiento de periféricos, pasar nil significa que no hay filtrado, leer todos los servicios periféricos a la vez

[peripheral discoverServices:nil];

NSLog(@"%s, line = %d, % @=Conexión exitosa", __FUNCTION__, __LINE__, periférico.nombre);

}

//La conexión del periférico falló

/** Devolución de llamada de error de conexión */

- (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)error periférico:(NSError *)error {

NSLog(@" %s, line = % d, %@=Conexión fallida", __FUNCTION__, __LINE__, periférico.nombre);

}

//Se perdió la conexión

/** Desconectar* /

- (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)error periférico:(nullable NSError *)error {

NSLog(@"%s, line = %d, %@=disconnect", __FUNCTION__, __LINE__, periférico.nombre);

// La desconexión se puede configurar para volver a conectar

[central connectPeripheral:opciones periféricas:nil] ;

}

7. Obtener servicios y características del dispositivo periférico

/** Servicio de descubrimiento*/

- (void)periférico :(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error {

// Recorre todos los servicios en el periférico

para (CBService *servicio en periférico.services) {

// NSLog(@"Todos los servicios: %@",servicio);

}

// Aquí solo hay un servicio, así que consíguelo directamente

CBService *service = periférico.services.lastObject;

// Encuentra características en el servicio según UUID

// [periférico discoverCharacteristics:@[[CBUUID UUIDWithString :CHARACTERISTIC_UUID]] paraServicio:servicio];

// [p

periférico discoverCharacteristics:@[service.UUID] forService:service];

[peripheral discoverCharacteristics:nil forService:service];

}

8. Desde el periferia El dispositivo lee datos

// Se llamará cuando se actualice el valor de la función (todos los datos transmitidos desde Bluetooth deben pasar por esta devolución de llamada. En pocas palabras, este método es la única forma de obtener la data) Puede determinar si leer datos del dispositivo periférico

/** Recibir devolución de llamada de datos*/

- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)error de característica: (NSError *)error {

// if (característica == @"El UUID de la característica que deseas o de la característica que has encontrado") {

// //característica .value son los datos que desea

// }

if ([peripheral.name hasPrefix:@"TEAMOSA"]){

NSData *datos = característica.valor;

NSString *valor = [self hexadecimalString:datos];

// NSLog(@"característica(lectura): %@, datos: %@ , valor : %@", característica, dato, valor);

}

// Obtiene los datos enviados por el dispositivo periférico

// NSData * datos = característica.valor;

// self.textFild.text = [[NSString alloc] initWithData:codificación de datos:NSUTF8StringEncoding];

}

9, Enviar (escribir) datos a dispositivos periféricos

//Puedes poner este método en la respuesta del botón, o puedes escribirlo cuando encuentres la función, dependiendo de cómo la uses según según las necesidades de su negocio

//[self.peripherale writeValue:_batteryData forCharacteristic:self.characteristic type:CBCharacteristicWriteWithResponse] //El primer parámetro es el dispositivo Bluetooth conectado. El segundo parámetro es qué característica; escribir a; Los tres parámetros se utilizan para registrar si la escritura se realizó correctamente a través de esta respuesta. Cabe señalar si el atributo de la característica admite la escritura de datos

/** Escribir devolución de llamada de datos*/

- (nulo) periférico:(CBPeripheral *)periférico didWriteValueForCharacteristic:(nonnull CBCharacteristic *)error de característica:(nullable NSError *)error {

/*

typedef NS_OPTIONS(NSUInteger, CBCaracterística

icProperties) {

CBCharacteristicPropertyBroadcast = 0x01,

CBCharacteristicPropertyRead = 0x02,

CBCharacteristicPropertyWriteWithoutResponse = 0x04,

CBCharacteristicPropertyWrite = 0x08,

CBCharacteristicPropertyNotify = 0x10,

CBCharacteristicPropertyIndicate = 0x20,

CBCharacteristicPropertyAuthenticatedSignedWrites = 0x40,

CBCharacteristicPropertyExtendedProperties = 0x80,

CBCharacteristicPropertyNotifyEncryptionRequired ENUM_AVAILABLE (NA, 6_0) = 0x100,

CBCharacteristicPropertyIndicateEncryptionRequired NS_ENUM_AVAILABLE(NA, 6_0) = 0x200

};

Imprime los permisos de las características (characteristic.properties ), puede ver que hay muchos tipos. Esta es una enumeración de NS_OPTIONS, que puede tener múltiples valores.

Los más comunes son leer, escribir, notificar e indicar. Saberlos es básicamente suficiente. Los dos primeros son permisos de lectura y escritura, los dos últimos son notificaciones, dos métodos de notificación diferentes

*/

// NSLog(@"%s, line = %d, char.pro = %d", __FUNCTION__, __LINE__, feature.properties);

// En este momento, dado que la propiedad de enumeración es NS_OPTIONS, una enumeración puede corresponder a varios tipos, por lo que el juicio no puede ser hecho con = pero debe usarse Contiene &

NSLog(@"escribir valor exitoso(escribir éxito): %@", característica);

}

10. Llamada específica al método de escritura de datos del periférico Bluetooth. El ejemplo aquí es llamar al procesamiento en el evento de clic del botón

//Enviar evento de clic del botón

- (void)sendClick {

if (!self.characteristic) {

return;

}

_tempValue = [NSString stringWithFormat:@"%.0f ", ProgressView.centigradeDegree ];

_timeValue = [NSString stringWithFormat:@"%.0ld", (long)progressView1.timeDegree];

NSString *ttData = [NSString stringWithFormat: @"%@, %@U", _tempValue, _timeValue];

// NSString *aaa = [DataCoverTool coverFrom

StringToHexStr:ttData];

// Utilice el tipo NSData para escribir

// NSData *data = [NSKeyedArchiver archivedDataWithRootObject:arry];

NSData *data = [ttData dataUsingEncoding:NSUTF8StringEncoding];

// NSData *data = [self dataWithString:ttData];

//Escribe datos de acuerdo con las características anteriores self.characteristic

[self.peripheral writeValue:data forCharacteristic:self.characteristic type:CBCharacteristicWriteWithResponse];