ffi-serial 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 171e00de20624479f57c484dde3675d6020564af
-  data.tar.gz: 72cd514955beeb975a37afe754d45e2684b2459d
+  metadata.gz: 7f14f5fa7b1ce50d9e803e54e5b58973e346f451
+  data.tar.gz: 626100a1daf9c5116556e7178300e08c0ac99ace
 SHA512:
-  metadata.gz: 5ffa5a7365668b12655c78042db290c60f617ed9e9c128c1b384b3bcbc9eabb643c98c111d8a6fe421c3f603704b4144212825a727f1a8021b088e98eb62d36e
-  data.tar.gz: 648ae77871fb16e3317e8f3815eedd95a6823ca1b5bf51cb06b3251ff0c5a24a629d4e4f44bed79e3b72d7a497c3c2393bd7a8ecbb918a3c3405916d031b5655
+  metadata.gz: a7f948d7807357304a2d237896287c2a61b488aa01a12a9a5c7682c87dad4738180f4cefd9bc77c32bbd0c8eba896b11b691ef57fdf0848e2691820cf72c22ed
+  data.tar.gz: ff9f571d42ec5859a97754ee12a8af9d014715169f8eeb38b4b00fefdd7066daa55967ada9d546d3742c1bd22385266c8051f3ade1add937c5f90e0a4a3bb25e

data/lib/ffi-serial.rb

@@ -22,6 +22,14 @@ module Serial
   # :attr_reader: parity
   # Determine the current serial port parity by querying the underlying operating system
 
+  ##
+  # :attr_accessor: read_timeout
+  # Get/Set the read_timeout
+  #
+  # - 0< nonblocking IO
+  # - 0 - blocking IO
+  # - >0 - Timeout in seconds (Float)
+
   ##
   # Create a new Ruby IO configured with the serial port parameters
   #

data/lib/ffi-serial/posix.rb

@@ -49,6 +49,10 @@ module Serial #:nodoc:
         termios[:c_iflag] = (termios[:c_iflag] | LIBC::CONSTANTS['IXON'] | LIBC::CONSTANTS['IXOFF'] | LIBC::CONSTANTS['IXANY'])
         termios[:c_cflag] = (termios[:c_cflag] | LIBC::CONSTANTS['CLOCAL'] | LIBC::CONSTANTS['CREAD'] | LIBC::CONSTANTS['HUPCL'])
 
+        # Blocking read
+        termios[:cc_c][LIBC::CONSTANTS['VMIN']] = 1
+        termios[:cc_c][LIBC::CONSTANTS['VTIME']] = 0
+
         LIBC.tcsetattr(io,  termios)
         io.extend(self)
       rescue Exception
@@ -58,16 +62,32 @@ module Serial #:nodoc:
       io
     end
 
-    # It seems like VMIN and VTIME is broken :(
-    # So this seems to be the only way to implement read the way it should be
-    def read(length = nil, buffer = nil) #:nodoc:
-      IO.select([self]) # Block
-      super(length, buffer)
+    def read_timeout #:nodoc:
+      termios = LIBC.tcgetattr(self)
+      return 0 unless (0 == termios[:cc_c][LIBC::CONSTANTS['VMIN']])
+      vtime = termios[:cc_c][LIBC::CONSTANTS['VTIME']]
+      return -1 if (0 == vtime)
+      (vtime.to_f / 10.0)
     end
 
-    def readpartial(length, buffer = nil) #:nodoc:
-      IO.select([self]) # Block
-      super(length, buffer)
+    def read_timeout=(val) #:nodoc:
+      val = Float(val)
+      termios = LIBC.tcgetattr(self)
+      if (0 > val)
+        termios[:cc_c][LIBC::CONSTANTS['VMIN']] = 0
+        termios[:cc_c][LIBC::CONSTANTS['VTIME']] = 0
+        val = -1
+      elsif (0 == val)
+        termios[:cc_c][LIBC::CONSTANTS['VMIN']] = 1
+        termios[:cc_c][LIBC::CONSTANTS['VTIME']] = 0
+        val = 0
+      else
+        val = (val * 10.0).to_i
+        termios[:cc_c][LIBC::CONSTANTS['VMIN']] = 0
+        termios[:cc_c][LIBC::CONSTANTS['VTIME']] = val
+        val = (val.to_f / 10.0)
+      end
+      LIBC.tcsetattr(self, termios); val
     end
 
     def baud #:nodoc:

