             let semaphore = Semaphore(timeout: timeout, operation: .writeCharacteristic(characteristic))
             accessQueue.sync { [unowned self] in self.internalState.writeCharacteristic.semaphore = semaphore }
             defer { accessQueue.sync { [unowned self] in self.internalState.writeCharacteristic.semaphore = nil } }
-            
             try semaphore.wait()
             
         } else {
-            
-            guard corePeripheral.state == .connected
-                else { throw CentralError.disconnected }
             
             // write command (if not blob)
             corePeripheral.writeValue(data, for: coreCharacteristic, type: .withoutResponse)
+            
+            // flush write messages
+            if corePeripheral.canSendWriteWithoutResponse == false {
+                let semaphore = Semaphore(timeout: timeout, operation: .flushWriteWithoutResponse(characteristic.peripheral))
+                accessQueue.sync { [unowned self] in self.internalState.flushWriteWithoutResponse.semaphore = semaphore }
+                defer { accessQueue.sync { [unowned self] in self.internalState.flushWriteWithoutResponse.semaphore = nil } }
+                try semaphore.wait()
+            }
         }
     }
     

        
        // TODO: Read Descriptor Value
    }
}

// MARK: - Supporting Types

        case discoverCharacteristics(Service<Peripheral>)
        case readCharacteristic(Characteristic<Peripheral>)
        case writeCharacteristic(Characteristic<Peripheral>)
        case flushWriteWithoutResponse(Peripheral)
        case updateCharacteristicNotificationState(Characteristic<Peripheral>)
    }
    
