title: How to disconnect already connected ble device
body: <p>So my problem is when I segue to different storyboard my ble peripheral stay connected to phone:
  code that I use to scan and connect ble peripheral:</p>
  
  <pre><code>import Foundation
  import UIKit
  import CoreBluetooth
  
  
  var txCharacteristic : CBCharacteristic?
  var rxCharacteristic : CBCharacteristic?
  var blePeripheral : CBPeripheral?
  var characteristicASCIIValue = NSString()
  
  
  
  class BLECentralViewController : UIViewController, CBCentralManagerDelegate, CBPeripheralDelegate, UITableViewDelegate, UITableViewDataSource{
  
      //Data
      var centralManager : CBCentralManager!
      var RSSIs = [NSNumber]()
      var data = NSMutableData()
      var writeData: String = ""
      var peripherals: [CBPeripheral] = []
      var characteristicValue = [CBUUID: NSData]()
      var timer = Timer()
      var characteristics = [String : CBCharacteristic]()
  
      //UI
      @IBOutlet weak var baseTableView: UITableView!
      @IBOutlet weak var refreshButton: UIBarButtonItem!
  
      @IBAction func refreshAction(_ sender: AnyObject) {
          disconnectFromDevice()
          self.peripherals = []
          self.RSSIs = []
          self.baseTableView.reloadData()
          startScan()
      }
  
      override func viewDidLoad() {
          super.viewDidLoad()
          self.baseTableView.delegate = self
          self.baseTableView.dataSource = self
          self.baseTableView.reloadData()
  
          /*Our key player in this app will be our CBCentralManager. CBCentralManager objects are used to manage discovered or connected remote peripheral devices (represented by CBPeripheral objects), including scanning for, discovering, and connecting to advertising peripherals.
           */
          centralManager = CBCentralManager(delegate: self, queue: nil)
          let backButton = UIBarButtonItem(title: "Disconnect", style: .plain, target: nil, action: nil)
          navigationItem.backBarButtonItem = backButton
      }
  
      override func viewDidAppear(_ animated: Bool) {
          disconnectFromDevice()
          super.viewDidAppear(animated)
          refreshScanView()
          print("View Cleared")
      }
  
      override func viewWillDisappear(_ animated: Bool) {
          super.viewWillDisappear(animated)
          print("Stop Scanning")
          centralManager?.stopScan()
      }
  
      /*Okay, now that we have our CBCentalManager up and running, it's time to start searching for devices. You can do this by calling the "scanForPeripherals" method.*/
  
      func startScan() {
          peripherals = []
          print("Now Scanning...")
          self.timer.invalidate()
          centralManager?.scanForPeripherals(withServices: nil , options: [CBCentralManagerScanOptionAllowDuplicatesKey:false])
          Timer.scheduledTimer(timeInterval: 3, target: self, selector: #selector(self.cancelScan), userInfo: nil, repeats: false)
      }
  
      /*We also need to stop scanning at some point so we'll also create a function that calls "stopScan"*/
      @objc func cancelScan() {
          self.centralManager?.stopScan()
          print("Scan Stopped")
          print("Number of Peripherals Found: \(peripherals.count)")
      }
  
      func refreshScanView() {
          baseTableView.reloadData()
      }
  
      //-Terminate all Peripheral Connection
      /*
       Call this when things either go wrong, or you're done with the connection.
       This cancels any subscriptions if there are any, or straight disconnects if not.
       (didUpdateNotificationStateForCharacteristic will cancel the connection if a subscription is involved)
       */
      func disconnectFromDevice () {
          if blePeripheral != nil {
              // We have a connection to the device but we are not subscribed to the Transfer Characteristic for some reason.
              // Therefore, we will just disconnect from the peripheral
              centralManager?.cancelPeripheralConnection(blePeripheral!)
          }
      }
  
  
      func restoreCentralManager() {
          //Restores Central Manager delegate if something went wrong
          centralManager?.delegate = self
      }
  
      /*
       Called when the central manager discovers a peripheral while scanning. Also, once peripheral is connected, cancel scanning.
       */
      func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral,advertisementData: [String : Any], rssi RSSI: NSNumber) {
  
          blePeripheral = peripheral
          self.peripherals.append(peripheral)
          self.RSSIs.append(RSSI)
          peripheral.delegate = self
          self.baseTableView.reloadData()
          if blePeripheral == nil {
              print("Found new pheripheral devices with services")
              print("Peripheral name: \(String(describing: peripheral.name))")
              print("**********************************")
              print ("Advertisement Data : \(advertisementData)")
          }
      }
  
      //Peripheral Connections: Connecting, Connected, Disconnected
  
      //-Connection
      func connectToDevice () {
          centralManager?.connect(blePeripheral!, options: nil)
          print("Good luck")
          print(blePeripheral!.discoverServices(nil))
          print("Good luck")
  
  
      }
  
      /*
       Invoked when a connection is successfully created with a peripheral.
       This method is invoked when a call to connect(_:options:) is successful. You typically implement this method to set the peripheral’s delegate and to discover its services.
       */
      //-Connected
      func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
          print("*****************************")
          print("Connection complete")
          print("Peripheral info: \(String(describing: blePeripheral))")
  
          //Stop Scan- We don't need to scan once we've connected to a peripheral. We got what we came for.
          centralManager?.stopScan()
          print("Scan Stopped")
  
          //Erase data that we might have
          data.length = 0
  
          //Discovery callback
          peripheral.delegate = self
          //Only look for services that matches transmit uuid
          peripheral.discoverServices([BLEService_UUID])
  
  
          //Once connected, move to new view controller to manager incoming and outgoing data
          let storyboard = UIStoryboard(name: "Main1", bundle: nil)
  
          let uartViewController = storyboard.instantiateViewController(withIdentifier: "UartModuleViewController") as! UartModuleViewController
  
          uartViewController.peripheral = peripheral
  
          navigationController?.pushViewController(uartViewController, animated: true)
      }
  
      /*
       Invoked when the central manager fails to create a connection with a peripheral.
       */
  
      func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
          if error != nil {
              print("Failed to connect to peripheral")
              return
          }
      }
  
      func disconnectAllConnection() {
          centralManager.cancelPeripheralConnection(blePeripheral!)
      }
  
      /*
       Invoked when you discover the peripheral’s available services.
       This method is invoked when your app calls the discoverServices(_:) method. If the services of the peripheral are successfully discovered, you can access them through the peripheral’s services property. If successful, the error parameter is nil. If unsuccessful, the error parameter returns the cause of the failure.
       */
      func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
          print("*******************************************************AAA")
  
          if ((error) != nil) {
              print("Error discovering services: \(error!.localizedDescription)")
              return
          }
  
          guard let services = peripheral.services else {
              return
          }
          //We need to discover the all characteristic
          for service in services {
  
              peripheral.discoverCharacteristics(nil, for: service)
              print("god bless")
              print(peripheral.discoverCharacteristics(nil, for: service))
              print("god bless")
              // bleService = service
          }
          print("Discovered Services: \(services)")
      }
  
      /*
       Invoked when you discover the characteristics of a specified service.
       This method is invoked when your app calls the discoverCharacteristics(_:for:) method. If the characteristics of the specified service are successfully discovered, you can access them through the service's characteristics property. If successful, the error parameter is nil. If unsuccessful, the error parameter returns the cause of the failure.
       */
  
      func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
  
          print("*******************************************************")
  
          if ((error) != nil) {
              print("Error discovering services: \(error!.localizedDescription)")
              return
          }
  
          guard let characteristics = service.characteristics else {
              return
          }
  
          print("Found \(characteristics.count) characteristics!")
  
          for characteristic in characteristics {
              //looks for the right characteristic
  
              if characteristic.uuid.isEqual(BLE_Characteristic_uuid_Rx)  {
                  rxCharacteristic = characteristic
  
                  //Once found, subscribe to the this particular characteristic...
                  peripheral.setNotifyValue(true, for: rxCharacteristic!)
                  // We can return after calling CBPeripheral.setNotifyValue because CBPeripheralDelegate's
                  // didUpdateNotificationStateForCharacteristic method will be called automatically
                  peripheral.readValue(for: characteristic)
                  print("Rx Characteristic: \(characteristic.uuid)")
              }
              if characteristic.uuid.isEqual(BLE_Characteristic_uuid_Tx){
                  txCharacteristic = characteristic
                  print("Tx Characteristic: \(characteristic.uuid)")
              }
              peripheral.discoverDescriptors(for: characteristic)
          }
      }
  
      // Getting Values From Characteristic
  
      /*After you've found a characteristic of a service that you are interested in, you can read the characteristic's value by calling the peripheral "readValueForCharacteristic" method within the "didDiscoverCharacteristicsFor service" delegate.
       */
      func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
  
          if characteristic == rxCharacteristic {
              if let ASCIIstring = NSString(data: characteristic.value!, encoding: String.Encoding.utf8.rawValue) {
                  characteristicASCIIValue = ASCIIstring
                  print("Value Recieved: \((characteristicASCIIValue as String))")
                  NotificationCenter.default.post(name:NSNotification.Name(rawValue: "Notify"), object: nil)
  
              }
          }
      }
  
  
      func peripheral(_ peripheral: CBPeripheral, didDiscoverDescriptorsFor characteristic: CBCharacteristic, error: Error?) {
          print("*******************************************************")
  
          if error != nil {
              print("\(error.debugDescription)")
              return
          }
          if ((characteristic.descriptors) != nil) {
  
              for x in characteristic.descriptors!{
                  let descript = x as CBDescriptor?
                  print("function name: DidDiscoverDescriptorForChar \(String(describing: descript?.description))")
                  print("Rx Value \(String(describing: rxCharacteristic?.value))")
                  print("Tx Value \(String(describing: txCharacteristic?.value))")
              }
          }
      }
  
  
      func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
          print("*******************************************************")
  
          if (error != nil) {
              print("Error changing notification state:\(String(describing: error?.localizedDescription))")
  
          } else {
              print("Characteristic's value subscribed")
          }
  
          if (characteristic.isNotifying) {
              print ("Subscribed. Notification has begun for: \(characteristic.uuid)")
          }
      }
  
  
  
      func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
          print("Disconnected")
      }
  
  
      func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
          guard error == nil else {
              print("Error discovering services: error")
              return
          }
          print("Message sent")
      }
  
      func peripheral(_ peripheral: CBPeripheral, didWriteValueFor descriptor: CBDescriptor, error: Error?) {
          guard error == nil else {
              print("Error discovering services: error")
              return
          }
          print("Succeeded!")
      }
  
      //Table View Functions
      func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -&gt; Int {
          return self.peripherals.count
      }
  
      func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -&gt; UITableViewCell {
          //Connect to device where the peripheral is connected
          let cell = tableView.dequeueReusableCell(withIdentifier: "BlueCell") as! PeripheralTableViewCell
          let peripheral = self.peripherals[indexPath.row]
          let RSSI = self.RSSIs[indexPath.row]
  
  
          if peripheral.name == nil {
              cell.peripheralLabel.text = "nil"
          } else {
              cell.peripheralLabel.text = peripheral.name
          }
          cell.rssiLabel.text = "RSSI: \(RSSI)"
  
          return cell
      }
  
      func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
          blePeripheral = peripherals[indexPath.row]
          connectToDevice()
      }
  
      /*
       Invoked when the central manager’s state is updated.
       This is where we kick off the scan if Bluetooth is turned on.
       */
      func centralManagerDidUpdateState(_ central: CBCentralManager) {
          if central.state == CBManagerState.poweredOn {
              // We will just handle it the easy way here: if Bluetooth is on, proceed...start scan!
              print("Bluetooth Enabled")
              startScan()
  
          } else {
              //If Bluetooth is off, display a UI alert message saying "Bluetooth is not enable" and "Make sure that your bluetooth is turned on"
              print("Bluetooth Disabled- Make sure your Bluetooth is turned on")
  
              let alertVC = UIAlertController(title: "Bluetooth is not enabled", message: "Make sure that your bluetooth is turned on", preferredStyle: UIAlertControllerStyle.alert)
              let action = UIAlertAction(title: "ok", style: UIAlertActionStyle.default, handler: { (action: UIAlertAction) -&gt; Void in
                  self.dismiss(animated: true, completion: nil)
              })
              alertVC.addAction(action)
              self.present(alertVC, animated: true, completion: nil)
          }
      }
  }
  </code></pre>
  
  <p>and code when i sending data from another viewcontroller</p>
  
  <pre><code>import UIKit
  import CoreBluetooth
  
  class UartModuleViewController: UIViewController, CBPeripheralManagerDelegate, UITextViewDelegate, UITextFieldDelegate {
  
      //UI
      @IBOutlet weak var baseTextView: UITextView!
      @IBOutlet weak var sendButton: UIButton!
      @IBOutlet weak var inputTextField: UITextField!
      @IBOutlet weak var scrollView: UIScrollView!
      @IBOutlet weak var switchUI: UISwitch!
      //Data
      var centralManager : CBCentralManager!
      var peripheralManager: CBPeripheralManager?
      var peripheral: CBPeripheral!
      private var consoleAsciiText:NSAttributedString? = NSAttributedString(string: "")
  
  
      @IBAction func Discon(_ sender: Any) {
          disconnectFromDevice()
          print("Hello")
  
      }
  
      func disconnectFromDevice () {
              // We have a connection to the device but we are not subscribed to the Transfer Characteristic for some reason.
              // Therefore, we will just disconnect from the peripheral
              centralManager?.cancelPeripheralConnection(blePeripheral!)
      }
  
      override func viewDidLoad() {
          super.viewDidLoad()
  
          self.navigationItem.backBarButtonItem = UIBarButtonItem(title:"Back", style:.plain, target:nil, action:nil)
  
          //Create and start the peripheral manager
          peripheralManager = CBPeripheralManager(delegate: self, queue: nil)
          //-Notification for updating the text view with incoming text
  
      }
  
      override func viewDidAppear(_ animated: Bool) {
  
  
      }
  
      override func viewDidDisappear(_ animated: Bool) {
          // peripheralManager?.stopAdvertising()
          // self.peripheralManager = nil
          super.viewDidDisappear(animated)
          NotificationCenter.default.removeObserver(self)
  
      }
  
  
      @IBAction func clickSendAction(_ sender: AnyObject) {
          outgoingData()
  
      }
      @IBAction func S(_ sender: Any) {
          sends()
      }
      @IBAction func sendd(_ sender: Any) {
          sendd()
      }
      @IBAction func senda(_ sender: Any) {
          senda()
      }
      @IBAction func sendt(_ sender: Any) {
          sendt()
      }
      @IBAction func sendb(_ sender: Any) {
          sendb()
      }
  
  
      func outgoingData () {
  
          let inputText = "W"
  
          writeValue(data: inputText)
  
  
      }
      func sends () {
  
          let inputText = "S"
  
          writeValue(data: inputText)
  
  
      }
  
      func sendd () {
  
          let inputText = "D"
  
          writeValue(data: inputText)
  
  
      }
      func senda () {
  
          let inputText = "A"
  
          writeValue(data: inputText)
  
  
      }
      func sendt () {
  
          let inputText = "T"
  
          writeValue(data: inputText)
  
  
      }
      func sendb () {
  
          let inputText = "B"
  
          writeValue(data: inputText)
  
  
      }
  
  
      // Write functions
      func writeValue(data: String){
          let valueString = (data as NSString).data(using: String.Encoding.utf8.rawValue)
          //change the "data" to valueString
          if let blePeripheral = blePeripheral{
              if let txCharacteristic = txCharacteristic {
                  blePeripheral.writeValue(valueString!, for: txCharacteristic, type: CBCharacteristicWriteType.withoutResponse)
              }
          }
      }
  
      func writeCharacteristic(val: Int8){
          var val = val
          let ns = NSData(bytes: &amp;val, length: MemoryLayout&lt;Int8&gt;.size)
          blePeripheral!.writeValue(ns as Data, for: txCharacteristic!, type: CBCharacteristicWriteType.withResponse)
      }
  
  
  
      //MARK: UITextViewDelegate methods
      func textViewShouldBeginEditing(_ textView: UITextView) -&gt; Bool {
          if textView === baseTextView {
              //tapping on consoleview dismisses keyboard
              inputTextField.resignFirstResponder()
              return false
          }
          return true
      }
  
      func textFieldDidBeginEditing(_ textField: UITextField) {
          scrollView.setContentOffset(CGPoint(x:0, y:250), animated: true)
      }
  
      func textFieldDidEndEditing(_ textField: UITextField) {
          scrollView.setContentOffset(CGPoint(x:0, y:0), animated: true)
      }
  
      func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
          if peripheral.state == .poweredOn {
              return
          }
          print("Peripheral manager is running")
      }
  
      //Check when someone subscribe to our characteristic, start sending the data
      func peripheralManager(_ peripheral: CBPeripheralManager, central: CBCentral, didSubscribeTo characteristic: CBCharacteristic) {
          print("Device subscribe to characteristic")
      }
  
  
      override func touchesBegan(_ touches: Set&lt;UITouch&gt;, with event: UIEvent?) {
          self.view.endEditing(true)
      }
  
      func textFieldShouldReturn(_ textField: UITextField) -&gt; Bool {
          textField.resignFirstResponder()
          outgoingData()
          return(true)
      }
  
      func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
          if let error = error {
              print("\(error)")
              return
          }
      }
  }
  </code></pre>
  
  <p>How i can terminate all connections when i segue from second view controller ?</p>
  
  <p>Thank you all so much</p>