data/lib/ffi-serial/windows.rb

@@ -18,10 +18,8 @@ module Serial #:nodoc:
 
       io = File.open(com_port, IO::RDWR|IO::BINARY)
       begin
-        io.instance_variable_set(:@__serial__port__, com_port[4..-1].to_s.freeze)
-
-        io.extend(self)
         io.sync = true
+        io.instance_variable_set(:@__serial__port__, com_port[4..-1].to_s.freeze)
 
         # Sane defaults
         dcb[:Flags] = dcb[:Flags] | (Kernel32::CONSTANTS['FLAGS'].fetch('fDtrControl').fetch(:enable))
@@ -30,7 +28,17 @@ module Serial #:nodoc:
 
         Kernel32.SetCommState(io, dcb)
         Kernel32.ClearCommError(io)
-        Kernel32.set_io_block(io)
+
+        # Blocking io
+        commtimeouts = Kernel32::COMMTIMEOUTS.new
+        commtimeouts[:ReadIntervalTimeout] = Kernel32::CONSTANTS['MAXDWORD']
+        commtimeouts[:ReadTotalTimeoutMultiplier] = Kernel32::CONSTANTS['MAXDWORD']
+        commtimeouts[:ReadTotalTimeoutConstant] = Kernel32::CONSTANTS['MAXDWORD'] - 1
+        commtimeouts[:WriteTotalTimeoutMultiplier] = 0
+        commtimeouts[:WriteTotalTimeoutConstant] = Kernel32::CONSTANTS['MAXDWORD'] - 1
+        Kernel32.SetCommTimeouts(io, commtimeouts)
+
+        io.extend(self)
       rescue Exception
         begin; io.close; rescue Exception; end
         raise
@@ -38,6 +46,36 @@ module Serial #:nodoc:
       io
     end
 
+    def read_timeout
+      commtimeouts = Kernel32.GetCommTimeouts(self)
+      return -1 if (0 == commtimeouts[:ReadTotalTimeoutConstant])
+      return 0 if (Kernel32::CONSTANTS['MAXDWORD'] == commtimeouts[:ReadIntervalTimeout])
+      Float(commtimeouts[:ReadTotalTimeoutConstant])/1000.0
+    end
+
+    def read_timeout=(val)
+      val = Float(val)
+      commtimeouts = Kernel32.GetCommTimeouts(self)
+      if (0 > val)
+        commtimeouts[:ReadIntervalTimeout] = Kernel32::CONSTANTS['MAXDWORD']
+        commtimeouts[:ReadTotalTimeoutMultiplier] = 0
+        commtimeouts[:ReadTotalTimeoutConstant] = 0
+        val = -1
+      elsif (0 == val)
+        commtimeouts[:ReadIntervalTimeout] = Kernel32::CONSTANTS['MAXDWORD']
+        commtimeouts[:ReadTotalTimeoutMultiplier] = Kernel32::CONSTANTS['MAXDWORD']
+        commtimeouts[:ReadTotalTimeoutConstant] = Kernel32::CONSTANTS['MAXDWORD'] - 1
+        val = 0
+      else
+        val = (val * 1000.0).to_i
+        commtimeouts[:ReadIntervalTimeout] = val
+        commtimeouts[:ReadTotalTimeoutMultiplier] = 0
+        commtimeouts[:ReadTotalTimeoutConstant] = val
+        val = (val / 1000.0)
+      end
+      Kernel32.SetCommTimeouts(self, commtimeouts); val
+    end
+
     def baud #:nodoc:
       Kernel32.GetCommState(self).baud
     end
