О Core Bluetooth замолвите слово… или что делать с загадочным девайсом, когда задач много, а девелопер один

Начну с себя. Я и есть тот самый iOS девелопер, работающий в компании Orion Innovation, которому посчастливилось разбирать функционал и придумать универсальный инструмент, применимый в разных кейсах. И у меня есть вопросы:

• Как часто вам приходится работать с реальными устройствами в мире мобильных девайсов?

• А что, если ваше приложение отличается от типичных клиент-серверных?

На всё про всё – массив байт. В нем заложены команды и они отправляются на блютуз девайс. Как же нам конвертировать это в неклассическую модель данных совсем непохожую на привычный Json? Интересно? Мои идеи и работающие решения в этой статье.

А если серьезно, то продолжительное время мой проект занимается разработкой приложения для управления чипом по протоколу BLE. Отдельная группа инженеров работает непосредственно с железом, занимаясь тем, что готовит API для нас. Сам чип управляет различными девайсами в зависимости от того, с какой платой его сконнектить. Инженеры создали свой функционал, а мы… на стороне клиента должны работать четко по предоставленной ими инструкции.

Я нарисовал схему, которая может помочь понять, как же все устроено:

Казалось бы все просто – есть сервис, у него есть характеристики, берешь, считываешь данные в конкретной характеристике, меняешь/записываешь новое свойство.

Но!

А что если у тебя есть интересный девайс, для которого умные инженеры написали универсальный протокол, позволяющий решить потрясающую задачу– избавить Core Bluetooth от потребности «помнить» массу данных (сервисов) и использовать всего лишь один, читая и записывая ВСЕ данные в одну характеристику. При этом учитывая, что форматы передачи данных могут отличаться, да и сами сообщения тоже. Получаем настоящий швейцарский нож!

Функционал этого чипа настолько велик, что по большому счету не важно, с какими именно девайсом его интегрировать. Важно только, КАК именно он работает.

Инженеры, безусловно, крайне умные и решили свою задачу с элегантностью пантеры. Но что же делать девелоперу?

Я имею более 20 типов сообщений, представляющих собой байтовые массивы. Они легковесны и универсальны – достаточно одной характеристики. Все просто.
Но вот задача – на стороне iOS нужен механизм. Желательно, столь же простой, удобный и универсальный.

Напомню – тип девайса, на котором установлен конкретный чип, не имеет значения. Приложение должно умело и четко коммуницировать, используя Bluetooth.

Что имеем: инженеры написали «протокол», единый для всех типов девайсов. Реализован на стороне девайса. Несет в себе более чем 20 видов сообщений.

Вывод: необходимо покаверить их все. Задача не из простых.

Что-то придумали инженеры, настала очередь iOS.

Для начала все запросы нужно классифицировать, используя предоставленную документацию.

Задача реализована следующим способом:

protocol PeripheralPacketProtocol {
    var header: PeripheralHeader { get set }
    var payload: Payload { get set }
    var crcLow: Byte { get set }
    var crcHight: Byte { get set }
    func toData() -> [Byte]
}

struct PeripheralPacket: PeripheralPacketProtocol {
    var header: PeripheralHeader
    var payload: Payload
    var crcLow: Byte
    var crcHight: Byte
    init(header: PeripheralHeader, payload: Payload) {
        self.header = header
        self.payload = payload
        var packet = header.toData()
        packet.append(contentsOf: payload.toData())
        let data = Data(packet)
        let crc = CRCCalculator.calculateCRCUInt8(data: data)
        self.crcLow = crc.crcLow
        self.crcHight = crc.crcHight
    }
    func toData() -> [Byte] {
        var packet = header.toData()
        packet.append(contentsOf: payload.toData())
        packet.append(crcLow)
        packet.append(crcHight)
        return packet
    }
}

У Вас может возникнуть вопрос – что же такое toData? Это – непосредственно наш массив байт, который в конечном итоге отправится на девайс. В коде это выглядит, как typealias к UINT8.

typealias Byte = UInt8
struct Uuid {
    var value: [Byte] = []
}

Можно заметить, что выделена общая часть запроса. Она будет статичной всегда.

Мы назвали ее header (неизменяемая часть сообщения)

