如何在 Swift 中读取 BLE 特征浮点数

Question

我正在尝试连接到蓝牙 LE / 蓝牙智能 / BLE 健康设备的健康温度计服务 (0x1809)，正式描述如下：https://developer.bluetooth.org/gatt/services/Pages/ServiceViewer.aspx?u=org.bluetooth.service.health_thermometer.xml。具体来说，我正在请求来自健康温度计特征 (0x2A1C) 的通知，并在此处提供说明：https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.temperature_measurement.xml。

我有不错的 Swift 2 背景，但我从未与 NSData、字节或按位运算符密切合作，而且我对 Little Endian 与 Big Endian 完全陌生，所以这对我和我来说都是新的可以使用一些帮助。该特性有一些内置的逻辑，可以确定您将收到哪些数据。到目前为止，我 100% 的时间都按照标志、温度测量值和时间戳的顺序收到了数据，但不幸的是，我总是会得到“010”的控制逻辑，这意味着我错误地读取了标志。事实上，我认为我错误地引入了时间戳之外的所有内容。我在代码 cmets 中包含了我看到的数据。

我尝试了多种获取此二进制数据的方法。标志是带有位运算符的单字节。温度测量本身是一个浮点数，我花了一些时间才意识到它不是一个 Swift 浮点数，而是一个 ISO/IEEE 标准“IEEE-11073 32 位浮点数”，BLE 规范说“没有指数值” “这里：https://www.bluetooth.com/specifications/assigned-numbers/format-types。我什至不知道那是什么意思。这是我的 didUpdateValueForCharacteristic() 函数的代码，您可以在其中查看我在尝试新尝试时注释掉的多次尝试：

// Parse Characteristic Response
let stream = NSInputStream( data: characteristic.value! )
stream.open()    // IMPORTANT