@@ -55,13 +93,7 @@ module Serial #:nodoc:
     end
 
     def read_nonblock(maxlen, outbuf = nil, options = nil) #:nodoc:
-      Kernel32.set_io_nonblock(self)
-      result = begin
-        outbuf.nil? ? read(maxlen) : read(maxlen, outbuf)
-      ensure
-        Kernel32.set_io_block(self)
-      end
-
+      result = Kernel32.nonblock_io(self) { outbuf.nil? ? self.read(maxlen) : self.read(maxlen, outbuf) }
       if result.nil? || (0 == result.length)
         if ((!options.nil?) && (false == options[:exception]))
           return :wait_readable
@@ -77,28 +109,19 @@ module Serial #:nodoc:
         return ch
       end
       self.ungetc(ch)
-      Kernel32.set_io_nonblock(self)
-      outbuf.nil? ? read(maxlen) : read(maxlen, outbuf)
-    ensure
-      Kernel32.set_io_block(self)
+      Kernel32.nonblock_io(self) { outbuf.nil? ? self.read(maxlen) : self.read(maxlen, outbuf) }
     end
 
     def readbyte #:nodoc:
-      Kernel32.set_io_nonblock(self); super
-    ensure
-      Kernel32.set_io_block(self)
+      Kernel32.nonblock_io(self) { super }
     end
 
     def getc #:nodoc:
-      Kernel32.set_io_nonblock(self); super
-    ensure
-      Kernel32.set_io_block(self)
+      Kernel32.nonblock_io(self) { super }
     end
 
     def readchar #:nodoc:
-      Kernel32.set_io_nonblock(self); super
-    ensure
-      Kernel32.set_io_block(self)
+      Kernel32.nonblock_io(self) { super }
     end
 
     def to_s #:nodoc:
@@ -134,7 +157,7 @@ module Serial #:nodoc:
 
       def self.GetCommTimeouts(ruby_io) #:nodoc:
         commtimeouts = COMMTIMEOUTS.new
-        return commtimeouts unless (0 == c_GetCommTimeouts(LIBC._get_osfhandle(fd), commtimeouts))
+        return commtimeouts unless (0 == c_GetCommTimeouts(LIBC._get_osfhandle(ruby_io), commtimeouts))
         raise ERRNO[FFI.errno].new
       end
 
@@ -148,19 +171,9 @@ module Serial #:nodoc:
         raise ERRNO[FFI.errno].new
       end
 
-      def self.set_io_block(ruby_io) #:nodoc:
-        self.SetCommTimeouts(ruby_io, (@@read_block_io ||= begin
-          timeouts = COMMTIMEOUTS.new
-          timeouts[:ReadIntervalTimeout] = CONSTANTS['MAXDWORD']
-          timeouts[:ReadTotalTimeoutMultiplier] = CONSTANTS['MAXDWORD']
-          timeouts[:ReadTotalTimeoutConstant] = CONSTANTS['MAXDWORD'] - 1
-          timeouts[:WriteTotalTimeoutMultiplier] = 0
-          timeouts[:WriteTotalTimeoutConstant] = CONSTANTS['MAXDWORD'] - 1
-          timeouts
-        end))
-      end
-
-      def self.set_io_nonblock(ruby_io) #:nodoc:
+      def self.nonblock_io(ruby_io, &blk)
+        return nil if blk.nil?
+        commtimeouts = self.GetCommTimeouts(ruby_io)
         self.SetCommTimeouts(ruby_io, (@@read_nonblock_io ||= begin
           timeouts = COMMTIMEOUTS.new
           timeouts[:ReadIntervalTimeout] = CONSTANTS['MAXDWORD']
@@ -170,6 +183,11 @@ module Serial #:nodoc:
           timeouts[:WriteTotalTimeoutConstant] = 1
           timeouts
         end))
+        begin
+          blk.yield
+        ensure
+          self.SetCommTimeouts(ruby_io, commtimeouts)
+        end
       end
 
       class DCB < FFI::Struct #:nodoc:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-serial
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Johan van der Vyver
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-03 00:00:00.000000000 Z
+date: 2016-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi