由于需要蓝牙设备，这儿就不上效果图了。
先说说 蓝牙协议吧。之前在用到蓝牙代码的时候，搞不懂怎么进行通信，而网上大多的文章都是介绍ios蓝牙代码的部分，这儿我就项目中的协议来说说。
FE39BFCA-C3B7-4B2B-99E1-5125B870CE96.png
就通过指令下发来介绍吧。
49ECB240-9E9F-414A-B626-BC6807AE7D14.png
这是蓝牙协议中的一个，对设备进行写入时间的指令。
最终APP会发类似这样的指令5501111213141308011010001200000000FF,当然我们是遵守指令协议规则的，那么下面我来介绍这条指令是怎样构成的。
就通过16进制字节来说吧，指令分为两大类，写或读，这里写是第一个字节55,如果是读就是FF。
1.写或读（55 或 FF）
2.协议版本（01）（PROTOCOL）
3.设备对应的id，4个字节去定义。（11121314）（DEVICE）
4.协议中的命令id，一个字节（13）（CMD）
5.要发送的内容长度，这儿是8个长度，故是08。（PACKSIZE）
6.内容中的具体指令。（DATA）
7.校验位2个字节，当然需要根据算法来。
这样就构成了一个完整的蓝牙指令了。
了解了蓝牙协议后，再来看看怎样去通过代码去转换十六进制到十进制，或是转成字符串。
那么先看看蓝牙代码那一块吧。
这儿我用一个单例来控制蓝牙那儿的代码，先说说这一块的逻辑。
1.在需要用到蓝牙列表中，先通过单例中实现蓝牙的协议方法，主要是看手机的蓝牙状态。
2.在手机蓝牙正常开启后，获得手机周围的蓝牙的设备。
3.点击某一个需要连接的蓝牙设备，通过特定服务的特征值进行区分连接。
4.在3的基础之上我们进而可以通过写和读的外设服务的特征值。
5.以上全部准备完毕之后，手机会监听设备发过来的指令（读），并在相应的方法中进行回应；而写是手机APP主动发出的，直接调用方法即可。
这儿我通过模拟场景来用代码介绍：
ConnectBluetoothVC 这个控制器启动的时候，需要通过蓝牙单例去触发相应的准备工作，它的界面显示的是蓝牙设备的列表。
override func viewDidLoad() {
super.viewDidLoad()
MBProgressHUD.showAdded(to: self.view, animated: true)
BluetoothManager.shareBlueInstanse().scanDevice()
blueToothNotification()
}
func blueToothNotification() {
NotificationCenter.default.addObserver(self, selector: #selector(reloadTableView(note:)), name: Notification.Name(rawValue: BLUE_TOOTH_Notification), object: nil)
RSToothWrite_Read_Manager.shared().openBluetoothNote()
}
当然这儿还做了一个通知的初始化，用来监听蓝牙设备发过来的指令（读）。
那么在RSToothWrite_Read_Manager这个类中，这个主要负责指令的生成，写或读的方法。这个类我也是用单例的形式进行，因为如果是对象的话，考虑到对象如果销毁的话，监听方法就不能被触发了。
swift单例的创建：
class func shared() -> RSToothWrite_Read_Manager {
return sharedManager
}
private static let sharedManager: RSToothWrite_Read_Manager = {
let shared = RSToothWrite_Read_Manager.init()
return shared
}()
蓝牙指令读的通知的监听：这是设备发送请求APP当前时间的指令。
func openBluetoothNote() {//监听蓝牙读的通知
NotificationCenter.default.addObserver(self, selector: #selector(getDeviceTime), name: NSNotification.Name(rawValue:BLUE_TOOTH_Device_Time), object: nil)
}
然后就是指令的构建了：
// app -> 设备
func appToDevice() -> String {
var appString = ""
if (UserDefault.object(forKey: "DeviceID") != nil) {
let string: String = UserDefault.object(forKey: "DeviceID") as! String
appString = "5501" + string
}
return appString
}
当然这儿用到了设备的id，但这是在哪儿初始化的呢？
这儿我和硬件那边商量，是在APP连接好了蓝牙的时候，会发送请求时间的指令，那么APP就会记录到设备的id，至于那一块的部分在蓝牙单例中会说到。
在这个指令单例中主要说说写入时间的指令的构建以及写入。
//参数的格式 weekone: xx ; beginTime: xx:xx:xx timeType: xx
func writeTimeToDevice(weekone: String,
beginTime: String,
endTime: String,
timeType: String,
completed completion: (() -> Swift.Void)? = nil) { //写入时间
let beginString = RS_OC_Helper.string(with: beginTime.components(separatedBy: ":"))
let endString = RS_OC_Helper.string(with: endTime.components(separatedBy: ":"))
let codeString1 = appToDevice() + "1308"
let codeString = codeString1 + timeType + beginString! + endString! + weekone
sendCodeStringToDevice(codeString: codeString, completed: completion)
}
func sendCodeStringToDevice(codeString: String, completed completion: (() -> Swift.Void)? = nil) {
let codeData: Data = Helper.hex(toBytes: codeString)
let checkCodeStr = Helper.getCheckCodeStr(codeData)
let allString = codeString + checkCodeStr!
let allCodeData = Helper.hex(toBytes: allString)
BluetoothManager.shareBlueInstanse().write(allCodeData, complete: completion)
}
这儿的block是为了在蓝牙写入完成的时候进行回调的。（当初想写入蓝牙成功后，再把该设备的这个记录写到服务器，但后来发现这样同步进行用户体验是在太差，就让蓝牙指令的写入和服务器的写入异步进行，但在block中会提示蓝牙写入的结果）。
指令的帮助类：这是用oc写的，用的话，可以进行oc，swift的混合编程。
1.String -> Data
+ (NSData *)hexToBytes:(NSString *)str
{
NSMutableData* data = [NSMutableData data];
int idx;
for (idx = 0; idx+2 <= str.length; idx+=2) {
NSRange range = NSMakeRange(idx, 2);
NSString* hexStr = [str substringWithRange:range];
NSScanner* scanner = [NSScanner scannerWithString:hexStr];
unsigned int intValue;
[scanner scanHexInt:&intValue];
[data appendBytes:&intValue length:1];
}
return data;
}
2.获取某个字节(在NSData的扩展类中)
//在index处获取一个字节
- (Byte)getByteAtIndex:(NSUInteger)index{
Byte value = 0;
if(index < self.length){
[self getBytes:&value range:NSMakeRange(index, 1)];
}
return value;
}
//转为16进制字符串
- (NSString*)toHexString{
const unsigned char *dataBuffer = (const unsigned char *)[self bytes];
if (!dataBuffer)
return [NSString string];
NSUInteger dataLength = [self length];
NSMutableString *hexString = [NSMutableString stringWithCapacity:(dataLength * 2)];
for (int i = 0; i < dataLength; ++i)
[hexString appendString:[NSString stringWithFormat:@"%02lx", (unsigned long)dataBuffer[i]]];
return [NSString stringWithString:hexString];
}
3.NSData->NSString
+ (NSString*)coverFromHexDataToStr:(NSData*)hexData {
NSString* result;
const unsigned char* dataBuffer = (const unsigned char*)[hexData bytes];
if(!dataBuffer) {
return nil;
}
NSUInteger dataLength = [hexData length];
NSMutableString* hexString = [NSMutableString stringWithCapacity:(dataLength * 2)];
for(int i = 0; i < dataLength; i++){
[hexString appendString:[NSString stringWithFormat:@"%02lx", (unsigned long)dataBuffer[i]]];
}
result = [NSString stringWithString:hexString];
return result;
}
4.十进制->十六进制
+ (NSString *)getHexByDecimal:(NSUInteger)decimal { // 十进制 -- 十六进制
NSString *hex =@"";
NSString *letter;
NSInteger number;
for (int i = 0; i<9; i++) {
number = decimal % 16;
decimal = decimal / 16;
switch (number) {
case 10:
letter =@"A"; break;
case 11:
letter =@"B"; break;
case 12:
letter =@"C"; break;
case 13:
letter =@"D"; break;
case 14:
letter =@"E"; break;
case 15:
letter =@"F"; break;
default:
letter = [NSString stringWithFormat:@"%ld", number];
}
hex = [letter stringByAppendingString:hex];
if (decimal == 0) {
break;
}
}
return hex;
}
5.取某一个字节的数值（12131415），想要取第二个字节数值13。
+ (NSUInteger)contentLengthOfData:(NSData *)data {
NSUInteger contenNum = [data getByteAtIndex:1];
return contenNum;
}
上面中的sendCodeStringToDevice方法中用到了蓝牙单例中的方法，然后把需要的指令通过其中的方法写入。
那么接下来看看蓝牙单例类BluetoothManager，这个类主要负责蓝牙协议，指令的写入与读取。
在类ConnectBluetoothVC中也用到了蓝牙单例进行蓝牙的初始化准备工作。
+ (instancetype)shareBlueInstanse
{
static BluetoothManager *model = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
model = [[BluetoothManager alloc] init];
});
return model;
}
- (instancetype)init
{
self = [super init];
if (self) {
_cMgr = [[CBCentralManager alloc] initWithDelegate:self queue:nil];
_mutPerArr = [NSMutableArray array];
}
return self;
}
- (void)scanperpheral
{
if ([self.cMgr isScanning]) {
[self.cMgr stopScan];
}
[self.cMgr scanForPeripheralsWithServices:nil // 通过某些服务筛选外设
options:nil]; // dict,条件
}
- (void)scanDevice {
[self.mutPerArr removeAllObjects];
[self scanperpheral];
}
- (void)stopScan {
[self.cMgr stopScan];
}
- (void)centralManagerDidUpdateState:(CBCentralManager *)central
{
NSLog(@"%s, line = %d", __FUNCTION__, __LINE__);
switch (central.state) {
case CBManagerStateUnknown:
NSLog(@">>>CBCentralManagerStateUnknown");
break;
case CBManagerStateResetting:
NSLog(@">>>CBCentralManagerStateResetting");
break;
case CBManagerStateUnsupported:
NSLog(@">>>CBCentralManagerStateUnsupported");
break;
case CBManagerStateUnauthorized:
NSLog(@">>>CBCentralManagerStateUnauthorized");
break;
case CBManagerStatePoweredOff:
NSLog(@">>>CBCentralManagerStatePoweredOff");
break;
case CBManagerStatePoweredOn:
NSLog(@">>>CBCentralManagerStatePoweredOn");
[self.cMgr scanForPeripheralsWithServices:nil options:nil];
break;
default:
break;
}
}
准备工作做好后，之后手机APP会获取周围的蓝牙设备。
- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary<NSString *,id> *)advertisementData RSSI:(NSNumber *)RSSI
{
NSLog(@"%s, line = %d, per = %@, data = %@, rssi = %@", __FUNCTION__, __LINE__, peripheral, advertisementData, RSSI);
if (![self.mutPerArr containsObject:peripheral] && peripheral.name != nil) {
[self.mutPerArr addObject:peripheral];
[[NSNotificationCenter defaultCenter] postNotificationName:@"BluetoothNoti" object:self.mutPerArr];
}
}
并通过发送通知给ConnectBluetoothVC,需要发送的数据就是外设设备数组。
ok，在界面中我们就会看到所有的蓝牙设备了，之后用户会点击连接某一个设备时：
- (void)connectPeriphralDidTouchCell:(CBPeripheral *)peripheral {
self.per = peripheral;
[self.cMgr connectPeripheral:self.per options:nil];
}
- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral
{
NSLog(@"%s, line = %d", __FUNCTION__, __LINE__);
[self showAlertView:[NSString stringWithFormat:@">>>连接到名称为（%@）的设备-成功",peripheral.name] value:@""];
[self.cMgr stopScan];
self.per.delegate = self;
[self.per discoverServices:nil];
}
- (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error
{
NSLog(@"%s, line = %d", __FUNCTION__, __LINE__);
[self showAlertView:[NSString stringWithFormat:@">>>连接到名称为（%@）的设备-失败",peripheral.name] value:@""];
}
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error
{
if (!error) {
for (CBService *service in peripheral.services) {
NSLog(@"serviceUUID:%@", service.UUID.UUIDString);
if ([SERVICE_UUID isEqualToString:[service.UUID.UUIDString lowercaseString]]) {
//发现特定服务的特征值
[service.peripheral discoverCharacteristics:nil forService:service];
}
}
}
}
// 外设发现service的特征
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error
{
NSLog(@"peripheral discover :%@", peripheral);
for (CBCharacteristic *characteristic in service.characteristics) {
if ([[characteristic.UUID.UUIDString lowercaseString] containsString:Notify_UUID]) {
[self.per setNotifyValue:YES forCharacteristic:characteristic];
}else if ([WRITE_UUID isEqualToString:[characteristic.UUID.UUIDString lowercaseString]]) {
self.writeCharacteristic = characteristic;
}
}
}
而这几个uuid参数就是开始蓝牙文件协议中定义好的数值：
#define SERVICE_UUID @"fff0"
#define Notify_UUID @"fff1"
#define WRITE_UUID @"fff3"
经过这两层比较，如果设备连接是正确的话，这样读和写的准备工作都弄好了，接下来如果是读到了设备发送过来的指令，就会：
// 获取characteristic的值（监听指令）
- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(nonnull CBCharacteristic *)characteristic error:(nullable NSError *)error
{
//打印出characteristic的UUID和值
//!注意，value的类型是NSData，具体开发时，会根据外设协议制定的方式去解析数据
if (characteristic.value == nil) {
return;
}
if ([Helper getTimeFromDevice:characteristic.value]) { //获取发送时间指令的通知
[[NSNotificationCenter defaultCenter] postNotificationName:@"GetDeviceTime" object:nil];
}
}
//监听是否是获取时间指令 （获取时间指令）, 同时初始化设备的id信息
+ (BOOL )getTimeFromDevice:(NSData *)value {
NSString *valueString = [self coverFromHexDataToStr:value];
if ([valueString hasPrefix:@"FF"] || [valueString hasPrefix:@"ff"]) {
if ([self checkCodeIsRight:value]) {
NSRange range = NSMakeRange(12, 2);
NSString *typeString = [valueString substringWithRange:range];
if ([typeString isEqualToString:@"11"]) {
NSString *str = [valueString substringWithRange:NSMakeRange(4, 8)];
[[NSUserDefaults standardUserDefaults] setObject:str forKey:@"DeviceID"];
[[NSUserDefaults standardUserDefaults] synchronize];
}
return [typeString isEqualToString:@"11"];
}
}
return NO;
}
这儿就说到了初始化设备id的地方了。
然后就是写了，指令的写入。
- (void)writeData:(NSData *)data complete:(void (^)(void))completion {
if (self.writeCharacteristic == nil) {
[self showAlertView:@"请先确认连接蓝牙设备" value:@""];
return;
}
self.actionBlock = completion;
[self.per writeValue:data forCharacteristic:self.writeCharacteristic type:CBCharacteristicWriteWithResponse];
}
// 写入成功
- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic error:(nullable NSError *)error {
if (!error) {
if (self.actionBlock) {
self.actionBlock();
}
} else {
NSLog(@"WriteVale Error = %@", error);
}
}
- (void)showAlertView:(NSString *)message value:(NSString *)value {
UIAlertView *alert = [[UIAlertView alloc] initWithTitle:message
message:value
delegate:nil
cancelButtonTitle:@"确定"
otherButtonTitles:nil];
[alert show];
}
当然block的回调会在指令完成的方法中执行。
这样蓝牙指令的整个流程就大致是完成了，我这个蓝牙协议的类是用oc写的（之前用的是swift写的，但老是不能正确的写入指令，而oc写的就可以，没办法目前这一块的代码用oc写了），所以需要swift和oc混合编程。
最后在某个控制器需要写入的地方调用：
RSToothWrite_Read_Manager.shared().writeTimeToDevice(weekone: (self?.weekCodeString)!,
beginTime: startTime,
endTime: endTime,
timeType: "01") {
RSHelper.showHudOnView(view: RSHelper.topControllerView(), withMsg: "设备设置时间成功")
}
最后的最后贴上我说的逻辑图
3CCBFB12-80FA-4BC9-AE13-E719194EC3E4.png
结尾给出蓝牙类的两个文件的GitHub地址吧
