cosmos 3.0.1 → 3.1.0

data/lib/cosmos/utilities/simulated_target.rb

@@ -1,99 +1,99 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/packets/packet'
-require 'cosmos/packets/structure'
-require 'cosmos/system/system'
-
-module Cosmos
-
-  # Update Packet for Simulated Targets
-  class Packet < Structure
-    attr_accessor :packet_rate
-  end
-
-  class SimulatedTarget
-
-    attr_accessor :tlm_packets
-
-    def initialize (target_name)
-      @tlm_packets = {}
-
-      #Generate copy of telemetry packets for this target
-      System.telemetry.packets(target_name).each do |name, packet|
-        @tlm_packets[name] = packet.clone
-        @tlm_packets[name].enable_method_missing
-      end
-
-      #Set id values
-      @tlm_packets.each do |name, packet|
-        ids = packet.id_items
-        ids.each do |id|
-          packet.send((id.name + '=').to_sym, id.id_value)
-        end
-      end
-
-      @current_cycle_delta = {}
-    end
-
-    def set_rates
-      raise "Error: set_rates must be implemented by subclass"
-    end
-
-    def write(packet)
-      raise "Error: write must be implemented by subclass"
-    end
-
-    def read(count_100hz, time)
-      raise "Error: read must be implemented by subclass"
-    end
-
-    protected
-
-    def set_rate(packet_name, rate)
-      packet = @tlm_packets[packet_name.upcase]
-      packet.packet_rate = rate if packet
-    end
-
-    def get_pending_packets(count_100hz)
-      pending_packets = []
-
-      #determine if packets are due to be sent and add to pending
-      @tlm_packets.each do |name, packet|
-        if packet.packet_rate
-          if ((count_100hz % packet.packet_rate) == 0)
-            pending_packets << packet
-          end
-        end
-      end
-
-      pending_packets
-    end
-
-    def cycle_tlm_item(packet, item_name, min, max, first_delta)
-      packet_name = packet.packet_name
-      @current_cycle_delta[packet_name] ||= {}
-      @current_cycle_delta[packet_name][item_name] ||= first_delta
-
-      current_delta = @current_cycle_delta[packet_name][item_name]
-      current_value = packet.read(item_name)
-      updated_value = current_value + current_delta
-      if updated_value < min
-        updated_value = min
-        @current_cycle_delta[packet_name][item_name] = -current_delta
-      elsif updated_value > max
-        updated_value = max
-        @current_cycle_delta[packet_name][item_name] = -current_delta
-      end
-      packet.write(item_name, updated_value)
-    end
-  end
-
-end
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/packets/packet'
+require 'cosmos/packets/structure'
+require 'cosmos/system/system'
+
+module Cosmos
+
+  # Update Packet for Simulated Targets
+  class Packet < Structure
+    attr_accessor :packet_rate
+  end
+
+  class SimulatedTarget
+
+    attr_accessor :tlm_packets
+
+    def initialize (target_name)
+      @tlm_packets = {}
+
+      #Generate copy of telemetry packets for this target
+      System.telemetry.packets(target_name).each do |name, packet|
+        @tlm_packets[name] = packet.clone
+        @tlm_packets[name].enable_method_missing
+      end
+
+      #Set id values
+      @tlm_packets.each do |name, packet|
+        ids = packet.id_items
+        ids.each do |id|
+          packet.send((id.name + '=').to_sym, id.id_value)
+        end
+      end
+
+      @current_cycle_delta = {}
+    end
+
+    def set_rates
+      raise "Error: set_rates must be implemented by subclass"
+    end
+
+    def write(packet)
+      raise "Error: write must be implemented by subclass"
+    end
+
+    def read(count_100hz, time)
+      raise "Error: read must be implemented by subclass"
+    end
+
+    protected
+
+    def set_rate(packet_name, rate)
+      packet = @tlm_packets[packet_name.upcase]
+      packet.packet_rate = rate if packet
+    end
+
+    def get_pending_packets(count_100hz)
+      pending_packets = []
+
+      #determine if packets are due to be sent and add to pending
+      @tlm_packets.each do |name, packet|
+        if packet.packet_rate
+          if ((count_100hz % packet.packet_rate) == 0)
+            pending_packets << packet
+          end
+        end
+      end
+
+      pending_packets
+    end
+
+    def cycle_tlm_item(packet, item_name, min, max, first_delta)
+      packet_name = packet.packet_name
+      @current_cycle_delta[packet_name] ||= {}
+      @current_cycle_delta[packet_name][item_name] ||= first_delta
+
+      current_delta = @current_cycle_delta[packet_name][item_name]
+      current_value = packet.read(item_name)
+      updated_value = current_value + current_delta
+      if updated_value < min
+        updated_value = min
+        @current_cycle_delta[packet_name][item_name] = -current_delta
+      elsif updated_value > max
+        updated_value = max
+        @current_cycle_delta[packet_name][item_name] = -current_delta
+      end
+      packet.write(item_name, updated_value)
+    end
+  end
+
+end

data/lib/cosmos/utilities/sleeper.rb

