title: How to write value to existing characteristics in BLE Device in Ios swift
body: <p>Im working on ios Ble app to charge mobile phone.Im done everything correct upto discover characteristics.First Scannig peripheral and connected to it. Discover the services(FFB0) and characteristics(FFB1,FFB2) which having notify and write with out response properties. And i found Client Characteristic Configuration Descriptor. I want send command to pcb to unlock for charging i want write value to FFB2 characteristics but peripheral doesn't responds . Here is my code. Im searching everything related to this but i did't find any solution If any body give solution to this problem it helpfull to me</p>
  
  <p>Thank You</p>
  
  <p><strong>// MARK: -  CBCentral,CBperipheral Delegates methods</strong></p>
  
  <pre><code>func centralManagerDidUpdateState(_ central: CBCentralManager) {
  
      switch central.state {
      case .unknown:
          print("central.state is .unknown")
  
      case .resetting:
          print("central.state is .resetting")
  
      case .unsupported:
          print("central.state is .unsupported")
  
      case .unauthorized:
          print("central.state is .unauthorized")
  
      case .poweredOff:
          print("central.state is .poweredOff")
  
      case .poweredOn:
          centralManager.scanForPeripherals(withServices: [batteryServiceCBUUID])
          print("central.state is .poweredOn")
  
      @unknown default:
          fatalError()
      }
      print("state: \(central.state)")
    }
  
  func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
  
      switch peripheral.state {
      case .unknown:
          print("peripheral.state  is .unknown")
  
      case .resetting:
          print("peripheral.state  is .resetting")
  
      case .unsupported:
          print("peripheral.state  is .unsupported")
  
      case .unauthorized:
          print("peripheral.state  is .unauthorized")
  
      case .poweredOff:
          print("peripheral.state  is .poweredOff")
  
      case .poweredOn:            
          let advertisementData = [CBAdvertisementDataLocalNameKey: "Test Device"]
          peripheralManager.startAdvertising(advertisementData)
          service.characteristics = [characteristicMut]
          peripheralManager.add(service)
  
          // peripheralManager.delegate = self
          print("peripheral.state  is .poweredOn")
  
      @unknown default:
          fatalError()
      }
  
      print("state: \(peripheral.state)")
  }
  
  func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
      if let error = error {
          print("Failed… error: \(error)")
          return
      }
      print("Succeeded!")
  
      //  peripheralManager.stopAdvertising()
  }
  
  func peripheralManager(peripheral: CBPeripheralManager, didAddService service: CBService, error: NSError?)
  {
      if let error = error {
          print("error: \(error)")
          return
      }
  
      print("service: \(service)")
  }
  
  func peripheralManager(_ peripheral: CBPeripheralManager, central: CBCentral, didSubscribeTo characteristic: CBCharacteristic) {
      print("Subscribed Central=======&gt;\(central)Characteristics \(characteristic)")
  }
  
  func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
  
      print(peripheral)
      batteryServicePeripheral = peripheral
      batteryServicePeripheral.delegate = self
      centralManager.stopScan()
      centralManager.connect(batteryServicePeripheral)
  
  }
  
  func peripheralManager(peripheral: CBPeripheralManager, didReceiveReadRequest request: CBATTRequest)
  {
      if request.characteristic.uuid == characteristicMut.uuid
      {
          // Set the correspondent characteristic's value
          // to the request
          request.value = characteristicMut.value
  
          // Respond to the request
          peripheralManager.respond(
              to: request,
              withResult: .success)
      }
  }
  
  func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
  
      print("Connected=======&gt;\(String(describing: peripheralManager))")
      batteryServicePeripheral.delegate = self
      batteryServicePeripheral.discoverServices([batteryServiceCBUUID])
  
  }
  
  func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
  
      print("Fail To Connect=======&gt;\(String(describing: error))")
  }
  
  
  func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
  
      if error == nil {
  
          print("Disconnected========&gt;\(peripheral)")
      }else {
  
          print("Disconnected========&gt;\(String(describing: error))")
      }
  }
  </code></pre>
  
  <p><strong>// MARK: -  CBPeripheral Delegate Methods</strong></p>
  
  <pre><code>func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
      guard let services = peripheral.services else { return }
      for service in services {
          print("SPAKA:PERIPHERALSERVICES============&gt;\(service)")
          peripheral.discoverCharacteristics(nil, for: service)
      }      
  }
  
  func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
  
      if let characteristics = service.characteristics {
          //else { return }
  
          for characteristic in characteristics {
  
              print(characteristic)
              if characteristic.uuid == batteryServiceCBUUID {
  
                  batteryServicePeripheral.setNotifyValue(true, for: characteristic)
                  batteryServicePeripheral.readValue(for: batteryCharacteristics)
              }
  
              if characteristic.uuid == batteryServiceRequestCBUUID2 {
  
                  batteryCharacteristics = characteristic
  
                  let str1 = "55e100"
                  let data = String(format: "%@%@",str1,hexTimeForChar)
                  guard let valueString = data.data(using: String.Encoding.utf8)  else {return}
  
                  peripheral.writeValue(valueString, for: characteristic , type: CBCharacteristicWriteType.withoutResponse)
                  print("Value String===&gt;\(valueString.debugDescription)")
                    batteryServicePeripheral.readValue(for: batteryCharacteristics)
                  peripheral.setNotifyValue(true, for: characteristic)
  
      peripheral.discoverDescriptors(for: batteryCharacteristics)
  }
  
  func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {        
      if error == nil {
          print("Message sent=======&gt;\(String(describing: characteristic.value))")
      }else{
  
          print("Message Not sent=======&gt;\(String(describing: error))")
      }
  }
  
  func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
  
      if error == nil {
          print("SPAKA : IS NOTIFYING UPDATED STATE ======&gt;\(characteristic.isNotifying)")
          print("SPAKA : UPDATED DESCRIPTION ======&gt;\(String(describing: characteristic.description))")
      }else{
          print("SPAKA : ERRORUPDATEDNOTIFICATION\(String(describing: error))")
      }
  }
  
  func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
  
      print("SPAKA: UPDATED VALUE RECEIVED========&gt;\(String(describing: characteristic.value))")
      print("characteristic UUID: \(characteristic.uuid), value: \(characteristic.value)")        
      guard let str = characteristic.value else { return  }        
      if let string = String(bytes: str, encoding: .utf8) {
          print("SPAKA==========&gt;:::\(string)")
      } else {
          print("not a valid UTF-8 sequence")
      }
  }
  
  func peripheral(_ peripheral: CBPeripheral, didDiscoverDescriptorsFor characteristic: CBCharacteristic, error: Error?) {
  
      guard let desc = batteryCharacteristics.descriptors else { return 
    }  
      for des in desc {
          print("BEGIN:SPAKA DESCRIPTOR========&gt;\(des)")
          discoveredDescriptor = des          
          peripheral.setNotifyValue(true, for: batteryCharacteristics)
      }
  
  }
  
  func peripheral(_ peripheral: CBPeripheral, didWriteValueFor descriptor: CBDescriptor, error: Error?) {
      if let error = error {
          print("Failed… error: \(error)")
          return
      }
  
      print("Descriptor Write Value uuid: \(descriptor.uuid), value: \(String(describing: descriptor.value))")
  }
  
  func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor descriptor: CBDescriptor, error: Error?) {
  
      if let error = error {
          print("Failed… error: \(error)")
          return
      }
  
      print("Descriptor Updated Value uuid: \(descriptor.uuid), value: \(String(describing: descriptor.value))")
  
      batteryServicePeripheral.readValue(for: batteryCharacteristics)
  
  }
  
  func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveWrite requests: [CBATTRequest]) {
      for request in requests {
          print(request)
          if let value = request.value {
              if let messageText = String(data: value, encoding: String.Encoding.utf8) {
                  print(messageText)
              }
          }
      }
  }
  
  func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveRead request: CBATTRequest){
  
      print("Received Request==========&gt;\(request)")
  }
  </code></pre>