rs_232 2.0.4

data/ext/rs_232/windows/port.c

@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2013, Ingenico Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+ * provided that the above copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ **/
+
+#include "port.h"
+
+
+VALUE setDtrIO(VALUE self, VALUE rb_int)
+{
+    {
+        Check_Type(rb_int, T_FIXNUM);
+    }
+
+    int boolean = FIX2INT(rb_int);
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    return INT2FIX( EscapeCommFunction(port->fd, boolean == 1 ? SETDTR : CLRDTR) );
+}
+
+
+VALUE setRtsIO(VALUE self, VALUE rb_int)
+{
+    {
+        Check_Type(rb_int, T_FIXNUM);
+    }
+
+    int boolean = FIX2INT(rb_int);
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    return INT2FIX( EscapeCommFunction(port->fd, boolean == 1 ? SETRTS : CLRRTS) );
+}
+
+
+VALUE lineStatusIO(VALUE self)
+{
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    unsigned long Status = 0, Temp = 0;
+
+    GetCommModemStatus(port->fd, &Temp);
+
+    if (Temp & MS_CTS_ON) Status |= LS_CTS;
+    if (Temp & MS_DSR_ON) Status |= LS_DSR;
+    if (Temp & MS_RING_ON) Status |= LS_RI;
+    if (Temp & MS_RLSD_ON) Status |= LS_DCD;
+
+    return LONG2FIX(Status);
+}
+
+
+static void platformInitIO(PortDescriptor *port)
+{
+    port->fd     = INVALID_HANDLE_VALUE;
+    port->status = 1;
+}
+
+
+void updateSettings(PortDescriptor *port)
+{
+
+    if (port->status != 0)
+        rb_raise(rb_eException, "Can not set due to comport is not open, status: %d\n", port->status);
+
+
+    if (port->toBeUpdated & T_BaudRate)
+        port->commConfig.dcb.BaudRate = port->settings.BaudRate;
+
+
+    if (port->toBeUpdated & T_Parity)
+    {
+        port->commConfig.dcb.Parity  = (BYTE) port->settings.Parity;
+        port->commConfig.dcb.fParity = (port->settings.Parity == PAR_NONE) ? 0 : 1;
+    }
+
+
+    if (port->toBeUpdated & T_DataBits)
+    {
+        port->commConfig.dcb.ByteSize = (BYTE) port->settings.DataBits;
+    }
+
+
+    if (port->toBeUpdated & T_StopBits)
+    {
+        switch (port->settings.StopBits)
+        {
+            case STOP_1:
+                port->commConfig.dcb.StopBits = ONESTOPBIT;
+                break;
+            case STOP_2:
+                port->commConfig.dcb.StopBits = TWOSTOPBITS;
+                break;
+        }
+    }
+
+    if (port->toBeUpdated & T_Flow)
+    {
+        switch (port->settings.FlowControl)
+        {
+            case FLOW_OFF:
+                port->commConfig.dcb.fOutxCtsFlow = 0;
+                port->commConfig.dcb.fRtsControl  = RTS_CONTROL_DISABLE;
+                port->commConfig.dcb.fInX         = 0;
+                port->commConfig.dcb.fOutX        = 0;
+                break;
+            case FLOW_XONXOFF:
+                port->commConfig.dcb.fOutxCtsFlow = 0;
+                port->commConfig.dcb.fRtsControl  = RTS_CONTROL_DISABLE;
+                port->commConfig.dcb.fInX         = 1;
+                port->commConfig.dcb.fOutX        = 1;
+                break;
+            case FLOW_HARDWARE:
+                port->commConfig.dcb.fOutxCtsFlow = 1;
+                port->commConfig.dcb.fRtsControl  = RTS_CONTROL_HANDSHAKE;
+                port->commConfig.dcb.fInX         = 0;
+                port->commConfig.dcb.fOutX        = 0;
+                break;
+        }
+    }
+
+    if (port->toBeUpdated & T_TimeOut)
+    {
+        int millisec                             = port->settings.Timeout_Millisec;
+
+        if (millisec == -1)
+        {
+            port->commTimeouts.ReadIntervalTimeout      = MAXDWORD;
+            port->commTimeouts.ReadTotalTimeoutConstant = 0;
+        } else
+        {
+            port->commTimeouts.ReadIntervalTimeout      = MAXDWORD;
+            port->commTimeouts.ReadTotalTimeoutConstant = millisec;
+        }
+        port->commTimeouts.ReadTotalTimeoutMultiplier  = 0;
+        port->commTimeouts.WriteTotalTimeoutMultiplier = millisec;
+        port->commTimeouts.WriteTotalTimeoutConstant   = 0;
+    }
+
+
+    if (port->toBeUpdated & T_SettingsDone)
+        SetCommConfig(port->fd, &port->commConfig, sizeof(COMMCONFIG));
+
+    if ((port->toBeUpdated & T_TimeOut))
+        SetCommTimeouts(port->fd, &port->commTimeouts);
+
+    port->toBeUpdated = 0;
+}
+
+
+static int queryStatusIO(VALUE self)
+{
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    return port->status;
+}
+
+
+VALUE isClosedIO(VALUE self)
+{
+    return queryStatusIO(self) != 0 ? Qtrue : Qfalse;
+}
+
+
+VALUE flushIO(VALUE self)
+{
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    return (INT2FIX(FlushFileBuffers(port->fd)));
+}
+
+
+VALUE bytesAvailableIO(VALUE self)
+{
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    DWORD   Errors;
+    COMSTAT Status;
+    if (ClearCommError(port->fd, &Errors, &Status))
+    {
+        return INT2FIX(Status.cbInQue);
+    }
+    return INT2FIX(0);
+}
+
+
+VALUE openIO(VALUE self)
+{
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    if (port->status == 0)
+        return INT2FIX(port->status);
+
+    DWORD conf_length = sizeof(COMMCONFIG);
+    port->commConfig.dwSize = conf_length;
+    DWORD threading = 0;
+
+    port->fd = CreateFileA(port->settings.ComPort,
+            GENERIC_READ | GENERIC_WRITE,
+            0,
+            NULL,
+            OPEN_EXISTING,
+            threading,
+            NULL);
+
+    if (port->fd == INVALID_HANDLE_VALUE)
+    {
+
+        port->status = 1;
+        rb_raise(rb_eException, "Unable to open comport: %s\n", port->settings.ComPort);
+
+    } else
+    {
+
+        port->status = 0;
+        rb_iv_set(self, "@open", INT2FIX(port->status));
+
+        GetCommConfig(port->fd, &port->commConfig, &conf_length);
+        GetCommState(port->fd, &(port->commConfig.dcb));
+
+        port->commConfig.dcb.fBinary       = 1;
+        port->commConfig.dcb.fInX          = 0;
+        port->commConfig.dcb.fOutX         = 0;
+        port->commConfig.dcb.fAbortOnError = 0;
+        port->commConfig.dcb.fNull         = 0;
+
+        port->commConfig.dcb.fDtrControl = 1;
+
+        port->toBeUpdated = T_ALL;
+
+        setSettings(self);
+
+    }
+
+    return INT2FIX(port->status);
+}
+
+
+VALUE writeIO(VALUE self, VALUE message)
+{
+
+    int recv;
+    int len;
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    Check_Type(message, T_STRING);
+
+    len = RSTRING_LEN(message);
+    char cStr[len];
+    strcpy(cStr, RSTRING_PTR(message));
+
+    if (!WriteFile(port->fd, cStr, len, (LPDWORD)((void *) &recv), NULL))
+    {
+        rb_raise(rb_eIOError, "IO: writing of the %d bytes has been failed", len);
+    }
+
+    return (INT2FIX(recv));
+
+}
+
+
+VALUE readIO(VALUE self, VALUE rb_int)
+{
+
+    {
+        Check_Type(rb_int, T_FIXNUM);
+    }
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    int n;
+    int len = FIX2INT(rb_int);
+    char buf[len];
+
+    ReadFile(port->fd, &buf, len, (LPDWORD)((void *) &n), NULL);
+
+    if (n > 0)
+      return rb_str_new(buf, n);
+
+    return Qnil;
+}
+
+
+VALUE closeIO(VALUE self)
+{
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    flushIO(self);
+    port->status = CloseHandle(port->fd);
+    port->fd     = INVALID_HANDLE_VALUE;
+
+    rb_iv_set(self, "@open", INT2FIX(port->status));
+
+    return INT2FIX(port->status);
+
+}
+
+
+VALUE initializeStruct(VALUE self, VALUE portName)
+{
+
+    {
+        Check_Type(portName, T_STRING);
+    }
+
+    PortDescriptor *port = NULL;
+
+    Data_Get_Struct(self, PortDescriptor, port);
+
+    port->settings.BaudRate         = BAUD115200;
+    port->settings.Parity           = PAR_NONE;
+    port->settings.FlowControl      = FLOW_OFF;
+    port->settings.DataBits         = DATA_8;
+    port->settings.StopBits         = STOP_1;
+    port->settings.Timeout_Millisec = 0;
+
+    snprintf(port->settings.ComPort, sizeof(port->settings.ComPort) - 1, WIN_PATTERN, RSTRING_PTR(portName));
+
+    platformInitIO(port);
+
+    rb_iv_set(self, "@port", portName);
+
+    return self;
+}
+

data/ext/rs_232/windows/port.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2013, Ingenico Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+ * provided that the above copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ **/
+
+#ifndef rs_232_port_h____FILEEXTENSION___
+#define rs_232_port_h____FILEEXTENSION___
+
+#   include <ruby.h>
+#   include <ruby/io.h>
+#   include <windows.h>
+#   include <fcntl.h>
+#   include <io.h>
+#   include <stdio.h>
+#   include <string.h>
+#   include "structs.h"
+
+#define WIN_PATTERN "\\\\.\\%s"
+
+void setBaudRate(VALUE, VALUE);
+
+VALUE getBaudRate(VALUE);
+
+void setParity(VALUE, VALUE);
+
+VALUE getParity(VALUE);
+
+void setDataBits(VALUE, VALUE);
+
+VALUE getDataBits(VALUE);
+
+void setStopBits(VALUE, VALUE);
+
+VALUE getStopBits(VALUE);
+
+void setFlowControl(VALUE, VALUE);
+
+VALUE getFlowControl(VALUE);
+
+void setTimeout(VALUE, VALUE);
+
+void setSettings(VALUE);
+
+#endif

data/features/config/config.yml

@@ -0,0 +1,2 @@
+SERIAL_PORT: COM20
+DEBUG: 0

data/features/connection.feature

