1.iOS 蓝牙数据BCC(异或校验)
2.【IOS】BLE-蓝牙空中升级(OAD)
3.ios设备app作为蓝牙外设端
4.iOS 蓝牙

iOS 蓝牙数据BCC(异或校验)

       深入解析iOS蓝牙数据传输中的蓝蓝牙BCC(异或校验)实现

       在iOS开发中，蓝牙数据传输的牙源源码安全性和准确性至关重要。其中，下载BCC（异或校验）是蓝蓝牙入户登记源码一种常见的数据验证机制，用于确保数据在传输过程中没有被篡改。牙源源码下面，下载让我们来详细解读这段关键的蓝蓝牙函数HSMCheckBCCWithHex，它在蓝牙数据包中扮演着守护者的牙源源码角色。

       首先，下载函数接收一个以十六进制表示的蓝蓝牙字符串(hexstring)，其核心逻辑在于对每个字符进行异或运算。牙源源码happytime源码我们看到，下载cheack变量初始化为0，蓝蓝牙这将用来累积每个字符的牙源源码校验值。

       对于输入的下载每个十六进制字符，函数会将其转换为十进制数值。requestapi源码在循环中，如果needAddStr为空，就直接存储当前字符；否则，将其与当前字符拼接，并通过HSMTOOL工具进行转换。dynamodb源码转换后的十进制数，与cheack进行异或运算，以累积校验值。异或操作的特性在于，相同的thinkphpcrm源码输入结果为0，不同则为1，这有助于检测数据传输过程中是否发生位错误。

       在每个字符处理完成后，cheack会被清零，为下一次计算做准备。当循环结束后，累积的校验值会被转换回十六进制并返回，通过这个值，接收方可以验证发送方的数据完整性和正确性。

       总结：在iOS蓝牙数据传输中，HSMCheckBCCWithHex函数是实现数据安全传输的重要步骤。通过异或校验，它确保了数据的完整性和准确性，为开发者提供了强有力的保障。对于蓝牙应用开发者来说，理解并熟练运用这样的校验方法，是提升应用程序稳定性和用户体验不可或缺的一部分。

【IOS】BLE-蓝牙空中升级(OAD)

       è“ç‰™ä¸ºCC ios升级蓝牙固件;

       1.头文件

        升级要用到的ID

        2.获取蓝牙列表,选择需要升级的蓝牙

       3.获取所有的特征值,找到我们需要的通道,设置通道的模式为监测通道变化

        传过去所需的参数

       4.指定蓝牙的代理和代理方法

       5.选择要升级的文件(这里是本地)

        6.开始进行蓝牙升级:

        (1)发送一个字节数据来获取蓝牙设备的当前设备信息

        (2)在代理处接收返回数据

        (3)处理接收的数据,如果版本不相同,就把本地文件的固件信息通过 通道1 发送过去;

        固件信息包含的信息有：固件版本、固件长度、固件类型

       (4)在代理处接收返回数据(如果成功会通过 通道2 返回数据)

       (5)处理数据,开始发送本地文件;收到的数据是需要发送数据的序号(-FFFF,高位在后;,,...FF,,...)

        此时有两种方法:

        第一种是每次都通过接收到的序号来发送数据,就不需要改变蓝牙的发送和接收模式;

        第二种是直接按照一定的间隔去发送数据;只要和硬件规定好时间就可以基本保证成功;

        由于第一种方法的速度很慢,所以我选择的第二种方式;

       (6)设置定时器,间隔时间ms;由于是直接发送不需要返回所以选择 CBCharacteristicWriteWithoutResponse 的方式;

       (7)传输结束后,硬件设备会自启,蓝牙会断开;

       demo没整理 见谅

       /huasali/blueToothDemo

ios设备app作为蓝牙外设端

        苹果手机可以作为蓝牙外设端，被蓝牙中央端来扫描连接交互数据，实现模拟蓝牙外设硬件。通过阅读CoreBluetooth库，可以找到一个CBPeripheralManager的类，该类主要的作用就是允许你来管理发布services，把这些services广告给其他的设备。如果想详细了解该类的属性和方法，建议去看看CoreBluetooth/CBPeripheralManager.h。

        下面来模拟一个简单的蓝牙外设端。

        上面中，serviceUUID为给外设配置的服务的UUID，可以有多个，characteristicUUID为给service添加的特征的UUID，也可以有多个，可自定义可读可写等等属性.characteristicValue为characteristic的值,localName和serviceUUIDs分别为键CBAdvertisementDataLocalNameKey和CBAdvertisementDataServiceUUIDsKey对应的value。由于作为外设端时发送广播包，广播包中提供包含着两个键值对，如果有另外的键值对想要发送，例如CBAdvertisementDataServiceDataKey，会出现错误。

        首先要导入蓝牙库

        #import <CoreBluetooth/CoreBluetooth.h>