protocol PeripheralHeaderProtocol {
    var destinationAdress: Address { get set }
    var destinationBus: Byte { get set }
    var sourceAddress: Address { get set }
    var sourceBus: Byte { get set }
    var dataLength: Int { get set }
    var reserved1: Byte { get set }
    var reserved2: Byte { get set }
    var command: Command { get set }
    func toData() -> [Byte]

}

struct PeripheralHeader: PeripheralHeaderProtocol {
    var destinationAdress: Address
    var destinationBus: Byte
    var sourceAddress: Address
    var sourceBus: Byte
    var dataLength: Int
    var reserved1: Byte
    var reserved2: Byte
    var command: Command
    init(destinationAdress: Address,
         destinationBus: Byte,
         sourceAddress: Address,
         sourceBus: Byte,
         dataLength: Int,
         reserved1: Byte = 0x00,
         reserved2: Byte = 0x00,
         command: Command) {
        self.destinationBus = destinationBus
        self.destinationAdress = destinationAdress
        self.sourceAddress = sourceAddress
        self.sourceBus = sourceBus
        self.dataLength = dataLength
        self.reserved1 = reserved1
        self.reserved2 = reserved2
        self.command = command
    }
    func toData() -> [Byte] {
        var header = destinationAdress.rawValue.value
        header.append(destinationBus)
        header.append(contentsOf: sourceAddress.rawValue.value)
        header.append(sourceBus)
        header.append(Byte(dataLength))
        header.append(reserved1)
        header.append(reserved2)
        header.append(contentsOf: command.rawValue.value)
        return header
    }
}

Она хранит адреса (source и destination), длину ожидаемого сообщения, а также типы передаваемых параметров.

Все просто – есть протокол, которому соответствует структура, формирующая заголовок.

Header имеет неизменяемую структуру. По большому счету, мы просто объединяем ВСЕ возможные варианты, раскладываем их по enum и выбираем, чем конкретно нам следует воспользоваться.

Перейдем к более сложной части – изменяемой.

Payload:

protocol PayloadProtocol {
    var packetType: PacketType? { get set }
    var object: Object? { get set }
    var objects: [Object]? { get set }
    var objectValue: IEEEFloat? { get set }
    var valueData: Value? { get set }
    func toData() -> [Byte]
}

struct Payload: PayloadProtocol {
    //Request Only Fields
    var packetType: PacketType?
    //Data type (full command model)
    var object: Object?
    //Multyple data type (full command model)
    var objects: [Object]?
    //Response only fields
    // If packetClass Data
    var dataType: DataType?

    var valueData: Value?
    // If packetClass MultiData
    var valueDataArray: [Value]?
    //If it for write data
    var objectValue: IEEEFloat?
    var rejectionStatus: RejectionStatus?
    //Reaponse Init
    // ToData to send
    func toData() -> [Byte] {
        var payload = packetType?.toData() ?? []
        payload.append(contentsOf: object?.toData() ?? [])
        payload.append(contentsOf: objects?.toByteArray() ?? [])
        payload.append(contentsOf: objectValue?.toData() ?? [])
        payload.append(contentsOf: dataType?.rawValue.value ?? [])
        payload.append(contentsOf: rejectionStatus?.rawValue.value ?? [])
        payload.append(contentsOf: valueData?.toData() ?? [])
        return payload
    }
}

В этой части передаются полезные данные, поэтому назовем ее “payload”. На ее состав влияет пара десятков (не преувеличиваю) свойств от типа и параметра запроса, до того, в каком типе данных мы будем передавать/принимать сообщение. В наследие получили 5 типов, и если честно, эта часть требует провести аналитику.

Это непосредственно те данные, которые нам нужно считать/записать на девайс. Соответственно, они комбинируемые. К тому же, сообщения бывают single и multi (то есть, мы просим либо одно значение, либо несколько). Также в этой части хранятся: тип данных, тип команды и непосредственно формат, в котором мы отправляем данные. Завершаем мы пакет сообщения контрольной суммой (про нее отдельно).

Самое приятное в части создания сообщений: понять типы кодировки и написать всевозможные хелперы для них. Ниже я приведу код реализации хелперов, полезных для девелоперов. Может пригодится.

Как было сказано, в проекте данные можно хранить в 5 различных типах, и все они отличаются набором передаваемых параметров.

