Live Streaming sensor data
Issue is that sensors are disconnected in between live streaming for small amount of time and then reconnected after small amount of time. What we need is constant live streaming so we cannot loose data in between live streaming.


Step:- 1 
Scan Sensors
func startScanning(){ 
    MetaWearScanner.shared.startScan(allowDuplicates: true) { (device) in
            if (!device.isMetaBoot) {
                DispatchQueue.main.async {
                    if (device.mac == self.upperArmMac){
                        self.upperArm = device
                        self.foreArmDataStreaming()
                    } else if (device.mac == self.foreArmMac) {
                        self.foreArm = device
                        self.upperArmDataStreaming()
                    }
                }
                
            }
        }
}


Step:- 2
Streaming first sensor data

    func upperArmDataStreaming(){
        guard let _ = upperArm else {return}
        
        
        upperArm.connectAndSetup().continueWith { t in
            
            t.result?.continueWith { t in
               // self.upperArm.clearAndReset()
                print("Upper Arm disconnected")
            }
            
            if let error = t.error {
                //self.upperArmDataStreaming()
                print(error)
                mbl_mw_sensor_fusion_enable_data(self.upperArm?.board, MBL_MW_SENSOR_FUSION_DATA_CORRECTED_ACC);
                mbl_mw_sensor_fusion_start(self.upperArm?.board);
            } else {
                
                mbl_mw_sensor_fusion_set_mode(self.upperArm?.board,MBL_MW_SENSOR_FUSION_MODE_NDOF)
                mbl_mw_sensor_fusion_set_acc_range(self.upperArm?.board, MBL_MW_SENSOR_FUSION_ACC_RANGE_16G)
                mbl_mw_sensor_fusion_set_gyro_range(self.upperArm?.board, MBL_MW_SENSOR_FUSION_GYRO_RANGE_2000DPS)
                mbl_mw_sensor_fusion_write_config(self.upperArm?.board)
                
                
                self.correctedAccerlationUpperArm = mbl_mw_sensor_fusion_get_data_signal(self.upperArm?.board, MBL_MW_SENSOR_FUSION_DATA_CORRECTED_ACC)
                 
                mbl_mw_datasignal_subscribe(self.correctedAccerlationUpperArm, bridge(obj: self)) { (context, data) in
                    guard let _ = context else{return}
                    
                    let this: CalibrateViewController = bridge(ptr: context!)
                    
                    guard let _ = this.correctedAccerlationUpperArm else{return}
                    DispatchQueue.main.async {
                        this.upperArmOnOffLabel.text = "On"
                    }
                    if let datax = data?.pointee{
                        let obj: MblMwCorrectedCartesianFloat = datax.valueAs()
                        this.upperArmY = obj.y + this.upperArmCalibration
                        
                        this.upperArmX = obj.x
                        //var upperArmAngle = acos(this.upperArmY)
                        var upperArmAngle = atan2(-obj.x, -obj.y)
                        upperArmAngle = upperArmAngle.isNaN ? 0 : upperArmAngle
                        this.Yup = (upperArmAngle * 180) / .pi
                        
                        //print(upperArmAngle)
                        //Check up angle for upper arm
                        if this.Yup > -120 && this.Yup < 0{
                            this.upperArmFlag = true
                        }
                        //if values are less than 0 then it will rotate whole hand so only when upperArmAngle is greater than 0 then update upper arm angle
                        DispatchQueue.main.async {
                            if this.isCalibrateEnabled{
                                //Stop Arm moving in oposite direction
                                //&& ((upperArmAngle * 180) / .pi < -90 )
                                if upperArmAngle < 0 {
                                    if upperArmAngle < -1.50{
                                        if let scene = this.scene{
                                            scene.updateUpperArmAngle(CGFloat(upperArmAngle) * 2)
                                        }
                                    }
                                    
                                }else{
                                    
                                    if let scene = this.scene{
                                        scene.updateUpperArmAngle()
                                    }
                                }
                            }
                            
                        }
                    }
                }
                mbl_mw_sensor_fusion_enable_data(self.upperArm?.board, MBL_MW_SENSOR_FUSION_DATA_CORRECTED_ACC);
                mbl_mw_sensor_fusion_start(self.upperArm?.board);

            }
        }
    }