@@ -0,0 +1,8 @@
+Feature: Connection
+
+  Scenario: Should have an ability to check open or not
+
+
+    * connection instance "should" be available
+    * I "close" connection
+    * connection instance "should not" be available

data/features/step_definitions/connection_steps.rb

@@ -0,0 +1,33 @@
+When /^connection instance "(should|should not)" be available$/ do |matcher|
+
+  action = matcher == 'should' ? :should : :should_not
+
+  if respond_to? :should
+    adapter.open?.send(action, be_true)
+  else
+    assert_equal(adapter.open?, action == :should)
+  end
+
+end
+
+Given /^I "(open|close)" connection$/ do |action|
+
+  adapter.send(action)
+
+  if action == 'close'
+    if respond_to? :should
+      adapter.open?.should be_false
+    else
+      assert_equal(connection.open?, false)
+    end
+  else
+    if respond_to? :should
+      adapter.open?.should be_true
+    else
+      assert_equal(connection.open?, true)
+    end
+  end
+
+end
+
+

data/features/support/adapter/dev.rb

@@ -0,0 +1,131 @@
+class Adapter::Dev < Adapter::Generic
+  attr_reader :interface
+  include CommPort
+
+  # == constructor with default params
+  #  by default port will be configured with:
+  #
+  #  @baud_rate = 115200  # BAUD_115200
+  #  @data_bits = 8       # DATA_BITS_8
+  #  @parity = 0          # PAR_NONE
+  #  @stop_bits = 1       # STOP_1
+  #  @flow_control = 0    # FLOW_OFF
+  #
+  #
+  def initialize(port, &block)
+    @interface ||= Rs232.new(port)
+    connect
+    $stdout.puts "*** Rs232 instance has been initialized. Build v#{CommPort::VERSION}"
+    super(&block)
+  end
+
+  # Open and configure interface
+  #
+  # @return [Bool]
+  #
+  def connect
+    @interface.open
+    # custom configuration should be there if required
+    # @interface.baud_rate    = BAUD_115200
+    # @interface.data_bits    = DATA_BITS_8
+    # @interface.parity       = PAR_NONE
+    # @interface.stop_bits    = STOP_1
+    # @interface.flow_control = FLOW_OFF
+    @open = open?
+  end
+
+  # == Write function implementation
+  #
+  # @param [String] bytes
+  # @return [Int]
+  #
+  def write(bytes)
+    @interface.write(bytes)
+  end
+
+  # == Closing interface and freeing structures
+  #
+  #  @return  [Bool]
+  #
+  def close
+    @interface.flush
+    @interface.close
+    @open = open?
+    !open?
+  end
+
+  # == Flashing buffer function
+  #
+  def flush
+    @interface.flush
+  end
+
+  # @return [Bool]
+  #
+  def open?
+    @interface && !@interface.closed?
+  end
+
+  # == read() implementation example
+  #
+  # @param +count+ [Int]
+  # @param +blocking+ [Bool]
+  #
+  # @return [String]
+  #
+  # === Alternative implementation:
+  # @usage:
+  #
+  #  +timeout+ = blocking_value ? 15000 : 0
+  #  +@interface.timeout+ = +timeout+
+  #  +@interface.read( +count+ )+
+  #
+  def read(count, blocking = false)
+    array       = []
+
+    bytes_count = (count == -1) ? @interface.available? : count
+
+    if blocking
+      bytes = read_io_until(count, count)
+      array.push bytes if bytes
+    else
+      bytes_count.times do
+        byte = @interface.read(1)
+        array.push byte if byte
+      end
+    end
+    array.empty? ? nil : array.join
+  end
+
+  private
+
+  # == simulate blocking function
+  #
+  # @param +count+ [Int]
+  # @param +up_to+ [Int]
+  #
+  # no direct ruby usage
+  #
+  def block_io_until(count, up_to)
+    while @interface.available? < count && up_to > 0
+      up_to -= 1
+    end
+    up_to > 0
+  end
+
+  # == simulate blocking function
+  #
+  # @param +count+ [Int]
+  # @param +up_to+ [Int]
+  #
+  # no direct ruby usage
+  #
+  def read_io_until(count, up_to)
+    until block_io_until(count, up_to)
+      sleep 0.001
+    end
+    read(count)
+  end
+
+end
+