Покажу на примере IEEFloat, как читать и конвертировать его в запрос.

struct IEEEFloat: IEEEFloatProtocol {
    var forceCode: Byte?
    var dataType: Byte?
    var object: Object?
    var statusCode: Byte?
    var lowerLimitIEEEFloat: Float?
    var upperLimitIEEEFloat: Float?
    var dataValue: Float?
    
  func toData() -> [Byte] {
        var ieeeFloat: [Byte] = []
        if let dataType = dataType {
            ieeeFloat.append(dataType)
        }
        if let forceCode = forceCode {
            ieeeFloat.append(forceCode)
        }
        if let statusCode = statusCode {
            ieeeFloat.append(statusCode)
        }
        ieeeFloat.append(contentsOf: object?.toData() ?? [])
        ieeeFloat.append(contentsOf: lowerLimitIEEEFloat?.bytes.reversed() ?? [])
        ieeeFloat.append(contentsOf: upperLimitIEEEFloat?.bytes.reversed() ?? [])
        ieeeFloat.append(contentsOf: dataValue?.bytes.reversed() ?? [])

        return ieeeFloat
    }
}

Также уделю отдельное внимание калькулятору. На моей стороне это выглядело так:

import Foundation

typealias CRC = (crc: UInt16, crcLow: UInt16, crcHight: UInt16)
typealias ByteCRC = (crc: Byte, crcLow: Byte, crcHight: Byte)

class CRCCalculator {
    static func calculateCRCUInt16(data: Data) -> CRC {
        let length = data.count
        var crcHighByte: UInt16 = 0
        var crcLowByte: UInt16 = 0
        var carryFlag1: UInt16 = 0
        var carryFlag2: UInt16 = 0
        let numOfBytes = length
        for byte in 0..<numOfBytes {
            var crcTempByte = data[byte]
            for _ in 0..<8 {
                carryFlag1 = 0
                if (crcTempByte & 0x01) == 1 {
                    carryFlag1 = 1
                }
                crcTempByte = crcTempByte >> 1
                carryFlag1 = carryFlag1 ^ (crcLowByte & 0x01)
                if carryFlag1 == 1 {
                    crcHighByte = crcHighByte ^ 0x40
                    crcLowByte = crcLowByte ^ 0x02
                }
                carryFlag2 = 0
                if (crcHighByte & 0x01) == 1 {
                    carryFlag2 = 1
                }
                crcHighByte = crcHighByte >> 1
                if carryFlag1 == 1 {
                    crcHighByte = crcHighByte | 0x80
                }
                crcLowByte = crcLowByte >> 1
                if carryFlag2 == 1 {
                    crcLowByte = crcLowByte | 0x80
                }
            }
        }
      return ((crcHighByte * 256) + crcLowByte, crcLowByte, crcHighByte)
    }
    static func calculateCRCUInt8(data: Data) -> ByteCRC {
        let res = CRCCalculator.calculateCRCUInt16(data: data)
        let crc = res.crc.data.byteArray[0] as Byte
        let crcLow = res.crcLow.data.byteArray[0] as Byte
        let crcHight = res.crcHight.data.byteArray[0] as Byte
        return (crc, crcLow, crcHight)
    }
}

Для того, чтобы не городить много бесполезного кода, процесс создания payload, header и подсчет CRC были вынесены в отдельные классы, отвечающие за общий тип сборки данных, а каждый частный соответствует общему протоколу, что делает код легко масштабируемым и изменяемым.

Дженеричность решения реализована с помощью протоколов. Каждый вид сообщения соответствует общему протоколу, что позволяет легко комбинировать их части.

Немного притормозим и подведем первый итог.

Вот что же мы дописали? Ничего. Это просто две виртуальные коробки Lego. Из них можно собрать все что угодно, только нужна инструкция… Чувствуете, о чем я? Так давайте напишем класс, который будет иметь инструкцию, КАК собрать запрос. Он будет знать МЕХАНИЗМ, по которому он будет собирать, как из кубиков, наше сообщение, а также парсить полученный ответ. При этом, такой подход позволяет нам максимально универсально подходить к вопросу сборки сообщений.

Достаточно слов – я приведу конкретный пример того, как собирается сообщение на ieefloat:

