rs232 0.1.0

data/README

@@ -0,0 +1,40 @@
+##
+ #  
+ #                          RS232
+ #    
+ #  Ruby interface to Windows Serial Port API
+ #  
+ #  author      hugo benichi
+ #  email       hugo.benichi@m4x.org
+ #  copyright   2012 hugo benichi  
+ #  version     0.1.0
+ #
+ ##
+ 
+  installation:  
+ 
+    run in the root directory
+      rake gem_install
+    
+    it will compile the gem library and produce a .gem package for ruby
+    it will then install the .gem automatically
+    
+  usage: 
+  
+    cf test/test_rs232.rb
+    
+    first, require the gem with
+      require 'rs232'
+      
+    then instance an object of RS232, passing an address, and optionally parameters to configure
+      serial_port = RS232.new 'COM1'
+    
+    the default parameters are
+      baud rate: 9600
+      8 bits
+      1 bit stop bit
+      no parity bit
+      control flow hardware (RTS/CTS)
+      delimiters "\r\n"
+
+    you can directly use the RS232 instance with the 'write', 'read', and 'query' commands

data/lib/rs232.rb

@@ -0,0 +1,144 @@
+
+class RS232
+
+  require 'ffi'
+  
+  attr_accessor :report, :delimiter
+  attr_reader   :count, :error
+  
+  # serial port object constructor
+  # also sets the parameters and timeout properties through an hash argument
+  def initialize address, params = {} 
+    mode = Win32::GENERIC_READ | Win32::GENERIC_WRITE
+    type = Win32::OPEN_EXISTING
+    attr = Win32::FILE_ATTRIBUTE_NORMAL
+    @serial = Win32::CreateFileA( address, mode, 0, nil, type, attr, nil) 
+    @error  = Win32.error_check
+    puts "RS232 >> got file handle 0x%.8x for com port %s" % [@serial, address]   
+    DCB.new.tap do |p|
+      p[:dcblength] = DCB::Sizeof  
+      Win32::GetCommState @serial, p
+      p[:baudrate] = params[:baudrate] || 9600
+      p[:bytesize] = params[:bytesize] || 8
+      p[:stopbits] = params[:stopbits] || DCB::ONESTOPBIT
+      p[:parity]   = params[:parity]   || DCB::NOPARITY
+      Win32::SetCommState @serial, p
+      @error = Win32.error_check
+    end        
+    CommTimeouts.new.tap do |timeouts|
+      timeouts[:read_interval_timeout]          = params[:read_interval_timeout]          ||  50 
+      timeouts[:read_total_timeout_multiplier]  = params[:read_total_timeout_multiplier]  ||  50
+      timeouts[:read_total_timeout_constant]    = params[:read_total_timeout_constant]    ||  10
+      timeouts[:write_total_timeout_multiplier] = params[:write_total_timeout_multiplier] ||  50
+      timeouts[:write_total_timeout_constant]   = params[:write_total_timeout_constant]   ||  10     
+      Win32::SetCommTimeouts @serial, timeouts
+      @error = Win32.error_check
+    end    
+    grow_buffer 128
+    @count = FFI::MemoryPointer.new :uint, 1
+    @report = false
+    @delimiter = params[:delimiter] || "\r\n"
+  end
+  
+  # writes a string to the Serial port and happens the delimiter characters stores in @delimiters
+  def write string
+    command = "%s%s" % [string.chomp, @delimiter]
+    grow_buffer command.length
+    @buffer.write_string  command
+    Win32::WriteFile @serial, @buffer, command.length, @count, nil
+    @error = Win32.error_check
+    puts "write count %i" % @count.read_uint32 if @report
+  end
+  
+  # read a string from the Serial port
+  def read
+    Win32::ReadFile @serial, @buffer, @buflen, @count, nil
+    @error = Win32.error_check
+    puts "read count %i" % @count.read_uint32 if @report
+    @buffer.read_string
+  end
+  
+  # write and read helper method
+  def query string
+    write sring
+    read
+  end
+  
+  # close the Com port
+  def stop
+    Win32::CloseHandle @serial
+    @error = Win32.error_check
+  end
+  
+  # increase the buffer size for reading and writing
+  def grow_buffer size   
+    @buffer = FFI::MemoryPointer.new :char, @buflen = size if @buffer.nil? || @buflen < size
+  end
+  
+  # wraps the native Windows API functions for file IO and COMM port found in kernel32.dll
+  module Win32
+    extend FFI::Library
+    ffi_lib 'kernel32.dll'
+    [
+      [ :GetLastError,    [],  :uint32],
+      [ :CreateFileA,     [:pointer, :uint32, :uint32, :pointer, :uint32, :uint32, :pointer],  :pointer],
+      # CreateFile first argument is a const char*
+      # Windows can decide to read it as a C string (1 char = 1 byte) or a unicode string (1 char = 2 byte)
+      # the real dll functions are actually CreateFileA for the C strings and CreateFileW for unicode
+      # I strongly suggest to use CreateFileA since FFI will automatically write a C string from Ruby string
+      [ :CloseHandle,     [:pointer],  :int],
+      [ :ReadFile,        [:pointer, :pointer, :uint32, :pointer, :pointer],    :int32],
+      [ :WriteFile,       [:pointer, :pointer, :uint32, :pointer, :pointer],    :int32],
+      [ :GetCommState,    [:pointer, :pointer], :int32],
+      [ :SetCommState,    [:pointer, :pointer], :int32],
+      [ :GetCommTimeouts, [:pointer, :pointer], :int32],
+      [ :SetCommTimeouts, [:pointer, :pointer], :int32],
+    ].each{ |sig| attach_function *sig }    
+    def self.error_code
+      err = self::GetLastError()
+      "error code: %i | 0x%.8x" % [err,err]
+    end
+    def self.error_check
+      self::GetLastError().tap{ |err| puts "error: %i | 0x%.8x" % [err,err] if err != 0 }
+    end    
+    GENERIC_READ  = 0x80000000              # consts from Windows seven sdk:  
+    GENERIC_WRITE = 0x40000000              # extract with 
+    OPEN_EXISTING = 3                       #   grep -i "generic_read" *.h 
+    FILE_ATTRIBUTE_NORMAL = 0x00000080      # from the /Include directory
+  end
+  
+  # this struct is used by windows to configure the COMM port
+  class DCB < FFI::Struct
+    layout  :dcblength,   :uint32,
+            :baudrate,    :uint32,
+            :flags,       :uint32,              # the :flag uint32 is actually a bit fields compound with structure
+            :wreserved,   :uint16,              #   uint32 fBinary :1;
+            :xonlim,      :uint16,              #   uint32 fParity :1;
+            :xofflim,     :uint16,              #   uint32 fParity :1;
+            :bytesize,    :uint8,               #   uint32 fOutxCtsFlow :1;
+            :parity,      :uint8,               #   uint32 fOutxDsrFlow :1;
+            :stopbits,    :uint8,               #   uint32 fDtrControl :2;
+            :xonchar,     :int8,                #   uint32 fDsrSensitivity :1;
+            :xoffchar,    :int8,                #   uint32 fTXContinueOnXoff :1;
+            :errorchar,   :int8,                #   uint32 fOutX :1;
+            :eofchar,     :int8,                #   uint32 fInX :1;
+            :evtchar,     :int8,                #   uint32 fErrorChar :1;
+            :wreserved1,  :uint16               #   uint32 fNull :1;
+                                                #   uint32 fRtsControl :2;
+                                                #   uint32 fAbortOnError :1;
+                                                #   uint32 fDummy2 :17;          
+    Sizeof      = 28 # this is used to tell windows the size of its own struct, not sure why it is necessary (different Windows version)
+    ONESTOPBIT  = 0
+    NOPARITY    = 0
+  end
+  
+  # this structure is used to set timeout properties of the opened COM ports
+  class CommTimeouts < FFI::Struct
+    layout  :read_interval_timeout,           :uint32, 
+            :read_total_timeout_multiplier,   :uint32, 
+            :read_total_timeout_constant,     :uint32, 
+            :write_total_timeout_multiplier,  :uint32, 
+            :write_total_timeout_constant,    :uint32
+  end 
+  
+end

