ffi-serial 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44fd8d0003d2e47f4722d3db91858c0ef47895ae
+  data.tar.gz: ad008840aa913c6f549173132911f9e4675cba98
+SHA512:
+  metadata.gz: aa8df84c7b52849bc7e51dc3f1c30ea2c1566f8de0c9dbe2082ab931816daa8e949a1444a04dea90e7b8a7ae7d61f2eba97e8f261876ef3684188414eaf64104
+  data.tar.gz: 0ced23dda4e32e280b99473331bc8d55d7f871a5b72fe4cec3fa8b1790a95bcbe549718a7c7ed755a4e54f4046f5902c8c3f77918d1368a1aef962d3d290ce5f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Johan van der Vyver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+## FFI Serial
+FFI Serial is a simple OS independent gem to allow access to a serial port
+
+## Why?
+Other gems exist, why this gem?
+
+1. Uses FFI to negate the need for native compilation
+2. Simply acts as a configurator for Ruby IO objects
+
+## Why FFI?
+FFI is very widely supported at this point.
+By making use of FFI a lot of native compilation concerns go away.
+
+## Why IO?
+Serial ports are simply files, in both Posix and Windows, that have special API calls to configure the serial port settings.
+
+Ruby IO provides a rich API and it is part of standard library.
+Using IO, this gem benefits from everything Ruby IO provides.
+No modification is made to IO nor does this simply emulate IO.
+
+99% of the code in this gem is to call the native operating system functions to configure the IO object serial port settings
+
+## Installation
+    gem install ffi-serial
+
+## Usage
+    require 'ffi-serial'
+
+    # Defaults for baud, data_bits, stop_bits and parity
+    port = Serial.new port: '/dev/ttyUSB0' #=> <Serial:/dev/ttyUSB0>
+
+    # Get configured settings from OS
+    port.baud #=> 9600
+    port.data_bits #=> 8
+    port.stop_bits #=> 1
+    port.parity #=> :none
+
+    # Really is a Ruby IO
+    port.is_a?(IO) #=> true
+    port.is_a?(File) #=> true
+
+    port.read_nonblock(512) #=> ... <supported in Windows>
+    port.read #=> ...
+    port.readpartial(512) #=> ...
+    port.write "\n" #=> 1
+    # etc.
+
+    port.close #=> nil
+
+    # Explicit configuration (and works on Windows)
+    port = Serial.new port: 'COM1', data_bits: 8, stop_bits: 1, parity: :none #=> <Serial:COM1>
+
+See Ruby standard library IO for complete method list
+http://ruby-doc.org/core-1.9.3/IO.html

data/lib/ffi-serial/bsd.rb

@@ -0,0 +1,49 @@
+module Serial #:nodoc:
+  module Posix #:nodoc:
+    # Values generated using a FreeBSD 10 instance on EC2
+
+    module LIBC #:nodoc:
+      require 'ffi'
+
+      def self.os_specific_constants #:nodoc:
+        { 'BAUD' => {
+            0 => 0, 50 => 50, 75 => 75, 110 => 110, 134 => 134, 150 => 150, 200 => 200, 300 => 300,
+            600 => 600, 1200 => 1200, 1800 => 1800, 2400 => 2400, 4800 => 4800, 7200 => 7200,
+            9600 => 9600, 14400 => 14400, 19200 => 19200, 28800 => 28800, 38400 => 38400,
+            57600 => 57600, 76800 => 76800, 115200 => 115200, 230400 => 230400,
+            460800 => 460800, 921600 => 921600 }.freeze,
+
+          'DATA_BITS' => { 5 => 0, 6 => 256, 7 => 512, 8 => 768 }.freeze,
+
+          'STOP_BITS' => { 1 => 0, 2 => 1024 }.freeze,
+
+          'PARITY' => { :none => 0, :even => 4096, :odd => 12288 }.freeze,
+
+          'IXON' => 512, 'IXOFF' => 1024, 'IXANY' => 2048, 'IGNPAR' => 4, 'CREAD' => 2048, 'CLOCAL' => 32768,
+          'HUPCL' => 16384, 'VMIN' => 16, 'VTIME' => 17, 'TCSANOW' => 0, 'F_GETFL' => 3, 'F_SETFL' => 4, }
+      end
+
+      class Termios < FFI::Struct #:nodoc:
+        layout  :c_iflag, :ulong,
+                :c_oflag, :ulong,
+                :c_cflag, :ulong,
+                :c_lflag, :ulong,
+                :cc_c, [:uchar, 20],
+                :c_ispeed, :ulong,
+                :c_ospeed, :ulong
+
+        def baud #:nodoc:
+          CONSTANTS['BAUD_'].fetch(self[:c_ispeed])
+        end
+
+        def baud=(val) #:nodoc:
+          mask = CONSTANTS['BAUD'].fetch(val, nil)
+          if mask.nil?
+            raise ArgumentError.new "Invalid baud, supported values #{CONSTANTS['BAUD'].keys.inspect}"
+          end
+          self[:c_cflag] = self[:c_cflag] | mask; self[:c_ispeed] = mask; self[:c_ospeed] = mask; val
+        end
+      end
+    end
+  end
+end

