Update README.md

Examples/SwiftSerialExample/Sources/main.swift

@@ -25,6 +25,7 @@ do {
     print("Serial port \(portName) opened successfully.")
     defer {
         serialPort.closePort()
+        print("Port Closed")
     }
 
     serialPort.setSettings(receiveRate: .baud9600,
@@ -74,8 +75,8 @@ do {
         }
     }
     
+    print("End of example");
 
-    print("We successfully received back \(numberOfMultiNewLineTest) lines")
 
 } catch PortError.failedToOpen {
     print("Serial port \(portName) failed to open. You might need root permissions.")

README.md

@@ -66,9 +66,13 @@ To get started quickly, you can take a look at my example project [here](Example
 git clone https://github.com/yeokm1/SwiftSerial.git
 cd SwiftSerial/Examples/SwiftSerialExample/
 swift build
-#You need root to access the serial port. Replace /dev/ttyUSB0 with the name of your serial port under test
+
+#For Linux: You need root to access the serial port. Replace /dev/ttyUSB0 with the name of your serial port under test
 sudo ./.build/debug/SwiftSerialExample /dev/ttyUSB0
 
+#For Mac: Root is not required
+./.build/debug/SwiftSerialExample /dev/tty.usbserial
+
 #If all goes well you should see a series of messages informing you that data transmitted has been received properly.
 ```
 
@@ -162,6 +166,11 @@ func readUntilChar(_ terminator: CChar) throws -> String
 ```
 Keep reading until the specified CChar is encountered. Return the string read so far without that value.
 
+```swift
+func readChar() throws -> UnicodeScalar
+```
+Read only one character. This works best if `minimumBytesToRead` has been set to `1` when opening the port. This function internally calls `readBytes()`.
+
 ### Writing data to the port
 
 There are several functions you can use to write data. All functions here are blocking till all the data has been written. All functions can throw `PortError.mustBeOpen`.
@@ -181,6 +190,11 @@ func writeBytes(from buffer: UnsafeMutablePointer<UInt8>, size: Int) throws -> I
 ```
 Function for those that want to mess with unsafe pointers. You have to specify how many bytes have to be written. Will return how many bytes actually written.
 
+```swift
+func writeChar(_ character: UnicodeScalar) throws -> Int{
+```
+Writes only one character. Will return `1` if successful. This function internally calls `writeString()`. Pull requests for a better way of doing this is appreciated.
+
 ### Closing the port
 
 Just do `serialPort.closePort()` to close the port once you are done using it.

Sources/SwiftSerial.swift

@@ -191,7 +191,7 @@ public enum ParityType {
     case even
     case odd
 
-	var parityValue: tcflag_t {
+    var parityValue: tcflag_t {
         switch self {
         case .none:
             return 0
@@ -389,7 +389,7 @@ extension SerialPort {
             data = Data(bytes: buffer, count: bytesRead)
         } else {
             //This is to avoid the case where bytesRead can be negative causing problems allocating the Data buffer
-       	    data = Data(bytes: buffer, count: 0)
+            data = Data(bytes: buffer, count: 0)
         }
 
         return data
@@ -421,17 +421,17 @@ extension SerialPort {
         }
 
         while true {
-        	let bytesRead = try readBytes(into: buffer, size: 1)
+            let bytesRead = try readBytes(into: buffer, size: 1)
 
-        	if bytesRead > 0 {
+            if bytesRead > 0 {
-        		let character = CChar(buffer[0])
+                let character = CChar(buffer[0])
                 
                 if character == terminator {
                     break
                 } else {
                     data.append(buffer, count: 1)
                 }
-        	}
+            }
         }
 
         if let string = String(data: data, encoding: String.Encoding.utf8) {
@@ -445,6 +445,25 @@ extension SerialPort {
         let newlineChar = CChar(10) // Newline/Line feed character `\n` is 10
         return try readUntilChar(newlineChar)
     }
+
+    public func readChar() throws -> UnicodeScalar {
+        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: 1)
+        
+        defer {
+            buffer.deallocate(capacity: 1)
+        }
+
+        while true {
+            let bytesRead = try readBytes(into: buffer, size: 1)
+
+            if bytesRead > 0 {
+                let character = UnicodeScalar(buffer[0])
+                return character     
+            }
+        }         
+
+    }
+
 }
 
 // MARK: Transmitting
@@ -480,4 +499,10 @@ extension SerialPort {
 
         return try writeData(data)
     }
+
+    public func writeChar(_ character: UnicodeScalar) throws -> Int{
+        let stringEquiv = String(character)
+        let bytesWritten = try writeString(stringEquiv)
+        return bytesWritten
+    }
 }