func toPeripheralPackageRequest(forPacketClass: PacketClass) -> PeripheralPacket? {
    //ToDo: Here we always convert response
    guard let destinationAdress = Address(rawValue: Uuid(value: Array(self.bytetoArray[0...3]))),
          let sourceAddress = Address(rawValue: Uuid(value: Array(self.bytetoArray[5...8]))),
          let command = Command(rawValue: Uuid(value: [self.bytetoArray[13]]))
          else {
        return nil
    }
    let sourceBusByte = self.bytetoArray[9]
    let destinationBusByte = self.bytetoArray[4]
    let dataLength = Int(self.bytetoArray[10])
    let reserved1 = self.bytetoArray[11]
    let reserved2 = self.bytetoArray[12]
    let header = PeripheralHeader(destinationAdress: destinationAdress,
                                       destinationBus: destinationBusByte,
                                       sourceAddress: sourceAddress,
                                       sourceBus: sourceBusByte,
                                       dataLength: dataLength,
                                       reserved1: reserved1,
                                       reserved2: reserved2,
                                       command: command)
    switch command {
    case .read:
        switch forPacketClass {
        case .data:
            guard let packetProperty = DataProperty(rawValue: Uuid(value: [self.bytetoArray[15]])) else {
                return nil
            }
            let packetType = PacketType(packetClass: forPacketClass,
                                             packetProperty: packetProperty)
            let payload = Payload(packetType: packetType,
                                       object: Object(objectNumberHighByte: self.bytetoArray[16],
                                                           objectNumberLowByte: self.bytetoArray[17],
                                                           objectName: Array(self.bytetoArray[18...25])))
            return PeripheralPacket(header: header, payload: payload)
        case .multiData:
            // At this moment it is only ieee float elements, but in future it can be different types
            let length = (Int(dataLength) - 2) / 10
            var valueDataArray: [Value] = []
            var itemLength = Int(self.bytetoArray[14])
            for _ in 1...length {
                itemLength = Int(self.bytetoArray[14 + itemLength * length - 1])
                let ieeeFloat = IEEEFloat(forceCode: self.bytetoArray[15 + itemLength * length - 1],
                                              statusCode: self.bytetoArray[16],
                                              lowerLimitIEEEFloat: Data(Array(self.bytetoArray[17...20])).floatValue,
                                              upperLimitIEEEFloat: Data(Array(self.bytetoArray[21...24])).floatValue,
                                              dataValue: Data(Array(self.bytetoArray[25...28])).floatValue)
                let value = Value(dataType: .ieeeFloat, ieeeFloat: ieeeFloat)
                valueDataArray.append(value)
            }
            let payload = Payload(valueDataArray: valueDataArray)
            return PeripheralPacket(header: header, payload: payload)
        default:
            return nil
        }
        ...
    default:
        return nil
    }
}

Как вы видите, есть пакет и его компоненты. Для конкретного сообщения.

Все очень просто: начинаем сборку с header. Берем из enum destination и source адреса, выбираем также из перечисления команду, вычисляем длину сообщения, расставляем зарезервированные байты по стандарту. И… вызываем инициализатор.

Аналогичную процедуру проделываем для payload, но! Я УЖЕ учитываю ТИП команды, ТИП запроса и расписываю КАЖДЫЙ способ сборки пакета (ниже приведу только один из 12 вариантов).

Собственно, это мультишот даты определенного типа. Лишнего нам и не нужно)

Отдельно разберу именно сборку ieeFloat:

struct IEEEFloat: IEEEFloatProtocol {
    var forceCode: Byte?
    var dataType: Byte?
    var object: Object?
    var statusCode: Byte?
    var lowerLimitIEEEFloat: Float?
    var upperLimitIEEEFloat: Float?
    var dataValue: Float?
    func toData() -> [Byte] {
        var ieeeFloat: [Byte] = []
        if let dataType = dataType {
            ieeeFloat.append(dataType)
        }
        if let forceCode = forceCode {
            ieeeFloat.append(forceCode)
        }
        if let statusCode = statusCode {
            ieeeFloat.append(statusCode)
        }
        ieeeFloat.append(contentsOf: object?.toData() ?? [])
        ieeeFloat.append(contentsOf: lowerLimitIEEEFloat?.bytes.reversed() ?? [])
        ieeeFloat.append(contentsOf: upperLimitIEEEFloat?.bytes.reversed() ?? [])
        ieeeFloat.append(contentsOf: dataValue?.bytes.reversed() ?? [])

        return ieeeFloat
    }
}