data/lib/ffi-serial/darwin.rb

@@ -0,0 +1,48 @@
+module Serial #:nodoc:
+  module Posix #:nodoc:
+    # Values generated using a Macbook Pro running Yosemite
+
+    module LIBC #:nodoc:
+      require 'ffi'
+
+      def self.os_specific_constants #:nodoc:
+        { 'BAUD' => {
+            0 => 0, 50 => 50, 75 => 75, 110 => 110, 134 => 134, 150 => 150, 200 => 200, 300 => 300,
+            600 => 600, 1200 => 1200, 1800 => 1800, 2400 => 2400, 4800 => 4800, 7200 => 7200,
+            9600 => 9600, 14400 => 14400, 19200 => 19200, 28800 => 28800, 38400 => 38400,
+            57600 => 57600, 76800 => 76800, 115200 => 115200, 230400 => 230400 }.freeze,
+
+          'DATA_BITS' => { 5 => 0, 6 => 256, 7 => 512, 8 => 768 }.freeze,
+
+          'STOP_BITS' => { 1 => 0, 2 => 1024 }.freeze,
+
+          'PARITY' => { :none => 0, :even => 4096, :odd => 12288 }.freeze,
+
+          'IXON' => 512, 'IXOFF' => 1024, 'IXANY' => 2048, 'IGNPAR' => 4, 'CREAD' => 2048, 'CLOCAL' => 32768,
+          'HUPCL' => 16384, 'VMIN' => 16, 'VTIME' => 17, 'TCSANOW' => 0, 'F_GETFL' => 3, 'F_SETFL' => 4, }
+      end
+
+      class Termios < FFI::Struct #:nodoc:
+        layout  :c_iflag, :ulong,
+                :c_oflag, :ulong,
+                :c_cflag, :ulong,
+                :c_lflag, :ulong,
+                :cc_c, [:uchar, 20],
+                :c_ispeed, :ulong,
+                :c_ospeed, :ulong
+
+        def baud #:nodoc:
+          CONSTANTS['BAUD_'].fetch(self[:c_ispeed])
+        end
+
+        def baud=(val) #:nodoc:
+          mask = CONSTANTS['BAUD'].fetch(val, nil)
+          if mask.nil?
+            raise ArgumentError.new "Invalid baud, supported values #{CONSTANTS['BAUD'].keys.inspect}"
+          end
+          self[:c_cflag] = self[:c_cflag] | mask; self[:c_ispeed] = mask; self[:c_ospeed] = mask; val
+        end
+      end
+    end
+  end
+end

data/lib/ffi-serial/linux.rb

