     public func readValue(
         for characteristic: DarwinCentral.Characteristic
     ) async throws -> Data {
-        self.log("Peripheral \(peripheral) will read characteristic \(characteristic.uuid)")
-        return try await withThrowingContinuation(for: peripheral) { [weak self] continuation in
+        self.log("Peripheral \(characteristic.peripheral) will read characteristic \(characteristic.uuid)")
+        return try await withThrowingContinuation(for: characteristic.peripheral) { [weak self] continuation in
             guard let self = self else { return }
             self.async {
-                
+                let operation = Operation.ReadCharacteristic(
+                    characteristic: characteristic,
+                    continuation: continuation
+                )
+                self.enqueue(.readCharacteristic(operation), for: characteristic.peripheral)
             }
         }
     }

            guard let self = self else { return }
            self.async {
                // get peripheral
                guard let peripheralObject = self.cache.peripherals[peripheral] else {
                    continuation.resume(throwing: CentralError.unknownPeripheral)
                    return
                }
                // yield value
                continuation.resume(returning: peripheralObject.canSendWriteWithoutResponse)
            }
        }
    }

        for characteristic: DarwinCentral.Characteristic,
        withResponse: Bool = true
    ) async throws {
        self.log("Peripheral \(characteristic.peripheral) will write characteristic \(characteristic.uuid)")
        if withResponse == false  {
            try await waitUntilCanSendWriteWithoutResponse(for: characteristic.peripheral)
        }
        try await write(data, withResponse: withResponse, for: characteristic)
    }
    
    public func notify(