// Retrieve Flags
var readBuffer = Array<UInt8>( count: 1, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
var flags = String( readBuffer[ 0 ], radix: 2 )
flags = String( count: 8 - flags.characters.count, repeatedValue: Character( "0" ) ) + flags
flags = String( flags.characters.reverse() )
print( "FLAGS: \( flags )" )

// Example data:
// ["01000000"]
//
// This appears to be wrong.  I should be getting "10000000" according to spec

// Bluetooth FLOAT-TYPE is defined in ISO/IEEE Std. 11073
// FLOATs are 32 bit
// Format [8bit exponent][24bit mantissa]

/* Attempt 1 - Read in a Float - Doesn't work since it's an IEEE Float
readBuffer = Array<UInt8>( count: 4, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
var tempData = UnsafePointer<Float>( readBuffer ).memory

// Attempt 2 - Inverted bytes- Doesn't work since it's wrong and it's an IEEE Float
let readBuffer2 = [ readBuffer[ 3 ], readBuffer[ 2 ], readBuffer[ 1 ], readBuffer[ 0 ] ]
var tempValue = UnsafePointer<Float>( readBuffer2 ).memory
print( "TEMP: \( tempValue )" )

// Attempt 3 - Doesn't work for 1 or 2 since it's an IEEE Float
var f:Float = 0.0
memccpy(&f, readBuffer, 4, 4)
print( "TEMP: \( f )" )
var f2:Float = 0.0
memccpy(&f2, readBuffer2, 4, 4)
print( "TEMP: \( f2 )" )

// Attempt 4 - Trying to Read an Exponent and a Mantissa - Didn't work
readBuffer = Array<UInt8>( count: 1, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let exponent = UnsafePointer<Int8>( readBuffer ).memory

readBuffer = Array<UInt8>( count: 3, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let mantissa = UnsafePointer<Int16>( readBuffer ).memory

let temp = NSDecimalNumber( mantissa: mantissa, exponent: exponent, isNegative: false )
print( "TEMP: \( temp )" )

// Attempt 5 - Invert bytes - Doesn't work
readBuffer = Array<UInt8>( count: 4, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let exponentBuffer = [ readBuffer[ 3 ] ]
let mantissaBuffer = [ readBuffer[ 2 ], readBuffer[ 1 ], readBuffer[ 0 ] ]
let exponent = UnsafePointer<Int16>( exponentBuffer ).memory
let mantissa = UnsafePointer<UInt64>( mantissaBuffer ).memory
let temp = NSDecimalNumber( mantissa: mantissa, exponent: exponent, isNegative: false )
print( "TEMP: \( temp )" )

// Attempt 6 - Tried a bitstream frontwards and backwards - Doesn't work
readBuffer = Array<UInt8>( count: 4, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )

var bitBuffer: [String] = Array<String>( count:4, repeatedValue: "" )
for var i = 0; i < bitBuffer.count; i++ {
  bitBuffer[ i ] = String( readBuffer[ i ], radix: 2 )
  bitBuffer[ i ] = String( count: 8 - bitBuffer[ i ].characters.count, repeatedValue: Character( "0" ) ) + bitBuffer[ i ]
  //bitBuffer[ i ] = String( bitBuffer[ i ].characters.reverse() )
}
print( "TEMP: \( bitBuffer )" )

// Attempt 7 - More like the Obj. C code - Doesn't work
readBuffer = Array<UInt8>( count: 4, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let value = UnsafePointer<UInt32>( readBuffer ).memory
let tempData = CFSwapInt32LittleToHost( value )

let exponent = tempData >> 24
let mantissa = tempData & 0x00FFFFFF

if ( tempData == 0x007FFFFF ) {
  print(" *** INVALID *** ")
  return
}

let tempValue = Double( mantissa ) * pow( 10.0, Double( exponent ) )
print( "TEMP: \( tempValue )" )

// Attempt 8 - Saw that BLE spec says "NO Exponent" - Doesnt' work
readBuffer = Array<UInt8>( count: 1, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )

readBuffer = Array<UInt8>( count: 3, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let tempValue = UnsafePointer<Float>( readBuffer ).memory
print( "TEMP: \( tempValue )" )

// Example data:
// ["00110110", "00000001", "00000000", "11111111"]
//
// Only the first byte appears to ever change.
*/


// Timestamp - Year - works
readBuffer = Array<UInt8>( count: 2, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let year = UnsafePointer<UInt16>( readBuffer ).memory

// Timestamp Remainder - works
readBuffer = Array<UInt8>( count: 5, repeatedValue: 0 )
stream.read( &readBuffer, maxLength: readBuffer.count )
let month = readBuffer[ 0 ]
let day = readBuffer[ 1 ]
let hour = readBuffer[ 2 ]
let minute = readBuffer[ 3 ]
let second = readBuffer[ 4 ]
print( "TIMESTAMP: \( month )/\( day )/\( year ) \( hour ):\( minute ):\( second )" )

我在 Objective C 中找到了这个示例，但我不知道 (https://github.com/AngelSensor/angel-sdk/blob/b7459d9c86c6a5c72d8e58b696345b642286b876/iOS/SDK/Services/HealthThermometer/ANHTTemperatureMeasurmentCharacteristic.m)，并且我尝试过使用它，但我不清楚到底发生了什么：

    // flags
    uint8_t flags = dataPointer[0];
    dataPointer++;

    // temperature
    uint32_t tempData = (uint32_t)CFSwapInt32LittleToHost(*(uint32_t *)dataPointer);
    dataPointer += 4;

    int8_t  exponent = (int8_t)(tempData >> 24);
    int32_t mantissa = (int32_t)(tempData & 0x00FFFFFF);

    if (tempData == 0x007FFFFF) {
        return;
    }

    float tempValue = (float)(mantissa*pow(10, exponent));

如果有人能帮助我了解如何从这个 BLE 特性中提取标志和温度计测量值，我将不胜感激。谢谢。

我被要求在下面提供示例数据。这是我的示例数据（总共 12 个字节）：

["00000010", "00110011", "00000001", "00000000", "11111111", "11100000", "00000111", "00000100", "00001111", "00000001", "00000101", "00101100"]

-OR-

<025e0100 ffe00704 0f11150f>

Answer 1

有时可能有点棘手，但这是我的简单实现，希望对您有所帮助

private func parseThermometerReading(withData someData : NSData?) {
    var pointer = UnsafeMutablePointer<UInt8>(someData!.bytes)
    let flagsValue = Int(pointer.memory) //First 8 bytes are the flag

    let temperatureUnitisCelsius = (flagsValue & 0x01) == 0
    let timeStampPresent         = (flagsValue & 0x02) > 0
    let temperatureTypePresent   = ((flagsValue & 0x04) >> 2) > 0

    pointer = pointer.successor() //Jump over the flag byte (pointer is 1 bytes, so successor will automatically hot 8 bits), you can also user pointer = pointer.advanceBy(1), which is the same

    let measurementValue : Float32 = self.parseFloat32(withPointer: pointer) //the parseFloat32 method is where the IEEE float conversion magic happens
    pointer = pointer.advancedBy(4) //Skip 32 bits (Since pointer holds 1 byte (8 bits), to skip over 32 bits we need to jump 4 bytes (4 * 8 = 32 bits), we are now jumping over the measurement FLOAT

    var timeStamp : NSDate?

    if timeStampPresent {
        //Parse timestamp
        //ParseDate method is also a simple way to convert the 7 byte timestamp to an NSDate object, see it's implementation for more details
        timeStamp = self.parseDate(withPointer: pointer)
        pointer = pointer.advancedBy(7) //Skip over 7 bytes of timestamp
    }

    var temperatureType : Int = -1 //Some unknown value

    if temperatureTypePresent {
        //Parse measurement Type
        temperatureType = Int(pointer.memory))
    }
}

现在介绍将字节转换为 IEEE 浮点数的小方法

internal func parseFloat32(withPointer aPointer : UnsafeMutablePointer<UInt8>) -> Float32 {
    // aPointer is 8bits long, we need to convert it to an 32Bit value
    var rawValue = UnsafeMutablePointer<UInt32>(aPointer).memory //rawValue is now aPointer, but with 32 bits instead of just 8
    let tempData = Int(CFSwapInt32LittleToHost(rawValue)) //We need to convert from BLE Little endian to match the current host's endianness

    // The 32 bit value consists of a 8 bit exponent and a 24 bit mantissa
    var mantissa : Int32  = Int32(tempData & 0x00FFFFFF) //We get the mantissa using bit masking (basically we mask out first 8 bits)

    //UnsafeBitCast is the trick in swift here, since this is the only way to convert an UInt8 to a signed Int8, this is not needed in the ObjC examples that you'll see online since ObjC supports SInt* types
    let exponent = unsafeBitCast(UInt8(tempData >> 24), Int8.self)
    //And we get the exponent by shifting 24 bits, 32-24 = 8 (the exponent)
    var output : Float32 = 0

    //Here we do some checks for specific cases of Negative infinity/infinity, Reserved MDER values, etc..
    if mantissa >= Int32(FIRST_RESERVED_VALUE.rawValue) && mantissa <= Int32(ReservedFloatValues.MDER_NEGATIVE_INFINITY.rawValue) {
        output = Float32(RESERVED_FLOAT_VALUES[mantissa - Int32(FIRST_S_RESERVED_VALUE.rawValue)])
    }else{
        //This is not a special reserved value, do the normal mathematical calculation to get the float value using mantissa and exponent.
        if mantissa >= 0x800000 {
            mantissa = -((0xFFFFFF + 1) - mantissa)
        }
        let magnitude = pow(10.0, Double(exponent))
        output = Float32(mantissa) * Float32(magnitude)
    }
    return output
}

下面是如何将日期解析为 NSDate 对象

internal func parseDate(withPointer aPointer : UnsafeMutablePointer<UInt8>) -> NSDate {

    var bytePointer = aPointer //The given Unsigned Int8 pointer
    var wordPointer = UnsafeMutablePointer<UInt16>(bytePointer) //We also hold a UInt16 pointer for the year, this is optional really, just easier to read
    var year        = Int(CFSwapInt16LittleToHost(wordPointer.memory)) //This gives us the year
    bytePointer     = bytePointer.advancedBy(2) //Skip 2 bytes (year)
    //bytePointer     = wordPointer.successor() //Or you can do this using the word Pointer instead (successor will make it jump 2 bytes)

    //The rest here is self explanatory
    var month       = Int(bytePointer.memory)
    bytePointer     = bytePointer.successor()
    var day         = Int(bytePointer.memory)
    bytePointer     = bytePointer.successor()
    var hours       = Int(bytePointer.memory)
    bytePointer     = bytePointer.successor()
    var minutes     = Int(bytePointer.memory)
    bytePointer     = bytePointer.successor()
    var seconds     = Int(bytePointer.memory)

    //Timestamp components parsed, create NSDate object
    var calendar            = NSCalendar.currentCalendar()
    var dateComponents      = calendar.components([.Year, .Month, .Day, .Hour, .Minute, .Second], fromDate: NSDate())
    dateComponents.year     = year
    dateComponents.month    = month
    dateComponents.day      = day
    dateComponents.hour     = hours
    dateComponents.minute   = minutes
    dateComponents.second   = seconds

    return calendar.dateFromComponents(dateComponents)!
}

对于使用 FLOAT 类型的任何其他 BLE 特性，这几乎是所有技巧

Answer 2

我做过一些与你类似的事情......我不确定这是否仍然与你相关，但让我们深入研究一下......也许我的代码可以给你一些见解：

首先，获取 NSData 到 UInt8 的数组：

let arr = Array(UnsafeBufferPointer(start: UnsafePointer<UInt8>(data.bytes), count: data.length))

我们遵循的规范表明，该数组中的前 3 个位置将代表尾数，最后一个位置将代表指数（在 -128..127 范围内）：

    let exponentRaw = input[3]
    var exponent = Int16(exponentRaw)

    if exponentRaw > 0x7F {
        exponent = Int16(exponentRaw) - 0x100
    }

    let mantissa = sumBits(Array(input[0...2]))

    let magnitude = pow(10.0, Float32(exponent))
    let value = Float32(mantissa) * magnitude

...辅助功能：

func sumBits(arr: [UInt8]) -> UInt64 {
    var sum : UInt64 = 0
    for (idx, val) in arr.enumerate() {
        sum += UInt64(val) << ( 8 * UInt64(idx) )
    }
    return sum
}