@@ -0,0 +1,51 @@
+module Serial #:nodoc:
+  module Posix #:nodoc:
+    # Values generated using a Raspberry Pi B+ running Raspbian Jesse Lite
+
+    module LIBC #:nodoc:
+      require 'ffi'
+
+      def self.os_specific_constants #:nodoc:
+        { 'BAUD' => {
+          0 => 0, 50 => 1, 75 => 2, 110 => 3, 134 => 4, 150 => 5, 200 => 6, 300 => 7, 600 => 8, 1200 => 9, 1800 => 10, 2400 => 11,
+          4800 => 12, 9600 => 13, 19200 => 14, 38400 => 15, 57600 => 4097, 115200 => 4098, 230400 => 4099, 460800 => 4100,
+          500000 => 4101, 576000 => 4102, 921600 => 4103, 1000000 => 4104, 1152000 => 4105, 1500000 => 4106, 2000000 => 4107,
+          2500000 => 4108, 3000000 => 4109, 3500000 => 4110, 4000000 => 4111 }.freeze,
+
+          'DATA_BITS' => { 5 => 0, 6 => 16, 7 => 32, 8 => 48 }.freeze,
+
+          'STOP_BITS' => { 1 => 0, 2 => 64 }.freeze,
+
+          'PARITY' => { :none => 0, :even => 256, :odd => 768, :space => 1073742080, :mark => 1073742592 }.freeze,
+
+          'IXON' => 1024, 'IXOFF' => 4096, 'IXANY' => 2048, 'IGNPAR' => 4, 'CREAD' => 128, 'CLOCAL' => 2048,
+          'HUPCL' => 1024, 'VMIN' => 6, 'VTIME' => 5, 'TCSANOW' => 0, 'F_GETFL' => 3, 'F_SETFL' => 4, }
+      end
+
+      class Termios < FFI::Struct #:nodoc:
+        # This struct has 2 version I've encountered, both with different sizes for cc_c
+        # The simple solution is to simply ignore anything after cc_c and add some padding bytes to avoid memory corruption
+        # Because of this hackyness, custom Baud rates are not supported
+        layout  :c_iflag, :uint,
+                :c_oflag, :uint,
+                :c_cflag, :uint,
+                :c_lflag, :uint,
+                :c_line, :uchar,
+                :cc_c, [:uchar, 19],
+                :ignored, [:uint8, 48] # ignored padding bytes
+
+        def baud #:nodoc:
+          CONSTANTS['BAUD_'].fetch(self[:c_cflag] & CONSTANTS['BAUD_BITMASK'])
+        end
+
+        def baud=(val) #:nodoc:
+          mask = CONSTANTS['BAUD'].fetch(val, nil)
+          if mask.nil?
+            raise ArgumentError.new "Invalid baud, supported values #{CONSTANTS['BAUD'].keys.inspect}"
+          end
+          self[:c_cflag] = self[:c_cflag] | mask; val
+        end
+      end
+    end
+  end
+end

data/lib/ffi-serial/posix.rb

