cosmos 3.0.1 → 3.1.0

data/lib/cosmos/io/posix_serial_driver.rb

@@ -1,145 +1,145 @@
-# 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 'fcntl'
-require 'termios' # Requires ruby-termios gem
-require 'timeout' # For Timeout::Error
-
-module Cosmos
-
-  # Serial driver for use on Posix serial ports found on UNIX based systems
-  class PosixSerialDriver
-
-    # (see SerialDriver#initialize)
-    def initialize(port_name = '/dev/ttyS0',
-                   baud_rate = 9600,
-                   parity = :NONE,
-                   stop_bits = 1,
-                   write_timeout = 10.0,
-                   read_timeout = nil)
-
-      # Convert Baud Rate into Termios constant
-      begin
-        baud_rate = Object.const_get("Termios::B#{baud_rate}")
-      rescue NameError
-        raise(ArgumentError, "Invalid Baud Rate, Not Defined by Termios: #{baud_rate}")
-      end
-
-      # Verify Parameters
-      raise(ArgumentError, "Invalid parity: #{parity}") if parity and !SerialDriver::VALID_PARITY.include?(parity)
-      raise(ArgumentError, "Invalid Stop Bits: #{stop_bits}") unless [1,2].include?(stop_bits)
-      @write_timeout = write_timeout
-      @read_timeout = read_timeout
-
-      parity = nil if parity == :NONE
-
-      # Open the serial Port
-      @handle = Kernel.open(port_name, File::RDWR | File::NONBLOCK)
-      flags = @handle.fcntl(Fcntl::F_GETFL, 0)
-      @handle.fcntl(Fcntl::F_SETFL, flags & ~File::NONBLOCK)
-      @handle.extend Termios
-
-      # Configure the serial Port
-      tio = Termios::new_termios()
-      iflags = 0
-      iflags |= Termios::IGNPAR unless parity
-      cflags = 0
-      cflags |= Termios::CREAD # Enable receiver
-      cflags |= Termios::CS8 # 8-bit bytes
-      cflags |= Termios::CLOCAL # Ignore Modem Control Lines
-      cflags |= Termios::CSTOPB if stop_bits == 2
-      cflags |= Termios::PARENB if parity
-      cflags |= Termios::PADODD if parity == :ODD
-      tio.iflag = iflags
-      tio.oflag = 0
-      tio.cflag = cflags
-      tio.lflag = 0
-      tio.cc[Termios::VTIME] = 0
-      tio.cc[Termios::VMIN] = 1
-      tio.ispeed = baud_rate
-      tio.ospeed = baud_rate
-      @handle.tcflush(Termios::TCIOFLUSH)
-      @handle.tcsetattr(Termios::TCSANOW, tio)
-    end
-
-    # (see SerialDriver#close)
-    def close
-      if @handle
-        # Close the serial Port
-        @handle.close
-        @handle = nil
-      end
-    end
-
-    # (see SerialDriver#closed?)
-    def closed?
-      if @handle
-        false
-      else
-        true
-      end
-    end
-
-    # (see SerialDriver#write)
-    def write(data)
-      num_bytes_to_send = data.length
-      total_bytes_sent = 0
-      bytes_sent = 0
-      data_to_send = data
-
-      loop do
-        begin
-          bytes_sent = @handle.write_nonblock(data_to_send)
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-          result = IO.fast_select(nil, [@handle], nil, @write_timeout)
-          if result
-            retry
-          else
-            raise Timeout::Error, "Write Timeout"
-          end
-        end
-        total_bytes_sent += bytes_sent
-        break if total_bytes_sent >= num_bytes_to_send
-        data_to_send = data[total_bytes_sent..-1]
-      end
-    end
-
-    # (see SerialDriver#read)
-    def read
-      begin
-        data = @handle.read_nonblock(65535)
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-        result = IO.fast_select([@handle], nil, nil, @read_timeout)
-        if result
-          retry
-        else
-          raise Timeout::Error, "Read Timeout"
-        end
-      end
-
-      data
-    end
-
-    # (see SerialDriver#read_nonblock)
-    def read_nonblock
-      data = ''
-
-      begin
-        data = @handle.read_nonblock(65535)
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-        # Do Nothing
-      end
-
-      data
-    end
-
-  end # class PosixSerialDriver
-
-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 'fcntl'
+require 'termios' # Requires ruby-termios gem
+require 'timeout' # For Timeout::Error
+
+module Cosmos
+
+  # Serial driver for use on Posix serial ports found on UNIX based systems
+  class PosixSerialDriver
+
+    # (see SerialDriver#initialize)
+    def initialize(port_name = '/dev/ttyS0',
+                   baud_rate = 9600,
+                   parity = :NONE,
+                   stop_bits = 1,
+                   write_timeout = 10.0,
+                   read_timeout = nil)
+
+      # Convert Baud Rate into Termios constant
+      begin
+        baud_rate = Object.const_get("Termios::B#{baud_rate}")
+      rescue NameError
+        raise(ArgumentError, "Invalid Baud Rate, Not Defined by Termios: #{baud_rate}")
+      end
+
+      # Verify Parameters
+      raise(ArgumentError, "Invalid parity: #{parity}") if parity and !SerialDriver::VALID_PARITY.include?(parity)
+      raise(ArgumentError, "Invalid Stop Bits: #{stop_bits}") unless [1,2].include?(stop_bits)
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+
+      parity = nil if parity == :NONE
+
+      # Open the serial Port
+      @handle = Kernel.open(port_name, File::RDWR | File::NONBLOCK)
+      flags = @handle.fcntl(Fcntl::F_GETFL, 0)
+      @handle.fcntl(Fcntl::F_SETFL, flags & ~File::NONBLOCK)
+      @handle.extend Termios
+
+      # Configure the serial Port
+      tio = Termios::new_termios()
+      iflags = 0
+      iflags |= Termios::IGNPAR unless parity
+      cflags = 0
+      cflags |= Termios::CREAD # Enable receiver
+      cflags |= Termios::CS8 # 8-bit bytes
+      cflags |= Termios::CLOCAL # Ignore Modem Control Lines
+      cflags |= Termios::CSTOPB if stop_bits == 2
+      cflags |= Termios::PARENB if parity
+      cflags |= Termios::PADODD if parity == :ODD
+      tio.iflag = iflags
+      tio.oflag = 0
+      tio.cflag = cflags
+      tio.lflag = 0
+      tio.cc[Termios::VTIME] = 0
+      tio.cc[Termios::VMIN] = 1
+      tio.ispeed = baud_rate
+      tio.ospeed = baud_rate
+      @handle.tcflush(Termios::TCIOFLUSH)
+      @handle.tcsetattr(Termios::TCSANOW, tio)
+    end
+
+    # (see SerialDriver#close)
+    def close
+      if @handle
+        # Close the serial Port
+        @handle.close
+        @handle = nil
+      end
+    end
+
+    # (see SerialDriver#closed?)
+    def closed?
+      if @handle
+        false
+      else
+        true
+      end
+    end
+
+    # (see SerialDriver#write)
+    def write(data)
+      num_bytes_to_send = data.length
+      total_bytes_sent = 0
+      bytes_sent = 0
+      data_to_send = data
+
+      loop do
+        begin
+          bytes_sent = @handle.write_nonblock(data_to_send)
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          result = IO.fast_select(nil, [@handle], nil, @write_timeout)
+          if result
+            retry
+          else
+            raise Timeout::Error, "Write Timeout"
+          end
+        end
+        total_bytes_sent += bytes_sent
+        break if total_bytes_sent >= num_bytes_to_send
+        data_to_send = data[total_bytes_sent..-1]
+      end
+    end
+
+    # (see SerialDriver#read)
+    def read
+      begin
+        data = @handle.read_nonblock(65535)
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        result = IO.fast_select([@handle], nil, nil, @read_timeout)
+        if result
+          retry
+        else
+          raise Timeout::Error, "Read Timeout"
+        end
+      end
+
+      data
+    end
+
+    # (see SerialDriver#read_nonblock)
+    def read_nonblock
+      data = ''
+
+      begin
+        data = @handle.read_nonblock(65535)
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        # Do Nothing
+      end
+
+      data
+    end
+
+  end # class PosixSerialDriver
+
+end # module Cosmos