Step:- 3
Streaming second sensor data

    func foreArmDataStreaming(){
        guard let _ = foreArm else {return}
        self.foreArm?.connectAndSetup().continueWith { t in
            
            t.result?.continueWith { t in
                print(t.error)
            }
            
            if let error = t.error {
                print(error)
            
                mbl_mw_sensor_fusion_enable_data(self.foreArm?.board, MBL_MW_SENSOR_FUSION_DATA_CORRECTED_ACC);
                mbl_mw_sensor_fusion_start(self.foreArm?.board);
            } else {
                
                mbl_mw_sensor_fusion_set_mode(self.foreArm?.board,MBL_MW_SENSOR_FUSION_MODE_NDOF)
                mbl_mw_sensor_fusion_set_acc_range(self.foreArm?.board, MBL_MW_SENSOR_FUSION_ACC_RANGE_16G)
                mbl_mw_sensor_fusion_set_gyro_range(self.foreArm?.board, MBL_MW_SENSOR_FUSION_GYRO_RANGE_2000DPS)
                
                mbl_mw_sensor_fusion_write_config(self.foreArm?.board)
                
                self.correctedAccerlationForeArm = mbl_mw_sensor_fusion_get_data_signal(self.foreArm?.board, MBL_MW_SENSOR_FUSION_DATA_CORRECTED_ACC)
                
                mbl_mw_datasignal_subscribe(self.correctedAccerlationForeArm, bridge(obj: self)) { (context, data) in
                    guard let _ = context else{return}
                    let this: CalibrateViewController = bridge(ptr: context!)
                    guard let _ = this.correctedAccerlationForeArm else{return}
                    DispatchQueue.main.async {
                        this.lowerArmOnOffLabel.text = "On"
                    }
                    if let datax = data?.pointee{
                        let obj: MblMwCorrectedCartesianFloat = datax.valueAs()
                        this.foreArmY = obj.y + this.foreArmCalibration
                        this.foreArmX = obj.x
                        var lowerArmAngle = -atan2(-obj.y, -obj.x)
                        lowerArmAngle = lowerArmAngle.isNaN ? 0 : lowerArmAngle
                        this.Yfor = (lowerArmAngle * 180) / .pi
                        
                        this.Xfor = (this.foreArmX * 180) / .pi
                
                        if this.Yfor > 140 && this.Xfor > 45{
                            this.foreArmFlag = true
                        }
                        DispatchQueue.main.async {
                            if this.isCalibrateEnabled {
                                if let scene = this.scene{
                                    scene.updateLowerArmAngle( CGFloat(lowerArmAngle))
                                    
                                }
                            }
                        }
                    }
                }
                mbl_mw_sensor_fusion_enable_data(self.foreArm?.board, MBL_MW_SENSOR_FUSION_DATA_CORRECTED_ACC);
                mbl_mw_sensor_fusion_start(self.foreArm?.board);
                
            }
        }
    }

Step:- 4
Stop Live Streaming
  func stopDataStreaming(){
        if let _ =  self.foreArm{
            
            if let _ = self.correctedAccerlationForeArm{
                mbl_mw_datasignal_unsubscribe(self.correctedAccerlationForeArm)
            }
            mbl_mw_sensor_fusion_stop(self.foreArm?.board)
            
            self.foreArm?.cancelConnection()
        }
        
        if let _ = self.upperArm{
            if let _ = self.correctedAccerlationUpperArm{
                mbl_mw_datasignal_unsubscribe(self.correctedAccerlationUpperArm)
            }
            
            mbl_mw_sensor_fusion_stop(self.upperArm?.board)
            self.upperArm?.cancelConnection()
        }
    }