@@ -0,0 +1,174 @@
+module Serial #:nodoc:
+
+  # Load the OS specific implementation
+  begin #:nodoc:
+    host_info = begin
+      RbConfig::CONFIG['host_os']
+    rescue Exception
+      require 'rbconfig'
+      RbConfig::CONFIG['host_os']
+    end
+
+    if (host_info =~ /darwin/)
+      require 'ffi-serial/darwin'
+    elsif (host_info =~ /linux/)
+      require 'ffi-serial/linux'
+    elsif (host_info =~ /bsd/)
+      require 'ffi-serial/bsd'
+    else
+      raise LoadError.new 'The current operating system is not (yet) supported'
+    end
+  end
+
+  ##
+  # Serial port implementation for Posix
+  module Posix #:nodoc:
+    ##
+    # Create a new serial port on a Posix based operating system
+    def self.new(dev, baud, data_bits, stop_bits, parity) #:nodoc:
+      # Parse configuration first
+      termios = LIBC::Termios.new
+
+      termios.baud = baud
+      termios.data_bits = data_bits
+      termios.stop_bits = stop_bits
+      termios.parity = parity
+
+      io = File.open(dev, IO::RDWR | IO::NOCTTY | IO::NONBLOCK)
+      begin
+        io.sync = true
+        io.fcntl(LIBC::CONSTANTS['F_SETFL'], (io.fcntl(LIBC::CONSTANTS['F_GETFL']) & (~IO::NONBLOCK)))
+        io.instance_variable_set(:@__serial__dev__, dev.freeze)
+
+        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
+        begin; io.close; rescue Exception; end
+        raise
+      end
+      io
+    end
+
+    def baud #:nodoc:
+      LIBC.tcgetattr(self).baud
+    end
+
+    def data_bits #:nodoc:
+      LIBC.tcgetattr(self).data_bits
+    end
+
+    def stop_bits #:nodoc:
+      LIBC.tcgetattr(self).stop_bits
+    end
+
+    def parity #:nodoc:
+      LIBC.tcgetattr(self).parity
+    end
+
+    def to_s #:nodoc:
+      ['#<Serial:', @__serial__dev__, '>'].join.to_s
+    end
+
+    def inspect #:nodoc:
+      self.to_s
+    end
+
+    private
+
+    ##
+    # FFI integration with C to provide access to OS specific serial port APIs
+    module LIBC #:nodoc:
+      require 'ffi'
+
+      extend FFI::Library #:nodoc:
+      ffi_lib FFI::Library::LIBC
+
+      def self.tcgetattr(ruby_io) #:nodoc:
+        termios = Termios.new
+        if (0 != c_tcgetattr(ruby_io.fileno, termios))
+          raise ERRNO[FFI.errno].new
+        end
+        termios
+      end
+
+      def self.tcsetattr(ruby_io, termios) #:nodoc:
+        if (0 != c_tcsetattr(ruby_io.fileno, CONSTANTS['TCSANOW'], termios))
+          raise ERRNO[FFI.errno].new
+        end
+      end
+
+      class Termios #:nodoc:
+        def data_bits=(val) #:nodoc:
+          mask = CONSTANTS['DATA_BITS'].fetch(val, nil)
+          if mask.nil?
+            raise ArgumentError.new "Invalid data bits, supported values #{CONSTANTS['DATA_BITS'].keys.inspect}"
+          end
+          self[:c_cflag] = self[:c_cflag] | mask; val
+        end
+
+        def data_bits #:nodoc:
+          CONSTANTS['DATA_BITS_'].fetch(self[:c_cflag] & CONSTANTS['DATA_BITS_BITMASK'])
+        end
+
+        def stop_bits=(val) #:nodoc:
+          mask = CONSTANTS['STOP_BITS'].fetch(val, nil)
+          if mask.nil?
+            raise ArgumentError.new "Invalid stop bits, supported values #{CONSTANTS['STOP_BITS'].keys.inspect}"
+          end
+          self[:c_cflag] = self[:c_cflag] | mask; val
+        end
+
+        def stop_bits #:nodoc:
+          CONSTANTS['STOP_BITS_'].fetch(self[:c_cflag] & CONSTANTS['STOP_BITS_BITMASK'])
+        end
+
+        def parity=(val) #:nodoc:
+          mask = CONSTANTS['PARITY'].fetch(val, nil)
+          if mask.nil?
+            raise ArgumentError.new "Invalid parity, supported values #{CONSTANTS['PARITY'].keys.inspect}"
+          end
+          if (:none == val)
+            self[:c_iflag] = self[:c_iflag] | LIBC::CONSTANTS['IGNPAR']
+          end
+          self[:c_cflag] = self[:c_cflag] | mask; val
+        end
+
+        def parity #:nodoc:
+          CONSTANTS['PARITY_'].fetch(self[:c_cflag] & CONSTANTS['PARITY_BITMASK'])
+        end
+      end
+
+      CONSTANTS ||= begin #:nodoc:
+        constants = self.os_specific_constants
+        constants['BAUD_'] = constants['BAUD'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['DATA_BITS_'] = constants['DATA_BITS'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['STOP_BITS_'] = constants['STOP_BITS'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['PARITY_'] = constants['PARITY'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['BAUD_BITMASK'] = constants['BAUD'].values.max
+        constants['DATA_BITS_BITMASK'] = constants['DATA_BITS'].values.max
+        constants['STOP_BITS_BITMASK'] = constants['STOP_BITS'].values.max
+        constants['PARITY_BITMASK'] = constants['PARITY'].values.max
+        constants.freeze
+      end
+
+      ERRNO ||= Errno.constants.each_with_object({}) { |e, r| e = Errno.const_get(e); r[e::Errno] = e }.freeze #:nodoc:
+
+      attach_function :c_tcgetattr, :tcgetattr, [:int, :buffer_in], :int #:nodoc:
+      attach_function :c_tcsetattr, :tcsetattr, [:int, :int, :buffer_out], :int #:nodoc:
+
+      private_class_method :os_specific_constants, :c_tcgetattr, :c_tcsetattr #:nodoc:
+      private_constant :ERRNO #:nodoc:
+    end
+
+    private_constant :LIBC #:nodoc:
+    private_class_method :new #:nodoc:
+  end
+end

data/lib/ffi-serial/windows.rb

@@ -0,0 +1,312 @@
+module Serial #:nodoc:
+  module Windows #:nodoc:
+    def self.new(com_port, baud, data_bits, stop_bits, parity) #:nodoc:
+      # Either specify as 'COM1' or a number. eg 1 for 'COM1'
+      begin
+        as_int = Integer(com_port)
+        com_port = '\\\\.\\COM' + as_int.to_s
+      rescue StandardError
+        com_port = '\\\\.\\' + com_port.to_s.strip.chomp.upcase
+      end
+
+      dcb = Kernel32::DCB.new
+
+      dcb.baud = baud
+      dcb.data_bits = data_bits
+      dcb.stop_bits = stop_bits
+      dcb.parity = parity
+
+      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
+
+        # Sane defaults
+        dcb[:Flags] = dcb[:Flags] | (Kernel32::CONSTANTS['FLAGS'].fetch('fDtrControl').fetch(:enable))
+        dcb[:XonChar] = 17
+        dcb[:XoffChar] = 19
+
+        Kernel32.SetCommState(io, dcb)
+        Kernel32.ClearCommError(io)
+        Kernel32.set_io_block(io)
+      rescue Exception
+        begin; io.close; rescue Exception; end
+        raise
+      end
+      io
+    end
+
+    def baud #:nodoc:
+      Kernel32.GetCommState(self).baud
+    end
+
+    def data_bits #:nodoc:
+      Kernel32.GetCommState(self).data_bits
+    end
+
+    def stop_bits #:nodoc:
+      Kernel32.GetCommState(self).stop_bits
+    end
+
+    def parity #:nodoc:
+      Kernel32.GetCommState(self).parity
+    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
+
+      if result.nil? || (0 == result.length)
+        if ((!options.nil?) && (false == options[:exception]))
+          return :wait_readable
+        end
+        raise Errno::EWOULDBLOCK.new
+      end
+      result
+    end
+
+    def readpartial(maxlen, outbuf = nil) #:nodoc:
+      ch = self.read(1)
+      if (ch.nil? || (0 == ch.length))
+        return ch
+      end
+      self.ungetc(ch)
+      Kernel32.set_io_nonblock(self)
+      outbuf.nil? ? read(maxlen) : read(maxlen, outbuf)
+    ensure
+      Kernel32.set_io_block(self)
+    end
+
+    def readbyte #:nodoc:
+      Kernel32.set_io_nonblock(self); super
+    ensure
+      Kernel32.set_io_block(self)
+    end
+
+    def getc #:nodoc:
+      Kernel32.set_io_nonblock(self); super
+    ensure
+      Kernel32.set_io_block(self)
+    end
+
+    def readchar #:nodoc:
+      Kernel32.set_io_nonblock(self); super
+    ensure
+      Kernel32.set_io_block(self)
+    end
+
+    def to_s #:nodoc:
+      ['#<Serial:', @__serial__port__, '>'].join.to_s
+    end
+
+    def inspect #:nodoc:
+      self.to_s
+    end
+
+    ##
+    # FFI integration with Kernel32.dll to provide access to OS specific serial port APIs
+    module Kernel32 #:nodoc:
+      require 'ffi'
+
+      extend FFI::Library #:nodoc:
+      ffi_lib 'kernel32'
+      ffi_convention :stdcall
+
+      def self.GetCommState(ruby_io) #:nodoc:
+        dcb = DCB.new
+        dcb[:DCBlength] = dcb.size
+        return dcb unless (0 == c_GetCommState(LIBC._get_osfhandle(ruby_io), dcb))
+        raise ERRNO[FFI.errno].new
+      end
+
+      def self.SetCommState(ruby_io, dcb) #:nodoc:
+        dcb[:DCBlength] = dcb.size
+        dcb[:Flags] = dcb[:Flags] | 1 # fBinary must be true
+        return true unless (0 == c_SetCommState(LIBC._get_osfhandle(ruby_io), dcb))
+        raise ERRNO[FFI.errno].new
+      end
+
+      def self.GetCommTimeouts(ruby_io) #:nodoc:
+        commtimeouts = COMMTIMEOUTS.new
+        return commtimeouts unless (0 == c_GetCommTimeouts(LIBC._get_osfhandle(fd), commtimeouts))
+        raise ERRNO[FFI.errno].new
+      end
+
+      def self.SetCommTimeouts(ruby_io, commtimeouts) #:nodoc:
+        return true unless (0 == c_SetCommTimeouts(LIBC._get_osfhandle(ruby_io), commtimeouts))
+        raise ERRNO[FFI.errno].new
+      end
+
+      def self.ClearCommError(ruby_io) #:nodoc:
+        return true unless (0 == c_ClearCommError(LIBC._get_osfhandle(ruby_io), 0, 0))
+        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:
+        self.SetCommTimeouts(ruby_io, (@@read_nonblock_io ||= begin
+          timeouts = COMMTIMEOUTS.new
+          timeouts[:ReadIntervalTimeout] = CONSTANTS['MAXDWORD']
+          timeouts[:ReadTotalTimeoutMultiplier] = 0
+          timeouts[:ReadTotalTimeoutConstant] = 0
+          timeouts[:WriteTotalTimeoutMultiplier] = 1
+          timeouts[:WriteTotalTimeoutConstant] = 1
+          timeouts
+        end))
+      end
+
+      class DCB < FFI::Struct #:nodoc:
+        layout :DCBlength, :uint32,
+               :BaudRate, :uint32,
+               :Flags, :uint32,
+               :wReserved, :uint16,
+               :XonLim, :uint16,
+               :XoffLim, :uint16,
+               :ByteSize, :uint8,
+               :Parity, :uint8,
+               :StopBits, :uint8,
+               :XonChar, :int8,
+               :XoffChar, :int8,
+               :ErrorChar, :int8,
+               :EofChar, :int8,
+               :EvtChar, :int8,
+               :wReserved1, :uint16
+
+        def baud=(val) #:nodoc:
+          new_val = begin
+            Integer(val)
+          rescue StandardError
+            -1
+          end
+          if (0 >= new_val)
+            raise ArgumentError.new "Invalid baud, specify a positive Integer"
+          end
+          self[:BaudRate] = new_val; val
+        end
+
+        def baud #:nodoc:
+          self[:BaudRate]
+        end
+
+        def data_bits=(val) #:nodoc:
+          parsed = CONSTANTS['DATA_BITS'].fetch(val, nil)
+          if parsed.nil?
+            raise ArgumentError.new "Invalid data bits, supported values #{CONSTANTS['DATA_BITS'].keys.inspect}"
+          end
+          self[:ByteSize] = parsed; val
+        end
+
+        def data_bits #:nodoc:
+          CONSTANTS['DATA_BITS_'].fetch(self[:ByteSize])
+        end
+
+        def stop_bits=(val) #:nodoc:
+          parsed = CONSTANTS['STOP_BITS'].fetch(val, nil)
+          if parsed.nil?
+            raise ArgumentError.new "Invalid data bits, supported values #{CONSTANTS['STOP_BITS'].keys.inspect}"
+          end
+          self[:StopBits] = parsed; val
+        end
+
+        def stop_bits #:nodoc:
+          CONSTANTS['STOP_BITS_'].fetch(self[:StopBits])
+        end
+
+        def parity=(val) #:nodoc:
+          parsed = CONSTANTS['PARITY'].fetch(val, nil)
+          if parsed.nil?
+            raise ArgumentError.new "Invalid parity, supported values #{CONSTANTS['PARITY'].keys.inspect}"
+          end
+          if (:none == val)
+            self[:Flags] = self[:Flags] & (~CONSTANTS['FLAGS'].fetch('fParity'))
+          else
+            self[:Flags] = self[:Flags] | CONSTANTS['FLAGS'].fetch('fParity')
+          end
+          self[:Parity] = parsed; val
+        end
+
+        def parity #:nodoc:
+          CONSTANTS['PARITY_'].fetch(self[:Parity])
+        end
+      end
+
+      class COMMTIMEOUTS < FFI::Struct #:nodoc:
+        layout :ReadIntervalTimeout, :uint32,
+               :ReadTotalTimeoutMultiplier, :uint32,
+               :ReadTotalTimeoutConstant, :uint32,
+               :WriteTotalTimeoutMultiplier, :uint32,
+               :WriteTotalTimeoutConstant, :uint32
+      end
+
+      CONSTANTS ||= begin #:nodoc:
+        constants = {
+          'MAXDWORD' => 4294967295,
+          'DATA_BITS' => { 5 => 5, 6 => 6, 7 => 7, 8 => 8 }.freeze,    
+          'STOP_BITS' => { 1 => 0, 1.5 => 1, 2 => 2 }.freeze,
+          'PARITY' => { none: 0, odd: 1, even: 2, mark: 3, space: 4 }.freeze,
+          'FLAGS' => {
+            'fParity' => 2, 'fOutxCtsFlow' => 4, 'fOutxDsrFlow' => 8,
+            'fDtrControl' => { disable: 0, enable: 16, handshake: 32 }.freeze,
+            'fDsrSensitivity' => 64, 'fTXContinueOnXoff' => 128, 'fOutX' => 256,
+            'fInX' => 512, 'fErrorChar' => 1024, 'fNull' => 2048,
+            'fRtsControl' => { disable: 0, enable: 4096, handshake: 8192,  toggle: 12288 }.freeze,
+            'fAbortOnError' => 16384
+          }.freeze,
+        }
+
+        constants['DATA_BITS_'] = constants['DATA_BITS'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['STOP_BITS_'] = constants['STOP_BITS'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['PARITY_'] = constants['PARITY'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['FLAGS_'] = {}
+        constants['FLAGS_']['fDtrControl'] = constants['FLAGS']['fDtrControl'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['FLAGS_']['fRtsControl'] = constants['FLAGS']['fRtsControl'].each_with_object({}) { |(k,v),r| r[v] = k }.freeze
+        constants['FLAGS_'].freeze
+
+        constants.freeze
+      end
+
+      module LIBC #:nodoc:
+        extend FFI::Library #:nodoc:
+        ffi_lib FFI::Library::LIBC
+
+        def self._get_osfhandle(ruby_io) #:nodoc:
+          handle = c__get_osfhandle(ruby_io.fileno)
+          return handle unless (-1 == handle)
+          raise ERRNO[FFI.errno].new
+        end
+
+        attach_function :c__get_osfhandle, :_get_osfhandle, [:int], :long #:nodoc:
+        private_class_method :c__get_osfhandle #:nodoc:
+      end
+
+      ERRNO ||= Errno.constants.each_with_object({}) { |e, r| e = Errno.const_get(e); r[e::Errno] = e }.freeze #:nodoc:
+
+      attach_function :c_GetCommState, :GetCommState, [:long, :buffer_out], :int32 #:nodoc:
+      attach_function :c_SetCommState, :SetCommState, [:long, :buffer_in], :int32 #:nodoc:
+      attach_function :c_GetCommTimeouts, :GetCommTimeouts, [:long, :buffer_out], :int32 #:nodoc:
+      attach_function :c_SetCommTimeouts, :SetCommTimeouts, [:long, :buffer_in], :int32 #:nodoc:
+      attach_function :c_ClearCommError, :ClearCommError, [:long, :int, :int], :int32 #:nodoc:
+      private_class_method :c_GetCommState, :c_SetCommState, :c_GetCommTimeouts, :c_SetCommTimeouts, :c_ClearCommError #:nodoc:
+      private_constant :LIBC, :ERRNO #:nodoc:
+    end
+
+    private_constant :Kernel32 #:nodoc:
+  end
+end

data/lib/ffi-serial.rb

@@ -0,0 +1,69 @@
+# :main: README.md
+module Serial
+  begin #:nodoc:
+    require 'ffi'
+  rescue LoadError
+    raise LoadError.new 'Could not load ruby gem ffi'
+  end
+
+  ##
+  # :attr_reader: baud
+  # Determine the current serial port baud rate by querying the underlying operating system
+
+  ##
+  # :attr_reader: data_bits
+  # Determine the current serial port data bits by querying the underlying operating system
+
+  ##
+  # :attr_reader: stop_bits
+  # Determine the current serial port stop bits by querying the underlying operating system
+
+  ##
+  # :attr_reader: parity
+  # Determine the current serial port parity by querying the underlying operating system
+
+  ##
+  # Create a new Ruby IO configured with the serial port parameters
+  #
+  # :call-seq:
+  #   new(port: '/dev/tty or COM1')
+  #   new(port: '/dev/tty or COM1', baud: 9600, data_bits: 8, stop_bits: 1, parity: :none)
+  def self.new(config)
+    driver = if ('Windows_NT' == ENV['OS'])
+      @@loaded_ffi_serial_windows ||= begin
+        require 'ffi-serial/windows'
+        true
+      end
+      Windows
+    else
+      @@loaded_ffi_serial_posix ||= begin
+        require 'ffi-serial/posix'
+        true
+      end
+      Posix
+    end
+
+    config = config.each_with_object({}) { |(k,v),r| r[k.to_s.strip.chomp.downcase.gsub(/\-|\_|\s/, '')] = v }
+    
+    port = config.delete('port') { raise ArgumentError.new ':port not specified' }
+    baud = config.delete('baud') { 9600 }
+    data_bits = config.delete('databits') { 8 }
+    stop_bits = config.delete('stopbits') { 1 }
+    parity = config.delete('parity') { :none }
+
+    if !config.empty?
+      raise ArgumentError.new "Unknown options specified: #{config.keys}"
+    end
+
+    # Create a new Ruby IO pointing to the serial port and configure it
+    # using the OS specific function
+    new_instance = driver.method(:new).call(
+      port,
+      Integer(baud),
+      Integer(data_bits),
+      Integer(stop_bits),
+      parity.to_s.strip.chomp.downcase.to_sym)
+
+    new_instance
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: ffi-serial
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Johan van der Vyver
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.3
+description: Yet another Ruby Serial Port implementation using FFI. Returns a Ruby
+  IO object configured as a serial port to leverage the extensive Ruby IO standard
+  library functionality
+email: code@johan.vdvyver.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/ffi-serial.rb
+- lib/ffi-serial/bsd.rb
+- lib/ffi-serial/darwin.rb
+- lib/ffi-serial/linux.rb
+- lib/ffi-serial/posix.rb
+- lib/ffi-serial/windows.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- FFI Serial
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: FFI Serial
+test_files: []