@@ -0,0 +1,44 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+module Cosmos
+
+  # Allows for a breakable sleep implementation using the self-pipe trick
+  # See http://www.sitepoint.com/the-self-pipe-trick-explained/
+  class Sleeper
+    def initialize
+      @pipe_reader, @pipe_writer = IO.pipe
+      @readers = [@pipe_reader]
+      @canceled = false
+    end
+
+    # Breakable version of sleep
+    # @param seconds Number of seconds to sleep
+    # @return true if the sleep was broken by someone calling cancel
+    #   otherwise returns false
+    def sleep(seconds)
+      read_ready, _ = IO.select(@readers, nil, nil, seconds)
+      if read_ready && read_ready.include?(@pipe_reader)
+        return true
+      else
+        return false
+      end
+    end
+
+    # Break sleeping - Once canceled a sleeper cannot be used again
+    def cancel
+      if !@canceled
+        @canceled = true
+        @pipe_writer.write('.')
+      end
+    end
+  end
+
+end # module Cosmos

data/lib/cosmos/version.rb

@@ -1,12 +1,12 @@
-# encoding: ascii-8bit
-
-COSMOS_VERSION = '3.0.1'
-module Cosmos
-  module Version
-    MAJOR = '3'
-    MINOR = '0'
-    PATCH = '1'
-    BUILD = 'f19556ddbfdda1e439bfaec33e9f81f32a3e868e'
-  end
-  VERSION = '3.0.1'
-end
+# encoding: ascii-8bit
+
+COSMOS_VERSION = '3.1.0'
+module Cosmos
+  module Version
+    MAJOR = '3'
+    MINOR = '1'
+    PATCH = '0'
+    BUILD = 'df3e9ba123a5e75fe76c191e9fab9c80df7ab1d4'
+  end
+  VERSION = '3.1.0'
+end

data/lib/cosmos/win32/excel.rb

@@ -1,66 +1,66 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'win32ole'
-
-module Cosmos
-
-  #
-  # This class will take an Excel spreadsheet and build an easily manipulated spreadsheet in ruby
-  #
-  class ExcelSpreadsheet
-
-    attr_reader :worksheets
-
-    class ExcelWorksheet
-
-      attr_reader :name, :num_rows, :num_columns, :data
-
-      def initialize (worksheet)
-        @name = worksheet.name
-        @num_rows = worksheet.UsedRange.rows.count
-        @num_columns = worksheet.UsedRange.columns.count
-
-        #Get Excel Data from Worksheet
-        @data = worksheet.UsedRange.value
-      end
-
-    end
-
-    def initialize (filename)
-      excel = WIN32OLE.new('excel.application')
-      excel.visible = false
-      wb = excel.workbooks.open(filename)
-
-      @worksheets = []
-
-      count = wb.worksheets.count
-      count.times do |index|
-        ws = wb.worksheets(index + 1)
-        @worksheets << ExcelWorksheet.new(ws)
-      end
-
-      excel.DisplayAlerts = false
-      excel.quit
-      excel = nil
-      GC.start
-    end
-
-  end
-
-  module ExcelColumnConstants
-    index = 0
-    ('A'..'IV').each do |value|
-      self.const_set(value, index)
-      index += 1
-    end
-  end
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'win32ole'
+
+module Cosmos
+
+  #
+  # This class will take an Excel spreadsheet and build an easily manipulated spreadsheet in ruby
+  #
+  class ExcelSpreadsheet
+
+    attr_reader :worksheets
+
+    class ExcelWorksheet
+
+      attr_reader :name, :num_rows, :num_columns, :data
+
+      def initialize (worksheet)
+        @name = worksheet.name
+        @num_rows = worksheet.UsedRange.rows.count
+        @num_columns = worksheet.UsedRange.columns.count
+
+        #Get Excel Data from Worksheet
+        @data = worksheet.UsedRange.value
+      end
+
+    end
+
+    def initialize (filename)
+      excel = WIN32OLE.new('excel.application')
+      excel.visible = false
+      wb = excel.workbooks.open(filename)
+
+      @worksheets = []
+
+      count = wb.worksheets.count
+      count.times do |index|
+        ws = wb.worksheets(index + 1)
+        @worksheets << ExcelWorksheet.new(ws)
+      end
+
+      excel.DisplayAlerts = false
+      excel.quit
+      excel = nil
+      GC.start
+    end
+
+  end
+
+  module ExcelColumnConstants
+    index = 0
+    ('A'..'IV').each do |value|
+      self.const_set(value, index)
+      index += 1
+    end
+  end
+
+end # module Cosmos

data/lib/cosmos/win32/win32.rb