遵守协议

        创建peripheralManager对象

        创建了peripheralManager对象后会自动调用回调方法didUpdateState

        - (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)peripheral {

        if (peripheral.state != CBPeripheralManagerStatePowerOn) {

        return;

        }

        }

给外设配置服务和特征

        - (void)configServiceAndCharacteristicForPeripheral {

        CBMutableCharacteristic *writeReadCharacteristic = [[CBMutableCharacteristic alloc] initWithType:characteristicUUID properties:CBCharacteristicPropertyWrite | CBCharacteristicPropertyRead value:nil permissions:CBAttributePermissionsReadEncryptionRequired | CBAttributePermissionsWriteEncryptionRequired];

        CBMutableService *service = [[CBMutableService alloc] initWithType:serviceUUID primary:YES];

        [service setCharacteristics:@[writeReadCharacteristic]];

        [self.peripheralManager addService:service];

        }

调用上面的方法时，会监听didAddService:

        - (void)peripheralManager:(CBPeripheralManager *)peripheral didAddService:(CBService *)service error:(NSError *)error {

        }

开始广播

        调用上 面方法时，会监听DidStartAdvertising:

        - (void)peripheralManagerDidStartAdvertising:(CBPeripheralManager *)peripheral error:(NSError *)error {

        }

当中央端连接上了此设备并订阅了特征时会回调 didSubscribeToCharacteristic:

        - (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didSubscribeToCharacteristic:(CBCharacteristic *)characteristic {

        [self.peripheralManager updateValue:characteristicValue forCharacteristic:characteristic onSubscribedCentrals:nil];

        }

当中央端取消订阅时会调用didUnsubscribeFromCharacteristic:

        - (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didUnsubscribeFromCharacteristic:(CBCharacteristic *)characteristic {

        }

当接收到中央端读的请求时会调用didReceiveReadRequest:

        - (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveReadRequest:(CBATTRequest *)request {

        if (request.characteristic.properties & CBCharacteristicPropertyRead) {

        NSData *data = request.characteristic.value;

        [request setValue:data];

        [self.peripheralManager respondToRequest:request withResult:CBATTErrorSuccess];

        } else {

        [self.peripheralManager respondToRequest:request withResult:CBATTErrorReadNotPermitted];

        }

        }

当接收到中央端写的请求时会调用didReceiveWriteRequest:

        - (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray<CBATTRequest *> *)requests {

        CBATTRequest *request = requests[0];

        if (request.characteristic.properties & CBCharacteristicPropertyWrite) {

        CBMutableCharacteristic *c = (CBMutableCharacteristic *)request.characteristic;

        c.value = request.value;

        [self.peripheralManager respondToRequest:request withResult:CBATTErrorSuccess];

        } else {

        [self.peripheralManager respondToRequest:request withResult:CBATTErrorWriteNotPermitted];

        }

        }

        手机app可以作为一个蓝牙外设端来模拟外设硬件，但广播包里的数据只能包含localName和serviceUUID，相对于外设硬件来说还是有一些不足之处。

iOS 蓝牙

       1. iOS中开发蓝牙常用的系统库是<CoreBluetooth/CoreBluetooth.h>。

        2.蓝牙外设必需为4.0及以上(2.0需要MFI认证)，否则无法进行开发，蓝牙4.0设施由于低耗电，所以也叫做BLE。

        3. CoreBluetooth框架的核心其实是俩东西

            3.1 Peripheral

            3.2 Central

        4. 服务和特征(service characteristic)：简而言之，外部蓝牙中它有若干个服务service（服务你能了解为蓝牙所拥有的可以力），而每个服务service下拥有若干个特征characteristic（特征你能了解为解释这个服务的属性）。

        5. Descriptor（形容）使用来形容characteristic变量的属性。例如，一个descriptor能规定一个可读的形容，或者者一个characteristic变量可接受的范围，或者者一个characteristic变量特定的单位。

             3.1 创建一个CBCentralManager实例来进行蓝牙管理；

             3.2 搜索扫描外围设备；

             3.3 连接外围设备；

             3.4 获得外围设备的服务；

             3.5 获得服务的特征；

             3.6 从外围设备读取数据；

             3.7 给外围设备发送（写入）数据。

         4.1 初始化

        dispatch_queue_t centralQueue = dispatch_queue_create(“centralQueue",DISPATCH_QUEUE_SERIAL);

        NSDictionary *dic = @{ CBCentralManagerOptionRestoreIdentifierKey : restoreIdentifier};

        self.centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:centralQueue options:dic];

        CBCentralManagerOptionRestoreIdentifierKey对应的是一个唯一标识的字符串，用于蓝牙进程被杀掉恢复连接时使用

        4.2 扫描

        /

*

         *扫描设备

         */

        - ( void )scanForDevices:(NSError**)error

        {

            if (CBCentralManagerStatePoweredOn == self .centralManager.state) {

                //取回已连接的service设备

                NSArray* retrievedPeripherals = [ self .centralManagerretrieveConnectedPeripheralsWithServices:@[ self .serviceUUID]];

                for (CBPeripheral* peripheral in retrievedPeripherals){

                    //NSLog(@"retrieved peripheral:%@", peripheral);

                    [ self .delegateclient: self didDiscoverDevice:peripheral.identifier];

                }

                //启动扫描

                if ( self .advertisementUUID) {

                    [ self .centralManager scanForPeripheralsWithServices:@[ self .advertisementUUID ] options:@{ CBCentralManagerScanOptionAllowDuplicatesKey:@YES }];

                } else {

                    [ self .centralManager scanForPeripheralsWithServices: nil options:@{ CBCentralManagerScanOptionAllowDuplicatesKey:@YES }];

        //            [self.centralManager scanForPeripheralsWithServices:nil options:nil];

                }

            } else {

                if (error != NULL ) {

                    *error = [NSErrorerrorWithDomain:HCErrorDomaincode:(SRVClientErrorUnknown+ self .centralManager.state)userInfo: nil ];

                    NSLog(@"[NSError errorWithDomain:HCErrorDomain code:(SRVClientErrorUnknown + self.centralManager.state) userInfo:nil];");

                }

            }

        }

        4.3 发现外围设备

        - ( void )centralManager:(CBCentralManager*)centraldidDiscoverPeripheral:(CBPeripheral*)peripheraladvertisementData:(NSDictionary*)advertisementDataRSSI:(NSNumber*)RSSI {

            NSString*peripheralName = peripheral.name;

            if (peripheralName == nil || peripheralName.length==0) {

                return ;

            }

            if ([peripheralNameisEqualToString:SRV_CLIENT_DEV_NAME] || [peripheralNameisEqualToString:SRV_CLIENT_DFU_NAME]) {

           }

        }

        4.4 连接外围设备

        //蓝牙连接成功回调

        - ( void )centralManager:(CBCentralManager*)centraldidConnectPeripheral:(CBPeripheral*)peripheral {

            [ self .centralManager stopScan];

            peripheral.delegate= self ;

            self .commandNo=0;

            NSLog(@"[D] CentralManager Discover services.");

            NSLog(@"%@", self .peripheral);

            self .peripheral.delegate= self ;

            [ self .peripheral discoverServices:@[ self .serviceUUID]];

            NSLog(@"%@", self .serviceUUID);

            //定时获取RSSI

            if ( self .needReadRSSI) {

                [ self readPeripheralRSSI];

                if (! self .rssiTimer) {

                    self .rssiTimer = [NSTimer scheduledTimerWithTimeInterval:5.0

                                                                  target: self

                                                                selector: @selector (readPeripheralRSSI)

                                                                userInfo: nil

                                                                 repeats: YES ];

                }

            }

        }

        #pragma mark è¿žæŽ¥å¤–设——失败

        - (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error{

            NSLog(@"%@", error);

        }

        #pragma mark å–消与外设的连接回调

        - (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error{

            NSLog(@"%@", peripheral);

        }

        4.5 èŽ·å¾—外围设备的服务

        //发现服务的回调

        - ( void )peripheral:(CBPeripheral*)peripheraldidDiscoverServices:(NSError*)error

        {

            NSLog(@"%@---didDiscoverServices",peripheral);

            if (error){

                NSLog(@"[E] peripheral didDiscoverServices error: %@", error.localizedDescription);

                [ self cancelConnection];

                return ;

            }

            for (CBService* service in peripheral.services){

                NSLog(@"[D] Discover characteristics. For service = %@", service);

                [peripheraldiscoverCharacteristics: nil forService:service];

            }

        }

        //发现特征的回调

        - ( void )peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error

        {

            if (error){

                NSLog(@"[E] peripheral didDiscoverCharacteristicsForService error: %@", error.localizedDescription);

                [ self cancelConnection];

                return ;

            }

            NSLog(@"[D] peripheral DiscoverCharacteristics = %@", service.characteristics);

            //订阅特征

            for (CBCharacteristic*characteristic in service.characteristics){

                if (characteristic.properties & (CBCharacteristicPropertyNotify|CBCharacteristicPropertyIndicate)){

                    if (!characteristic.isNotifying) {

                        if ([ self .ignoreCharacteristicUUIDscontainsObject:characteristic.UUID]) {

                            continue ;

                        }

                        NSLog(@"[D] Enable notify value. For characteristic = %@", characteristic);

                        //d订阅特性当数据频繁改变时用 setNotifyValue 不频繁时用readValueForCharacteristic

                        [peripheralsetNotifyValue: YES forCharacteristic:characteristic];

                    }

                }

            }

        }

        // 订阅后的callback

        - ( void )peripheral:(CBPeripheral *)peripheral didUpdateNotificationStateForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error

        {

            if (error){

                NSLog(@"[E] peripheral didUpdateNotificationStateForCharacteristic error: %@", error.localizedDescription);

                [ self cancelConnection];

                return ;

            }

            if ([ self isAllCharacteristicNotificationEnabled]){

                NSLog(@"订阅成功");

               //authorizeRequest 授权认证

                [ self .delegate clientDidPrepareForOperation: self ];

            }

        //    [self.delegate clientDidPrepareForOperation:self];

        }

        4.6 ä»Žå¤–围设备读取数据

        // peripheral主动发数据，包括写命令后主动返回的状态 读数据的回调

        - ( void )peripheral:(CBPeripheral*)peripheraldidUpdateValueForCharacteristic:(CBCharacteristic*)characteristicerror:(NSError*)error

        {

            if (error) {

                NSLog(@"[E] peripheral didUpdateValueForCharacteristic error: %@ %@", error.localizedDescription,characteristic);

                [ self cancelConnection];

                [ self cleanupOperationUnexpectedly];

                return ;

            }

            NSLog(@"%@",peripheral);

            NSLog(@"%@",characteristic);

            [ self .delegate client: self didUpdateValueForCharacteristic:characteristic.UUID value:characteristic.value];

            if ([characteristic.UUIDisEqual: self .ctrlptUUID]) {

                    if (CTRLPTProgressWaitResp == self .ctrlptProgress) {

                  }

            }

         }

        4.7 ç»™å¤–围设备发送（写入）数据

        - ( BOOL )performOperationSegment:(CBCharacteristic*)characteristic

        {

                 BOOL isLastSegment;

                uint8_tsegment[];

                uint_tindex =0;

                uint_tsegLength;

                NSIntegerforwardLength = self .forwardFlow.length;

                if ((forwardLength - self .forwardOffset) > (- index)) {

                    isLastSegment = NO ;

                    segLength = (- index);

                } else {

                    isLastSegment = YES ;

                    segLength = (forwardLength - self .forwardOffset);

                }

                memcpy(&segment[index], & self .forwardFlow.bytes[ self .forwardOffset], segLength);

                self .forwardOffset+= segLength;

                index += segLength;

                NSData*writeData = [NSDatadataWithBytes:segmentlength:index];

                NSLog(@"[D] Write value = %@. For characteristic = %@", writeData, characteristic);

                [ self .peripheral writeValue:writeData forCharacteristic:characteristic type:CBCharacteristicWriteWithResponse];//对于操控类蓝牙，数据写入要求非常快，其中writeWithSponce写入消耗的时间是writeWithoutSponce的2.3倍，因此尽量改写成writeWithoutSponce来提升写入速率

                 return isLastSegment;

         }

        //是否写入成功的回调

        - ( void )peripheral:(CBPeripheral*)peripheraldidWriteValueForCharacteristic:(CBCharacteristic*)characteristicerror:(NSError*)error

        {

            if (error) {

                NSLog(@"[E] peripheral didWriteValueForCharacteristic error: %@", error);

                [ self cancelConnection];

                [ self cleanupOperationUnexpectedly];

                return ;

            }

            NSLog(@"写入成功----%@",characteristic);

            if ([characteristic.UUIDisEqual: self .ctrlptUUID]) {

                if (CTRLPTProgressWritting == self .ctrlptProgress) {

                    if ([ self performOperationSegment:characteristic]) {

                        self .ctrlptProgress = CTRLPTProgressWaitResp;

                        self .backwardFlow.length=0;

                        self .backwardOffset=0;

                    }

                }

            }

        }

        4.8 如何解析蓝牙数据

       //判断是否第一个包，若是，取出包长度

                                        if (0== self .backwardOffset&& length >=2) {

                                            uint_tcommandLength;

                                            [characteristicDatagetBytes:&commandLengthlength: sizeof (commandLength)];

                                            offset += sizeof (commandLength);

                                            self .backwardLength= commandLength;

                                            [ self .backwardFlowappendData:[characteristicDatasubdataWithRange:NSMakeRange(offset, length - offset)]];

                                        } else {

                                            [ self .backwardFlowappendData:characteristicData];

                                        }