Swift3でのBLEアプリ開発-その2-

open class SenStickDeviceManager : NSObject, CBCentralManagerDelegate {
let queue: DispatchQueue
var manager: CBCentralManager?

// Properties, KVO
dynamic open fileprivate(set) var devices:[SenStickDevice] = []
dynamic open fileprivate(set) var isScanning: Bool = false

// Initializer, Singleton design pattern.
open static let sharedInstance: SenStickDeviceManager = SenStickDeviceManager()

fileprivate override init() {
 queue = DispatchQueue(label: "senstick.ble-queue", attributes: nil)
 super.init()
 manager = CBCentralManager.init(delegate: self, queue: queue)
}

// 1秒毎にコールバックします。0になれば終了です。
  open func scan(_ duration:TimeInterval = 5.0, callback:((_ remaining: TimeInterval) -> Void)?)
  {
      // デバイスリストをクリアする
      DispatchQueue.main.async(execute: {
          self.devices = []
      })

      // スキャン中、もしくはBTの電源がオフであれば、直ちに終了。
      if manager!.isScanning || manager!.state != .poweredOn {
          callback?(0)
          return
      }

      // スキャン時間は1秒以上、30秒以下に制約
      let scanDuration = max(1, min(30, duration))
      scanCallback = callback

      // 接続済のペリフェラルを取得する
      for peripheral in (manager!.retrieveConnectedPeripherals(withServices: [SenStickUUIDs.advertisingServiceUUID])) {
          addPeripheral(peripheral, name:nil)
      }

      // スキャンを開始する。
      manager!.scanForPeripherals(withServices: [SenStickUUIDs.advertisingServiceUUID], options: nil)
      isScanning = true

      var remaining = scanDuration
      scanTimer = DispatchSource.makeTimerSource(flags: DispatchSource.TimerFlags(rawValue: UInt(0)), queue: DispatchQueue.main)
      scanTimer?.scheduleRepeating(deadline: DispatchTime.now(), interval: 1.0) // 1秒ごとのタイマー
      scanTimer?.setEventHandler {
          // 時間を-1秒。
          remaining = max(0, remaining - 1)
          if remaining <= 0 {
              self.cancelScan()
          }
          // 継続ならばシグナリング
          self.scanCallback?(remaining)
      }
      scanTimer!.resume()
  }

public static let ControlServiceUUID:CBUUID        = {return SenStickUUIDs.createSenstickUUID(0x2000)}()
public static let StatusCharUUID:CBUUID            = {return SenStickUUIDs.createSenstickUUID(0x7000)}()

public static let SenStickServiceUUIDs: [CBUUID: [CBUUID]] = [

    DeviceInformationServiceUUID : [ManufacturerNameStringCharUUID, HardwareRevisionStringCharUUID, FirmwareRevisionStringCharUUID, SerialNumberStringCharUUID],

    BatteryServiceUUID: [BatteryLevelCharUUID],

    ControlServiceUUID   : [StatusCharUUID, AvailableLogCountCharUUID, StorageStatusCharUUID, DateTimeCharUUID, AbstractCharUUID, DeviceNameCharUUID],

// イニシャライザ
  required public init?(device:SenStickDevice)
  {
      self.device = device

      guard let service = device.findService(SenStickUUIDs.DeviceInformationServiceUUID) else { return nil }

// 過度な呼び出しにならないように、メインスレッドでの処理が終わったら次の処理を入れるようにする。
var flag:Bool // obj_sync_enter()/obj_sync_exit()を使い排他処理したフラグ

if(self.flag == false) {
    self.flag = true
    DispatchQueue.main.async(execute: {
        self.delegate?.didUpdateLogData(self)
        self.flag = false
    })

open class SenStickSensorService<T: SensorDataPackableType, S: RawRepresentable> where S.RawValue == UInt16, T.RangeType == S

open class AccelerationSensorService: SenStickSensorService<CMAcceleration, AccelerationRange>

// 加速度センサーの範囲設定値。列挙側の値は、BLEでの設定値に合わせている。
public enum AccelerationRange : UInt16, CustomStringConvertible
{
    case accelerationRange2G   = 0x00 // +- 2g
    case accelerationRange4G   = 0x01 // +- 4g
    case accelerationRange8G   = 0x02 // +- 8g
    case accelerationRange16G  = 0x03 // +- 16g

    public var description : String
    {
        switch self {
        case .accelerationRange2G: return "2G"
        case .accelerationRange4G: return "4G"
        case .accelerationRange8G: return "8G"
        case .accelerationRange16G:return "16G"
        }
    }
}

// センサーからの生データ。16ビット 符号付き数値。フルスケールは設定レンジ値による。2, 4, 8, 16G。
struct AccelerationRawData
{
    var xRawValue : Int16
    var yRawValue : Int16
    var zRawValue : Int16

    init(xRawValue:Int16, yRawValue:Int16, zRawValue:Int16)
    {
        self.xRawValue = xRawValue
        self.yRawValue = yRawValue
        self.zRawValue = zRawValue
    }

    // 物理センサーの1GあたりのLBSの値
    static func getLSBperG(_ range: AccelerationRange) -> Double
    {
        switch range {
        case .accelerationRange2G: return 16384
        case .accelerationRange4G: return 8192
        case .accelerationRange8G: return 4096
        case .accelerationRange16G:return 2048
        }
    }

    static func unpack(_ data: [Byte]) -> AccelerationRawData
    {
        let x = Int16.unpack(data[0..<2])
        let y = Int16.unpack(data[2..<4])
        let z = Int16.unpack(data[4..<6])

        return AccelerationRawData(xRawValue: x!, yRawValue: y!, zRawValue: z!)
    }
}

extension CMAcceleration : SensorDataPackableType
{
    public typealias RangeType = AccelerationRange

    public static func unpack(_ range:AccelerationRange, value: [UInt8]) -> CMAcceleration?
    {
        guard value.count >= 6 else {
            return nil
        }

        let rawData  = AccelerationRawData.unpack(value)
        let lsbPerG  = AccelerationRawData.getLSBperG(range)

        // FIXME 右手系/左手系などの座標変換など確認すること。

        return CMAcceleration(x: Double(rawData.xRawValue) / Double(lsbPerG), y: Double(rawData.yRawValue) / Double(lsbPerG), z: Double(rawData.zRawValue) / Double(lsbPerG))
    }
}