Force code, Status code, нижний и верхний лимиты, а также значение.

Согласно приложенным инструкциям, калькулятор считает чек сумму в моменте инициализации сообщения и сборки массива.

Прошу обратить внимание, что каждый сборщик имеет подобный метод:

func toData() -> [Byte] {
        var packet = header.toData()
        packet.append(contentsOf: payload.toData())
        packet.append(crcLow)
        packet.append(crcHight)
        return packet
}

Он переводит нашу модель в массив байт. Что в конечном итоге дает итоговый массив, который CoreBluetooth отправляет на девайс в указанную характеристику. Следующим способом:

func write(bytes: [Byte], for Characteristic: Characteristic, type: CBCharacteristicWriteType = .withoutResponse) {
        guard let characteristic = cbPeripheral?.characteristics.first(where: {
            $0.Characteristic == Characteristic
        }) else {
            return
        }
        cbPeripheral?.writeValue(Data(bytes), for: characteristic, type: type)
    }

Мы берем конкретный массив байт и передаем его в известную характеристику, ожидая получить ответ после записи на девайс.

Конструкция получается достаточно громоздкой. Но в ней есть известные плюсы – легко масштабируемый код, в котором есть возможность изменить любое из свойств.

Выводы

По факту статья получилась даже не совсем о Core Bluetooth, а скорее о том, какой инструмент можно создать для работы с порой катастрофически большим объёмом данных, которые можно последовательно передавать на девайс в легковесном формате байтовых массивов.

Кроме того, я думаю Вы сможете воспользоваться простыми, но удобными хелперами для конвертации данных.

До скорых встреч.

Хелперы:

extension Data {
    var byteArray: [Byte] {
        let bufferPointer = UnsafeBufferPointer(start: (self as NSData).bytes.assumingMemoryBound(to: Byte.self), count: count)
        return Array(bufferPointer)
    }
    var floatValue: Float {
        return Float(bitPattern: UInt32(bigEndian: self.withUnsafeBytes { $0.load(as: UInt32.self) }))
    }
    
    var intValue: Int {
        return self.reduce(0) { value, byte in
            return value << 8 | Int(byte)
        }
    }
    var stringValue: String {
        if let str = NSString(data: self, encoding: String.Encoding.utf8.rawValue) as String? {
            return str
        } else {
            return ""
        }

    }
}


extension UInt16 {
    var data: Data {
        var int = self
        return Data(bytes: &int, count: MemoryLayout<UInt16>.size)
    }
}

extension Float {
   var bytes: [UInt8] {
       withUnsafeBytes(of: self, Array.init)
   }
}

func hexToString() -> String {
        
        var finalString = ""
        let chars = Array(self)
        
        for count in stride(from: 0, to: chars.count - 1, by: 2){
            let firstDigit =  Int.init("\(chars[count])", radix: 16) ?? 0
            let lastDigit = Int.init("\(chars[count + 1])", radix: 16) ?? 0
            let decimal = firstDigit * 16 + lastDigit
            let decimalString = String(format: "%c", decimal) as String
            finalString.append(Character.init(decimalString))
        }
        return finalString
        
    }
    
    func base64Decoded() -> String? {
        guard let data = Data(base64Encoded: self) else { return nil }
        return String(data: data, encoding: .init(rawValue: 0))
    }

    func ranges(of string: String) -> [NSRange] {
        var ranges = [NSRange]()
        var searchStartIndex = self.startIndex

        while searchStartIndex < self.endIndex,
            let range = self.range(of: string, range: searchStartIndex..<endIndex),
            !range.isEmpty {

            let nsRange = NSRange(range, in: self)
            ranges.append(nsRange)
            searchStartIndex = range.upperBound
        }

        return ranges
    }

    func rangeOfMatches(for pattern: String) -> [NSRange] {
        do {
            let regex = try NSRegularExpression(pattern: pattern)

            return regex
                .matches(in: self, range: NSRange(startIndex..., in: self))
                .compactMap { $0.range }

        } catch {
            return []
        }
    }