@@ -1,387 +1,387 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/win32/win32_main'
-require 'cosmos/packets/structure'
-
-module Cosmos
-
-  # Win32 class
-  #
-  # This class implements the Win32
-  #
-  class Win32
-    # Create a file
-    def self.create_file(filename, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file = NULL)
-      api = Win32API.new('Kernel32', 'CreateFile', [LP, DWORD, DWORD, LP, DWORD, DWORD, HANDLE], HANDLE)
-      handle = api.call(filename, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file)
-      raise "Error during CreateFile: #{get_last_error_message()}" if handle == INVALID_HANDLE_VALUE
-      handle
-    end
-
-    # Close a file
-    def self.close_handle(handle)
-      api = Win32API.new('Kernel32', 'CloseHandle', [HANDLE], BOOL)
-      result = api.call(handle)
-      raise "Error closing handle: #{get_last_error_message()}" if result == 0
-      result
-    end
-
-    # Get Comm State
-    def self.get_comm_state(handle)
-      dcb = build_dcb()
-      api = Win32API.new('Kernel32', 'GetCommState', [HANDLE, LP], BOOL)
-      result = api.call(handle, dcb.buffer)
-      raise "GetCommState Error: #{get_last_error_message()}" if result == 0
-      dcb
-    end
-
-    # Set Comm State
-    def self.set_comm_state(handle, dcb)
-      api = Win32API.new('Kernel32', 'SetCommState', [HANDLE, LP], BOOL)
-      result = api.call(handle, dcb.buffer)
-      raise "SetCommState Error: #{get_last_error_message()}" if result == 0
-      result
-    end
-
-    # Set Comm Timeouts - Values in Ms
-    def self.set_comm_timeouts(handle, read_interval_timeout = 4294967295, read_total_timeout_multiplier = 0, read_total_timeout_constant = 0, write_total_timeout_multiplier = 0, write_total_timeout_constant = 0)
-      comm_timeouts = build_comm_timeouts(read_interval_timeout, read_total_timeout_multiplier, read_total_timeout_constant, write_total_timeout_multiplier, write_total_timeout_constant)
-      api = Win32API.new('Kernel32', 'SetCommTimeouts', [HANDLE, LP], BOOL)
-      result = api.call(handle, comm_timeouts.buffer)
-      raise "SetCommTimeouts Error: #{get_last_error_message()}" if result == 0
-      result
-    end
-
-    # Read File
-    def self.read_file(handle, bytes_to_read, overlapped = NULL)
-      buffer     = ' ' * (bytes_to_read + 1)
-      bytes_read = ' ' * 8
-      api = Win32API.new('Kernel32', 'ReadFile', [HANDLE, LP, DWORD, LP, LP], BOOL)
-      api.call(handle, buffer, bytes_to_read, bytes_read, overlapped)
-      bytes_read = bytes_read.unpack(DWORD)[0]
-      if bytes_read > 0
-        buffer[0..(bytes_read - 1)]
-      else
-        ''
-      end
-    end
-
-    # Write File
-    def self.write_file(handle, buffer, bytes_to_write, overlapped = NULL)
-      bytes_written = ' ' * 8
-      api = Win32API.new('Kernel32', 'WriteFile', [HANDLE, LP, DWORD, LP, LP], BOOL)
-      api.call(handle, buffer, bytes_to_write, bytes_written, overlapped)
-      bytes_written.unpack(DWORD)[0]
-    end
-
-    protected
-
-    def self.build_dcb
-      dcb = Structure.new(:LITTLE_ENDIAN)
-      dcb.define_item('DCBlength', 0, 32, :UINT)
-      dcb.define_item('BaudRate',  32, 32, :UINT)
-      dcb.define_item('fBinary', 71, 1, :UINT)
-      dcb.define_item('fParity', 70, 1, :UINT)
-      dcb.define_item('fOutxCtsFlow', 69, 1, :UINT)
-      dcb.define_item('fOutxDsrFlow', 68, 1, :UINT)
-      dcb.define_item('fDtrControl', 66, 2, :UINT)
-      dcb.define_item('fDsrSensitivity', 65, 1, :UINT)
-      dcb.define_item('fTXContinueOnXoff', 64, 1, :UINT)
-      dcb.define_item('fOutX', 79, 1, :UINT)
-      dcb.define_item('fInX', 78, 1, :UINT)
-      dcb.define_item('fErrorChar', 77, 1, :UINT)
-      dcb.define_item('fNull', 76, 1, :UINT)
-      dcb.define_item('fRtsControl', 74, 2, :UINT)
-      dcb.define_item('fAbortOnError', 73, 1, :UINT)
-      dcb.define_item('fDummy2', 88, 17, :UINT)
-      dcb.define_item('wReserved', 96, 16, :UINT)
-      dcb.define_item('XonLim', 112, 16, :UINT)
-      dcb.define_item('XoffLim', 128, 16, :UINT)
-      dcb.define_item('ByteSize', 144, 8, :UINT)
-      dcb.define_item('Parity', 152, 8, :UINT)
-      dcb.define_item('StopBits', 160, 8, :UINT)
-      dcb.define_item('XonChar', 168, 8, :INT)
-      dcb.define_item('XoffChar', 176, 8, :INT)
-      dcb.define_item('ErrorChar', 184, 8, :INT)
-      dcb.define_item('EofChar', 192, 8, :INT)
-      dcb.define_item('EvtChar', 200, 8, :INT)
-      dcb.define_item('wReserved1',   208, 16, :UINT)
-      dcb.write('DCBlength', 28)
-      dcb
-    end
-
-    def self.build_comm_timeouts(read_interval_timeout = 4294967295, read_total_timeout_multiplier = 0, read_total_timeout_constant = 0, write_total_timeout_multiplier = 0, write_total_timeout_constant = 0)
-      comm_timeouts = Structure.new(:LITTLE_ENDIAN)
-      comm_timeouts.append_item('ReadIntervalTimeout', 32, :UINT)
-      comm_timeouts.append_item('ReadTotalTimeoutMultiplier', 32, :UINT)
-      comm_timeouts.append_item('ReadTotalTimeoutConstant', 32, :UINT)
-      comm_timeouts.append_item('WriteTotalTimeoutMultiplier', 32, :UINT)
-      comm_timeouts.append_item('WriteTotalTimeoutConstant', 32, :UINT)
-      comm_timeouts.write('ReadIntervalTimeout', read_interval_timeout)
-      comm_timeouts.write('ReadTotalTimeoutMultiplier', read_total_timeout_multiplier)
-      comm_timeouts.write('ReadTotalTimeoutConstant', read_total_timeout_constant)
-      comm_timeouts.write('WriteTotalTimeoutMultiplier', write_total_timeout_multiplier)
-      comm_timeouts.write('WriteTotalTimeoutConstant', write_total_timeout_constant)
-      comm_timeouts
-    end
-
-  end # class Win32
-
-end # module Cosmos
-
-module QDA
-  module Filters
-    # Used only on windows to enable calling other executables without the
-    # annoying command-prompt box that pops up when using Ruby backticks in
-    # a script running under rubyw.
-    #
-    # Usage:
-    # output, errors = QDA::Filters::Win32Process::backtick('dir')
-    #
-    # Note - most of this code written by S Kroeger, see
-    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/155684
-    module Win32Process
-      NORMAL_PRIORITY_CLASS = 0x00000020
-      STARTUP_INFO_SIZE = 68
-      PROCESS_INFO_SIZE = 16
-      SECURITY_ATTRIBUTES_SIZE = 12
-
-      ERROR_SUCCESS = 0x00
-      FORMAT_MESSAGE_FROM_SYSTEM = 0x1000
-      FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x2000
-
-      HANDLE_FLAG_INHERIT = 1
-      HANDLE_FLAG_PROTECT_FROM_CLOSE =2
-
-      STARTF_USESHOWWINDOW = 0x00000001
-      STARTF_USESTDHANDLES = 0x00000100
-
-      class << self
-        def raise_last_win_32_error
-          errorCode = Cosmos::Win32API.new("kernel32", "GetLastError", [], 'L').call
-          if errorCode != ERROR_SUCCESS
-            params = [
-              'L', # IN DWORD dwFlags,
-              'P', # IN LPCVOID lpSource,
-              'L', # IN DWORD dwMessageId,
-              'L', # IN DWORD dwLanguageId,
-              'P', # OUT LPSTR lpBuffer,
-              'L', # IN DWORD nSize,
-              'P', # IN va_list *Arguments
-            ]
-
-            formatMessage = Cosmos::Win32API.new("kernel32", "FormatMessage", params, 'L')
-            msg = ' ' * 255
-            formatMessage.call(FORMAT_MESSAGE_FROM_SYSTEM +
-                                      FORMAT_MESSAGE_ARGUMENT_ARRAY, '', errorCode, 0, msg, 255, '')
-
-            msg.gsub!(/\000/, '')
-            msg.strip!
-            raise msg
-          else
-            raise 'GetLastError returned ERROR_SUCCESS'
-          end
-        end
-
-        def create_pipe # returns read and write handle
-          params = [
-            'P', # pointer to read handle
-            'P', # pointer to write handle
-            'P', # pointer to security attributes
-            'L'] # pipe size
-
-          createPipe = Cosmos::Win32API.new("kernel32", "CreatePipe", params, 'I')
-
-          read_handle, write_handle = [0].pack('I'), [0].pack('I')
-          sec_attrs = [SECURITY_ATTRIBUTES_SIZE, 0, 1].pack('III')
-
-          raise_last_win_32_error if createPipe.Call(read_handle,
-                                                      write_handle, sec_attrs, 0).zero?
-
-          [read_handle.unpack('I')[0], write_handle.unpack('I')[0]]
-        end
-
-        def set_handle_information(handle, flags, value)
-          params = [
-            'L', # handle to an object
-            'L', # specifies flags to change
-            'L'] # specifies new values for flags
-
-          setHandleInformation = Cosmos::Win32API.new("kernel32",
-                                               "SetHandleInformation", params, 'I')
-          raise_last_win_32_error if setHandleInformation.Call(handle,
-                                                                flags, value).zero?
-          nil
-        end
-
-        def close_handle(handle)
-          closeHandle = Cosmos::Win32API.new("kernel32", "CloseHandle", ['L'], 'I')
-          raise_last_win_32_error if closeHandle.call(handle).zero?
-        end
-
-        def create_process(command, stdin, stdout, stderror)
-          params = [
-            'L', # IN LPCSTR lpApplicationName
-            'P', # IN LPSTR lpCommandLine
-            'L', # IN LPSECURITY_ATTRIBUTES lpProcessAttributes
-            'L', # IN LPSECURITY_ATTRIBUTES lpThreadAttributes
-            'L', # IN BOOL bInheritHandles
-            'L', # IN DWORD dwCreationFlags
-            'L', # IN LPVOID lpEnvironment
-            'L', # IN LPCSTR lpCurrentDirectory
-            'P', # IN LPSTARTUPINFOA lpStartupInfo
-            'P']  # OUT LPPROCESS_INFORMATION lpProcessInformation
-
-          startupInfo = [STARTUP_INFO_SIZE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW, 0,
-            0, 0, stdin, stdout, stderror].pack('IIIIIIIIIIIISSIIII')
-
-          processInfo = [0, 0, 0, 0].pack('IIII')
-          command << 0
-
-          createProcess = Cosmos::Win32API.new("kernel32", "CreateProcess", params, 'I')
-          cp_args = [ 0, command, 0, 0, 1, 0, 0, 0, startupInfo, processInfo ]
-          raise_last_win_32_error if createProcess.call(*cp_args).zero?
-
-          hProcess, hThread,
-          dwProcessId, dwThreadId = processInfo.unpack('LLLL')
-
-          close_handle(hProcess)
-          close_handle(hThread)
-
-          [dwProcessId, dwThreadId]
-        end
-
-        def write_file(hFile, buffer)
-          params = [
-            'L', # handle to file to write to
-            'P', # pointer to data to write to file
-            'L', # number of bytes to write
-            'P', # pointer to number of bytes written
-            'L'] # pointer to structure for overlapped I/O
-
-          written = [0].pack('I')
-          writeFile = Cosmos::Win32API.new("kernel32", "WriteFile", params, 'I')
-
-          raise_last_win_32_error if writeFile.call(hFile, buffer, buffer.size,
-                                                     written, 0).zero?
-
-          written.unpack('I')[0]
-        end
-
-        def read_file(hFile)
-          params = [
-            'L', # handle of file to read
-            'P', # pointer to buffer that receives data
-            'L', # number of bytes to read
-            'P', # pointer to number of bytes read
-            'L'] #pointer to structure for data
-
-          number = [0].pack('I')
-          buffer = ' ' * 255
-
-          readFile = Cosmos::Win32API.new("kernel32", "ReadFile", params, 'I')
-          return '' if readFile.call(hFile, buffer, 255, number, 0).zero?
-
-          buffer[0...number.unpack('I')[0]]
-        end
-
-        def peek_named_pipe(hFile)
-          params = [
-            'L', # handle to pipe to copy from
-            'L', # pointer to data buffer
-            'L', # size, in bytes, of data buffer
-            'L', # pointer to number of bytes read
-            'P', # pointer to total number of bytes available
-            'L'] # pointer to unread bytes in this message
-
-          available = [0].pack('I')
-          peekNamedPipe = Cosmos::Win32API.new("kernel32", "PeekNamedPipe", params, 'I')
-
-          return -1 if peekNamedPipe.Call(hFile, 0, 0, 0, available, 0).zero?
-
-          available.unpack('I')[0]
-        end
-      end
-
-      class Win32popenIO
-        def initialize (hRead, hWrite, hError)
-          @hRead  = hRead
-          @hWrite = hWrite
-          @hError = hError
-        end
-
-        def write data
-          Win32Process::write_file(@hWrite, data.to_s)
-        end
-
-        def read
-          sleep(0.01) while Win32Process::peek_named_pipe(@hRead).zero?
-          Win32Process::read_file(@hRead)
-        end
-
-        def read_all
-          all = ''
-          until (buffer = read).empty?
-            all << buffer
-          end
-          all
-        end
-
-        def read_err
-          sleep(0.01) while Win32Process::peek_named_pipe(@hError).zero?
-          Win32Process::read_file(@hError)
-        end
-
-        def read_all_err
-          all = ''
-          until (buffer = read_err).empty?
-            all << buffer
-          end
-          all
-        end
-      end
-
-      # The only useful public method in this class - receives a command line,
-      # and returns the output content and error content as a pair of strings.
-      # No shell expansion is carried out on the command line string.
-      #
-      # Usage:
-      # output, errors = QDA::Filters::Win32Process::backtick('dir')
-      def self.backtick(command)
-        # create 3 pipes
-        child_in_r, child_in_w = create_pipe
-        child_out_r, child_out_w = create_pipe
-        child_error_r, child_error_w = create_pipe
-
-        # Ensure the write handle to the pipe for STDIN is not inherited.
-        set_handle_information(child_in_w, HANDLE_FLAG_INHERIT, 0)
-        set_handle_information(child_out_r, HANDLE_FLAG_INHERIT, 0)
-        set_handle_information(child_error_r, HANDLE_FLAG_INHERIT, 0)
-
-        create_process(command,
-                              child_in_r,
-                              child_out_w,
-                              child_error_w)
-        # we have to close the handles, so the pipes terminate with the process
-        close_handle(child_in_r)
-        close_handle(child_out_w)
-        close_handle(child_error_w)
-        close_handle(child_in_w)
-        io = Win32popenIO.new(child_out_r, child_in_w, child_error_r)
-
-        out = io.read_all().gsub(/\r/, '')
-        err = io.read_all_err().gsub(/\r/, '')
-        return out, err
-      end
-    end # module Win32Process
-  end #module Filters
-end # module QDA
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/win32/win32_main'
+require 'cosmos/packets/structure'
+
+module Cosmos
+
+  # Win32 class
+  #
+  # This class implements the Win32
+  #
+  class Win32
+    # Create a file
+    def self.create_file(filename, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file = NULL)
+      api = Win32API.new('Kernel32', 'CreateFile', [LP, DWORD, DWORD, LP, DWORD, DWORD, HANDLE], HANDLE)
+      handle = api.call(filename, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file)
+      raise "Error during CreateFile: #{get_last_error_message()}" if handle == INVALID_HANDLE_VALUE
+      handle
+    end
+
+    # Close a file
+    def self.close_handle(handle)
+      api = Win32API.new('Kernel32', 'CloseHandle', [HANDLE], BOOL)
+      result = api.call(handle)
+      raise "Error closing handle: #{get_last_error_message()}" if result == 0
+      result
+    end
+
+    # Get Comm State
+    def self.get_comm_state(handle)
+      dcb = build_dcb()
+      api = Win32API.new('Kernel32', 'GetCommState', [HANDLE, LP], BOOL)
+      result = api.call(handle, dcb.buffer)
+      raise "GetCommState Error: #{get_last_error_message()}" if result == 0
+      dcb
+    end
+
+    # Set Comm State
+    def self.set_comm_state(handle, dcb)
+      api = Win32API.new('Kernel32', 'SetCommState', [HANDLE, LP], BOOL)
+      result = api.call(handle, dcb.buffer)
+      raise "SetCommState Error: #{get_last_error_message()}" if result == 0
+      result
+    end
+
+    # Set Comm Timeouts - Values in Ms
+    def self.set_comm_timeouts(handle, read_interval_timeout = 4294967295, read_total_timeout_multiplier = 0, read_total_timeout_constant = 0, write_total_timeout_multiplier = 0, write_total_timeout_constant = 0)
+      comm_timeouts = build_comm_timeouts(read_interval_timeout, read_total_timeout_multiplier, read_total_timeout_constant, write_total_timeout_multiplier, write_total_timeout_constant)
+      api = Win32API.new('Kernel32', 'SetCommTimeouts', [HANDLE, LP], BOOL)
+      result = api.call(handle, comm_timeouts.buffer)
+      raise "SetCommTimeouts Error: #{get_last_error_message()}" if result == 0
+      result
+    end
+
+    # Read File
+    def self.read_file(handle, bytes_to_read, overlapped = NULL)
+      buffer     = ' ' * (bytes_to_read + 1)
+      bytes_read = ' ' * 8
+      api = Win32API.new('Kernel32', 'ReadFile', [HANDLE, LP, DWORD, LP, LP], BOOL)
+      api.call(handle, buffer, bytes_to_read, bytes_read, overlapped)
+      bytes_read = bytes_read.unpack(DWORD)[0]
+      if bytes_read > 0
+        buffer[0..(bytes_read - 1)]
+      else
+        ''
+      end
+    end
+
+    # Write File
+    def self.write_file(handle, buffer, bytes_to_write, overlapped = NULL)
+      bytes_written = ' ' * 8
+      api = Win32API.new('Kernel32', 'WriteFile', [HANDLE, LP, DWORD, LP, LP], BOOL)
+      api.call(handle, buffer, bytes_to_write, bytes_written, overlapped)
+      bytes_written.unpack(DWORD)[0]
+    end
+
+    protected
+
+    def self.build_dcb
+      dcb = Structure.new(:LITTLE_ENDIAN)
+      dcb.define_item('DCBlength', 0, 32, :UINT)
+      dcb.define_item('BaudRate',  32, 32, :UINT)
+      dcb.define_item('fBinary', 71, 1, :UINT)
+      dcb.define_item('fParity', 70, 1, :UINT)
+      dcb.define_item('fOutxCtsFlow', 69, 1, :UINT)
+      dcb.define_item('fOutxDsrFlow', 68, 1, :UINT)
+      dcb.define_item('fDtrControl', 66, 2, :UINT)
+      dcb.define_item('fDsrSensitivity', 65, 1, :UINT)
+      dcb.define_item('fTXContinueOnXoff', 64, 1, :UINT)
+      dcb.define_item('fOutX', 79, 1, :UINT)
+      dcb.define_item('fInX', 78, 1, :UINT)
+      dcb.define_item('fErrorChar', 77, 1, :UINT)
+      dcb.define_item('fNull', 76, 1, :UINT)
+      dcb.define_item('fRtsControl', 74, 2, :UINT)
+      dcb.define_item('fAbortOnError', 73, 1, :UINT)
+      dcb.define_item('fDummy2', 88, 17, :UINT)
+      dcb.define_item('wReserved', 96, 16, :UINT)
+      dcb.define_item('XonLim', 112, 16, :UINT)
+      dcb.define_item('XoffLim', 128, 16, :UINT)
+      dcb.define_item('ByteSize', 144, 8, :UINT)
+      dcb.define_item('Parity', 152, 8, :UINT)
+      dcb.define_item('StopBits', 160, 8, :UINT)
+      dcb.define_item('XonChar', 168, 8, :INT)
+      dcb.define_item('XoffChar', 176, 8, :INT)
+      dcb.define_item('ErrorChar', 184, 8, :INT)
+      dcb.define_item('EofChar', 192, 8, :INT)
+      dcb.define_item('EvtChar', 200, 8, :INT)
+      dcb.define_item('wReserved1',   208, 16, :UINT)
+      dcb.write('DCBlength', 28)
+      dcb
+    end
+
+    def self.build_comm_timeouts(read_interval_timeout = 4294967295, read_total_timeout_multiplier = 0, read_total_timeout_constant = 0, write_total_timeout_multiplier = 0, write_total_timeout_constant = 0)
+      comm_timeouts = Structure.new(:LITTLE_ENDIAN)
+      comm_timeouts.append_item('ReadIntervalTimeout', 32, :UINT)
+      comm_timeouts.append_item('ReadTotalTimeoutMultiplier', 32, :UINT)
+      comm_timeouts.append_item('ReadTotalTimeoutConstant', 32, :UINT)
+      comm_timeouts.append_item('WriteTotalTimeoutMultiplier', 32, :UINT)
+      comm_timeouts.append_item('WriteTotalTimeoutConstant', 32, :UINT)
+      comm_timeouts.write('ReadIntervalTimeout', read_interval_timeout)
+      comm_timeouts.write('ReadTotalTimeoutMultiplier', read_total_timeout_multiplier)
+      comm_timeouts.write('ReadTotalTimeoutConstant', read_total_timeout_constant)
+      comm_timeouts.write('WriteTotalTimeoutMultiplier', write_total_timeout_multiplier)
+      comm_timeouts.write('WriteTotalTimeoutConstant', write_total_timeout_constant)
+      comm_timeouts
+    end
+
+  end # class Win32
+
+end # module Cosmos
+
+module QDA
+  module Filters
+    # Used only on windows to enable calling other executables without the
+    # annoying command-prompt box that pops up when using Ruby backticks in
+    # a script running under rubyw.
+    #
+    # Usage:
+    # output, errors = QDA::Filters::Win32Process::backtick('dir')
+    #
+    # Note - most of this code written by S Kroeger, see
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/155684
+    module Win32Process
+      NORMAL_PRIORITY_CLASS = 0x00000020
+      STARTUP_INFO_SIZE = 68
+      PROCESS_INFO_SIZE = 16
+      SECURITY_ATTRIBUTES_SIZE = 12
+
+      ERROR_SUCCESS = 0x00
+      FORMAT_MESSAGE_FROM_SYSTEM = 0x1000
+      FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x2000
+
+      HANDLE_FLAG_INHERIT = 1
+      HANDLE_FLAG_PROTECT_FROM_CLOSE =2
+
+      STARTF_USESHOWWINDOW = 0x00000001
+      STARTF_USESTDHANDLES = 0x00000100
+
+      class << self
+        def raise_last_win_32_error
+          errorCode = Cosmos::Win32API.new("kernel32", "GetLastError", [], 'L').call
+          if errorCode != ERROR_SUCCESS
+            params = [
+              'L', # IN DWORD dwFlags,
+              'P', # IN LPCVOID lpSource,
+              'L', # IN DWORD dwMessageId,
+              'L', # IN DWORD dwLanguageId,
+              'P', # OUT LPSTR lpBuffer,
+              'L', # IN DWORD nSize,
+              'P', # IN va_list *Arguments
+            ]
+
+            formatMessage = Cosmos::Win32API.new("kernel32", "FormatMessage", params, 'L')
+            msg = ' ' * 255
+            formatMessage.call(FORMAT_MESSAGE_FROM_SYSTEM +
+                                      FORMAT_MESSAGE_ARGUMENT_ARRAY, '', errorCode, 0, msg, 255, '')
+
+            msg.gsub!(/\000/, '')
+            msg.strip!
+            raise msg
+          else
+            raise 'GetLastError returned ERROR_SUCCESS'
+          end
+        end
+
+        def create_pipe # returns read and write handle
+          params = [
+            'P', # pointer to read handle
+            'P', # pointer to write handle
+            'P', # pointer to security attributes
+            'L'] # pipe size
+
+          createPipe = Cosmos::Win32API.new("kernel32", "CreatePipe", params, 'I')
+
+          read_handle, write_handle = [0].pack('I'), [0].pack('I')
+          sec_attrs = [SECURITY_ATTRIBUTES_SIZE, 0, 1].pack('III')
+
+          raise_last_win_32_error if createPipe.Call(read_handle,
+                                                      write_handle, sec_attrs, 0).zero?
+
+          [read_handle.unpack('I')[0], write_handle.unpack('I')[0]]
+        end
+
+        def set_handle_information(handle, flags, value)
+          params = [
+            'L', # handle to an object
+            'L', # specifies flags to change
+            'L'] # specifies new values for flags
+
+          setHandleInformation = Cosmos::Win32API.new("kernel32",
+                                               "SetHandleInformation", params, 'I')
+          raise_last_win_32_error if setHandleInformation.Call(handle,
+                                                                flags, value).zero?
+          nil
+        end
+
+        def close_handle(handle)
+          closeHandle = Cosmos::Win32API.new("kernel32", "CloseHandle", ['L'], 'I')
+          raise_last_win_32_error if closeHandle.call(handle).zero?
+        end
+
+        def create_process(command, stdin, stdout, stderror)
+          params = [
+            'L', # IN LPCSTR lpApplicationName
+            'P', # IN LPSTR lpCommandLine
+            'L', # IN LPSECURITY_ATTRIBUTES lpProcessAttributes
+            'L', # IN LPSECURITY_ATTRIBUTES lpThreadAttributes
+            'L', # IN BOOL bInheritHandles
+            'L', # IN DWORD dwCreationFlags
+            'L', # IN LPVOID lpEnvironment
+            'L', # IN LPCSTR lpCurrentDirectory
+            'P', # IN LPSTARTUPINFOA lpStartupInfo
+            'P']  # OUT LPPROCESS_INFORMATION lpProcessInformation
+
+          startupInfo = [STARTUP_INFO_SIZE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW, 0,
+            0, 0, stdin, stdout, stderror].pack('IIIIIIIIIIIISSIIII')
+
+          processInfo = [0, 0, 0, 0].pack('IIII')
+          command << 0
+
+          createProcess = Cosmos::Win32API.new("kernel32", "CreateProcess", params, 'I')
+          cp_args = [ 0, command, 0, 0, 1, 0, 0, 0, startupInfo, processInfo ]
+          raise_last_win_32_error if createProcess.call(*cp_args).zero?
+
+          hProcess, hThread,
+          dwProcessId, dwThreadId = processInfo.unpack('LLLL')
+
+          close_handle(hProcess)
+          close_handle(hThread)
+
+          [dwProcessId, dwThreadId]
+        end
+
+        def write_file(hFile, buffer)
+          params = [
+            'L', # handle to file to write to
+            'P', # pointer to data to write to file
+            'L', # number of bytes to write
+            'P', # pointer to number of bytes written
+            'L'] # pointer to structure for overlapped I/O
+
+          written = [0].pack('I')
+          writeFile = Cosmos::Win32API.new("kernel32", "WriteFile", params, 'I')
+
+          raise_last_win_32_error if writeFile.call(hFile, buffer, buffer.size,
+                                                     written, 0).zero?
+
+          written.unpack('I')[0]
+        end
+
+        def read_file(hFile)
+          params = [
+            'L', # handle of file to read
+            'P', # pointer to buffer that receives data
+            'L', # number of bytes to read
+            'P', # pointer to number of bytes read
+            'L'] #pointer to structure for data
+
+          number = [0].pack('I')
+          buffer = ' ' * 255
+
+          readFile = Cosmos::Win32API.new("kernel32", "ReadFile", params, 'I')
+          return '' if readFile.call(hFile, buffer, 255, number, 0).zero?
+
+          buffer[0...number.unpack('I')[0]]
+        end
+
+        def peek_named_pipe(hFile)
+          params = [
+            'L', # handle to pipe to copy from
+            'L', # pointer to data buffer
+            'L', # size, in bytes, of data buffer
+            'L', # pointer to number of bytes read
+            'P', # pointer to total number of bytes available
+            'L'] # pointer to unread bytes in this message
+
+          available = [0].pack('I')
+          peekNamedPipe = Cosmos::Win32API.new("kernel32", "PeekNamedPipe", params, 'I')
+
+          return -1 if peekNamedPipe.Call(hFile, 0, 0, 0, available, 0).zero?
+
+          available.unpack('I')[0]
+        end
+      end
+
+      class Win32popenIO
+        def initialize (hRead, hWrite, hError)
+          @hRead  = hRead
+          @hWrite = hWrite
+          @hError = hError
+        end
+
+        def write data
+          Win32Process::write_file(@hWrite, data.to_s)
+        end
+
+        def read
+          sleep(0.01) while Win32Process::peek_named_pipe(@hRead).zero?
+          Win32Process::read_file(@hRead)
+        end
+
+        def read_all
+          all = ''
+          until (buffer = read).empty?
+            all << buffer
+          end
+          all
+        end
+
+        def read_err
+          sleep(0.01) while Win32Process::peek_named_pipe(@hError).zero?
+          Win32Process::read_file(@hError)
+        end
+
+        def read_all_err
+          all = ''
+          until (buffer = read_err).empty?
+            all << buffer
+          end
+          all
+        end
+      end
+
+      # The only useful public method in this class - receives a command line,
+      # and returns the output content and error content as a pair of strings.
+      # No shell expansion is carried out on the command line string.
+      #
+      # Usage:
+      # output, errors = QDA::Filters::Win32Process::backtick('dir')
+      def self.backtick(command)
+        # create 3 pipes
+        child_in_r, child_in_w = create_pipe
+        child_out_r, child_out_w = create_pipe
+        child_error_r, child_error_w = create_pipe
+
+        # Ensure the write handle to the pipe for STDIN is not inherited.
+        set_handle_information(child_in_w, HANDLE_FLAG_INHERIT, 0)
+        set_handle_information(child_out_r, HANDLE_FLAG_INHERIT, 0)
+        set_handle_information(child_error_r, HANDLE_FLAG_INHERIT, 0)
+
+        create_process(command,
+                              child_in_r,
+                              child_out_w,
+                              child_error_w)
+        # we have to close the handles, so the pipes terminate with the process
+        close_handle(child_in_r)
+        close_handle(child_out_w)
+        close_handle(child_error_w)
+        close_handle(child_in_w)
+        io = Win32popenIO.new(child_out_r, child_in_w, child_error_r)
+
+        out = io.read_all().gsub(/\r/, '')
+        err = io.read_all_err().gsub(/\r/, '')
+        return out, err
+      end
+    end # module Win32Process
+  end #module Filters
+end # module QDA