             didWriteValueFor characteristicObject: CBCharacteristic,
             error: Swift.Error?
         ) {
-            if let error = error {
-                self.central.log("Error writing characteristic (\(error))")
-            } else {
-                self.central.log("Peripheral \(peripheralObject.gattIdentifier.uuidString) did write value for characteristic \(characteristicObject.uuid.uuidString)")
-            }
+            log(peripheralObject.gattIdentifier.uuidString, characteristicObject.uuid.uuidString, error?.localizedDescription)
+            
             let characteristic = Characteristic(
                 characteristic: characteristicObject,
                 peripheral: peripheralObject

            }
        }
        
        func peripheralIsReady(toSendWriteWithoutResponse corePeripheral: CBPeripheral) {
            self.central.log("Peripheral \(corePeripheral.gattIdentifier.uuidString) is ready to send write without response")
            let peripheral = Peripheral(corePeripheral)
            if let continuation = self.central.continuation.isReadyToWriteWithoutResponse[peripheral] {
                continuation.resume()
                self.central.continuation.isReadyToWriteWithoutResponse[peripheral] = nil

        }
    }
    
    public func rssi(for peripheral: Peripheral) async throws -> RSSI {
        return try await withCheckedThrowingContinuation { [weak self] continuation in
            guard let self = self else { return }
            self.queue.async {
                // get peripheral
                guard let peripheralObject = self.cache.peripherals[peripheral] else {
                    continuation.resume(throwing: CentralError.unknownPeripheral)
                    return
                }
                // check power on
                let state = self.centralManager._state
                guard state == .poweredOn else {
                    continuation.resume(throwing: DarwinCentralError.invalidState(state))
                    return
                }
                // check connected
                guard peripheralObject.state == .connected else {
                    continuation.resume(throwing: CentralError.disconnected)
                    return
                }
                // cancel old task
                if let oldTask = self.continuation.readRSSI[peripheral] {
                    oldTask.resume(throwing: CancellationError())
                    self.continuation.readRSSI[peripheral] = nil
                }
                // read value
                self.continuation.readRSSI[peripheral] = continuation
                peripheralObject.readRSSI()
            }
        }
    }
    
    // MARK - Private Methods
    
    private func log(_ message: String) {
        continuation.log.yield(message)
    }