data/lib/cosmos/io/raw_logger.rb

@@ -1,174 +1,174 @@
-# 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 'thread'
-require 'socket' # For gethostname
-require 'cosmos/config/config_parser'
-
-module Cosmos
-
-  # Creates a log file of raw data for either reads or writes. Can automatically
-  # cycle the log based on when the log file reaches a predefined size.
-  class RawLogger
-
-    # @return [String] The filename of the log
-    attr_reader :filename
-
-    # @return [Queue] Queue for asynchronous logging
-    attr_reader :queue
-
-    # @return [Boolean] Is logging enabled?
-    attr_reader :logging_enabled
-
-    # @retuen [String] Original name passed to raw logger
-    attr_reader :orig_name
-
-    # The allowable log types
-    LOG_TYPES = [:READ, :WRITE]
-
-    # The cycle time interval. Cycle times are only checked at this level of
-    # granularity.
-    CYCLE_TIME_INTERVAL = 60
-
-    # @param log_name [String] The name of the raw logger.  Typically matches the
-    #    name of the corresponding interface
-    # @param log_type [Symbol] The type of log to create. Must be :READ
-    #   or :WRITE.
-    # @param cycle_time [Integer] The amount of time in seconds before creating
-    #   a new log file. This can be combined with cycle_size but is better used
-    #   independently.
-    # @param cycle_size [Integer] The size in bytes before creating a new log
-    #   file. This can be combined with cycle_time but is better used
-    #   independently.
-    # @param log_directory [String] The directory to store the log files.
-    #   Passing nil will use the system default 'LOGS' directory.
-    def initialize(
-      log_name,
-      log_type,
-      logging_enabled = false,
-      cycle_size = 2000000000,
-      log_directory = nil
-    )
-      raise "log_type must be :READ or :WRITE" unless LOG_TYPES.include? log_type
-      @log_type = log_type
-      @orig_name = log_name
-      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
-      @cycle_size = ConfigParser.handle_nil(cycle_size)
-      @cycle_size = Integer(@cycle_size) if @cycle_size
-      if ConfigParser.handle_nil(log_directory)
-        @log_directory = log_directory
-      else
-        @log_directory = nil
-      end
-      @mutex = Mutex.new
-      @file = nil
-      @filename = nil
-      @start_time = Time.now
-      @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
-    end
-
-    # Set the raw logger name
-    # @param name [String] new name
-    def name=(log_name)
-      @orig_name = log_name
-      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
-    end
-
-    # Write data to the log file.
-    #
-    # If no log file currently exists in the filesystem, a new file will be
-    # created.
-    #
-    # Writing a log file is a critical operation so the entire method is
-    # wrapped with a rescue and handled with handle_critical_exception
-    #
-    # @param data [String] The data to write to the log file
-    def write(data)
-      if @logging_enabled
-        return if !data or data.length <= 0
-        need_new_file = false
-        @mutex.synchronize do
-          if !@file or (@cycle_size and (@file.stat.size + data.length) > @cycle_size)
-            need_new_file = true
-          end
-        end
-        start_new_file() if need_new_file
-        @mutex.synchronize { @file.write(data) if @file }
-      end
-    rescue => err
-      Logger.instance.error "Error writing #{@filename} : #{err.formatted}"
-      Cosmos.handle_critical_exception(err)
-    end
-
-    # Starts a new log file by closing the existing log file. New log files are
-    # not created until data is written by {#write} so this does not
-    # immediately create a log file on the filesystem.
-    def start
-      close_file() unless ((Time.now - @start_time) < 1.0) # Prevent close/open too fast
-      @mutex.synchronize { @logging_enabled = true }
-    end
-
-    # Stops all logging and closes the current log file.
-    def stop
-      @mutex.synchronize { @logging_enabled = false }
-      close_file()
-    end
-
-    # Create a clone of this object with a new name
-    def clone
-      raw_logger = super()
-      raw_logger.name = raw_logger.orig_name
-      raw_logger
-    end
-
-    protected
-
-    # Starting a new log file is a critical operation so the entire method is
-    # wrapped with a rescue and handled with handle_critical_exception
-    def start_new_file
-      @log_directory ||= System.instance.paths['LOGS']
-      close_file()
-      @mutex.synchronize do
-        Cosmos.set_working_dir do
-          @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name], '.bin'))
-          @file = File.new(@filename, 'wb')
-        end
-        @start_time = Time.now
-        Logger.instance.info "Raw Log File Opened : #{@filename}"
-      end
-    rescue => err
-      Logger.instance.error "Error opening #{@filename} : #{err.formatted}"
-      @logging_enabled = false
-      Cosmos.handle_critical_exception(err)
-    end
-
-    # Closing a log file isn't critical so we just log an error
-    def close_file
-      @mutex.synchronize do
-        if @file
-          begin
-            @file.close unless @file.closed?
-            Cosmos.set_working_dir do
-              File.chmod(0444, @file.path) # Make file read only
-            end
-            Logger.instance.info "Raw Log File Closed : #{@filename}"
-          rescue => err
-            Logger.instance.error "Error closing #{@filename} : #{err.formatted}"
-          end
-
-          @file = nil
-          @filename = nil
-        end
-      end
-    end
-
-  end # class RawLogger
-
-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 'thread'
+require 'socket' # For gethostname
+require 'cosmos/config/config_parser'
+
+module Cosmos
+
+  # Creates a log file of raw data for either reads or writes. Can automatically
+  # cycle the log based on when the log file reaches a predefined size.
+  class RawLogger
+
+    # @return [String] The filename of the log
+    attr_reader :filename
+
+    # @return [Queue] Queue for asynchronous logging
+    attr_reader :queue
+
+    # @return [Boolean] Is logging enabled?
+    attr_reader :logging_enabled
+
+    # @retuen [String] Original name passed to raw logger
+    attr_reader :orig_name
+
+    # The allowable log types
+    LOG_TYPES = [:READ, :WRITE]
+
+    # The cycle time interval. Cycle times are only checked at this level of
+    # granularity.
+    CYCLE_TIME_INTERVAL = 60
+
+    # @param log_name [String] The name of the raw logger.  Typically matches the
+    #    name of the corresponding interface
+    # @param log_type [Symbol] The type of log to create. Must be :READ
+    #   or :WRITE.
+    # @param cycle_time [Integer] The amount of time in seconds before creating
+    #   a new log file. This can be combined with cycle_size but is better used
+    #   independently.
+    # @param cycle_size [Integer] The size in bytes before creating a new log
+    #   file. This can be combined with cycle_time but is better used
+    #   independently.
+    # @param log_directory [String] The directory to store the log files.
+    #   Passing nil will use the system default 'LOGS' directory.
+    def initialize(
+      log_name,
+      log_type,
+      logging_enabled = false,
+      cycle_size = 2000000000,
+      log_directory = nil
+    )
+      raise "log_type must be :READ or :WRITE" unless LOG_TYPES.include? log_type
+      @log_type = log_type
+      @orig_name = log_name
+      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
+      @cycle_size = ConfigParser.handle_nil(cycle_size)
+      @cycle_size = Integer(@cycle_size) if @cycle_size
+      if ConfigParser.handle_nil(log_directory)
+        @log_directory = log_directory
+      else
+        @log_directory = nil
+      end
+      @mutex = Mutex.new
+      @file = nil
+      @filename = nil
+      @start_time = Time.now
+      @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
+    end
+
+    # Set the raw logger name
+    # @param name [String] new name
+    def name=(log_name)
+      @orig_name = log_name
+      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
+    end
+
+    # Write data to the log file.
+    #
+    # If no log file currently exists in the filesystem, a new file will be
+    # created.
+    #
+    # Writing a log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    #
+    # @param data [String] The data to write to the log file
+    def write(data)
+      if @logging_enabled
+        return if !data or data.length <= 0
+        need_new_file = false
+        @mutex.synchronize do
+          if !@file or (@cycle_size and (@file.stat.size + data.length) > @cycle_size)
+            need_new_file = true
+          end
+        end
+        start_new_file() if need_new_file
+        @mutex.synchronize { @file.write(data) if @file }
+      end
+    rescue => err
+      Logger.instance.error "Error writing #{@filename} : #{err.formatted}"
+      Cosmos.handle_critical_exception(err)
+    end
+
+    # Starts a new log file by closing the existing log file. New log files are
+    # not created until data is written by {#write} so this does not
+    # immediately create a log file on the filesystem.
+    def start
+      close_file() unless ((Time.now - @start_time) < 1.0) # Prevent close/open too fast
+      @mutex.synchronize { @logging_enabled = true }
+    end
+
+    # Stops all logging and closes the current log file.
+    def stop
+      @mutex.synchronize { @logging_enabled = false }
+      close_file()
+    end
+
+    # Create a clone of this object with a new name
+    def clone
+      raw_logger = super()
+      raw_logger.name = raw_logger.orig_name
+      raw_logger
+    end
+
+    protected
+
+    # Starting a new log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    def start_new_file
+      @log_directory ||= System.instance.paths['LOGS']
+      close_file()
+      @mutex.synchronize do
+        Cosmos.set_working_dir do
+          @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name], '.bin'))
+          @file = File.new(@filename, 'wb')
+        end
+        @start_time = Time.now
+        Logger.instance.info "Raw Log File Opened : #{@filename}"
+      end
+    rescue => err
+      Logger.instance.error "Error opening #{@filename} : #{err.formatted}"
+      @logging_enabled = false
+      Cosmos.handle_critical_exception(err)
+    end
+
+    # Closing a log file isn't critical so we just log an error
+    def close_file
+      @mutex.synchronize do
+        if @file
+          begin
+            @file.close unless @file.closed?
+            Cosmos.set_working_dir do
+              File.chmod(0444, @file.path) # Make file read only
+            end
+            Logger.instance.info "Raw Log File Closed : #{@filename}"
+          rescue => err
+            Logger.instance.error "Error closing #{@filename} : #{err.formatted}"
+          end
+
+          @file = nil
+          @filename = nil
+        end
+      end
+    end
+
+  end # class RawLogger
+
+end # module Cosmos