data/features/support/adapter/generic.rb

@@ -0,0 +1,64 @@
+require 'monitor'
+
+module Adapter
+
+  class Generic
+    include MonitorMixin
+    include RsLogger
+
+    attr_accessor :event
+
+    def initialize(*args, &block)
+      Thread.abort_on_exception = true
+      unless instance_variables.include?(:@rxd)
+        @rxd = true
+      end
+      @event = block
+      super(*args)
+      run
+    end
+
+    def reading_allowed?
+      @rxd
+    end
+
+    def defer_reading
+      @rxd = false
+      !reading_allowed?
+    end
+
+    def allow_reading
+      @rxd = true
+    end
+
+    def rx(int, blocking = false)
+      byte = read(int, blocking)
+      if byte
+        logger.debug "RX [#{byte.length}]: #{byte.inspect}"
+      end
+      byte
+    end
+
+    def tx(bytes)
+      int = write(bytes)
+      logger.debug "TX [#{int}]: #{bytes.inspect}"
+      int
+    end
+
+    def restart_rx_thread
+      allow_reading
+      run
+    end
+
+    def run
+      Thread.new do
+        loop do
+          rx(1, false) if reading_allowed?
+          sleep(0.005)
+        end
+      end
+    end
+
+  end
+
+end

data/features/support/adapter/rs_logger.rb

@@ -0,0 +1,36 @@
+require "logger"
+
+module Adapter::RsLogger
+
+  class LogFormatter < ::Logger::Formatter
+
+    def call(severity, time, progname, msg)
+      "#{format_datetime(time)}[TID:#{$$}] [Rs232::#{severity}]: #{msg}\n"
+    end
+
+
+    private
+
+    def format_datetime(time)
+      if @datetime_format.nil?
+        time.strftime("%Y-%m-%d %H:%M:%S.") << "%06d " % time.usec
+      else
+        time.strftime(@datetime_format)
+      end
+    end
+
+  end
+
+  def logger
+    @logger ||= begin
+      logger = ::Logger.new( ENV["LOG"]||$stdout )
+      logger.level = ENV["DEBUG"].to_i
+      logger.formatter= LogFormatter.new
+      logger
+    end
+  end
+  
+  module_function :logger
+
+end
+

data/features/support/adapter.rb

@@ -0,0 +1,5 @@
+module Adapter
+  autoload :RsLogger, File.expand_path("../adapter/rs_logger", __FILE__)
+  autoload :Generic, File.expand_path("../adapter/generic", __FILE__)
+  autoload :Dev, File.expand_path("../adapter/dev", __FILE__)
+end

data/features/support/after.rb

@@ -0,0 +1,5 @@
+After do
+  adapter.close
+  logger.debug "Closed..."
+end
+