data/rakefile.rb

@@ -0,0 +1,11 @@
+task :test_global do ruby "test/test_rs232.rb" end
+task :test_local  do ruby "-Ilib test/test_rs232.rb" end
+
+task :gem_build   do sh "gem build rs232.gemspec" end
+task :gem_install => :gem_build do 
+  gemfile = Dir.new("./").entries.select{ |f| f =~ /rs232-[\d]+\.[\d]+\.[\d]+.gem/ }.sort[-1]
+  puts "installing %s" % gemfile
+  #sh "gem install --local %s" % gemfile
+end
+
+task :default => :test_local

data/test/test_rs232.rb

@@ -0,0 +1,19 @@
+require 'rs232'
+
+t = RS232.new 'COM1'
+
+t.write '?:V'
+puts t.read
+
+t.write 'Q:'
+puts t.read
+
+t.write 'H:1-'
+
+#$stdin.gets
+
+#t.write 'M:1+P10000'
+#t.write 'G:'
+
+puts "end of program"
+t.stop

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: rs232
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Hugo Benichi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-10 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Allows to script access to the serial port on Windows. Simple read and write commands
+email: hugo.benichi@m4x.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rs232.rb
+- test/test_rs232.rb
+- rakefile.rb
+- README
+has_rdoc: true
+homepage: http://github.com/hugobenichi/rs232
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby interface to Windows Serial Port API
+test_files: []
+