cosmos 3.0.0

data/lib/cosmos/io/win32_serial_driver.rb

@@ -0,0 +1,147 @@
+# 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'
+require 'timeout' # For Timeout::Error
+
+module Cosmos
+
+  # Serial driver for use on Windows serial ports
+  class Win32SerialDriver
+
+    # (see SerialDriver#initialize)
+    def initialize(port_name = 'COM1',
+                   baud_rate = 9600,
+                   parity = :NONE,
+                   stop_bits = 1,
+                   write_timeout = 10.0,
+                   read_timeout = nil,
+                   read_polling_period = 0.01,
+                   read_max_length = 1000)
+
+      # Verify Parameters
+      port_name = '\\\\.\\' + port_name if port_name =~ /^COM[0-9]{2,3}$/
+
+      raise(ArgumentError, "Invalid baud rate: #{baud_rate}") unless Win32::BAUD_RATES.include?(baud_rate)
+
+      raise(ArgumentError, "Invalid parity: #{parity}") if parity and !SerialDriver::VALID_PARITY.include?(parity)
+      case parity
+      when SerialDriver::ODD
+        parity = Win32::ODDPARITY
+      when SerialDriver::EVEN
+        parity = Win32::EVENPARITY
+      when SerialDriver::NONE
+        parity = Win32::NOPARITY
+      end
+
+      raise(ArgumentError, "Invalid stop bits: #{stop_bits}") unless [1,2].include?(stop_bits)
+      if stop_bits == 1
+        stop_bits = Win32::ONESTOPBIT
+      else
+        stop_bits = Win32::TWOSTOPBITS
+      end
+
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+      @read_polling_period = read_polling_period
+      @read_max_length = read_max_length
+
+      # Open the Comm Port
+      @handle = Win32.create_file(port_name,
+                                  Win32::GENERIC_READ | Win32::GENERIC_WRITE,
+                                  0,
+                                  Win32::NULL,
+                                  Win32::OPEN_EXISTING,
+                                  Win32::FILE_ATTRIBUTE_NORMAL)
+
+      # Configure the Comm Port
+      dcb = Win32.get_comm_state(@handle)
+      dcb.write('BaudRate', baud_rate)
+      dcb.write('ByteSize', 8)
+      dcb.write('Parity',   parity)
+      dcb.write('StopBits', stop_bits)
+      Win32.set_comm_state(@handle, dcb)
+
+      # Configure Timeouts
+      Win32.set_comm_timeouts(@handle, 4294967295, 0, 0, 0, 0)
+    end
+
+    # (see SerialDriver#close)
+    def close
+      if @handle
+        # Close the Comm Port
+        Win32.close_handle(@handle)
+        @handle = nil
+      end
+    end
+
+    # (see SerialDriver#closed?)
+    def closed?
+      if @handle
+        false
+      else
+        true
+      end
+    end
+
+    # (see SerialDriver#write)
+    def write(data)
+      # Write the data
+      time = Time.now
+      bytes_to_write = data.length
+      while (bytes_to_write > 0)
+        bytes_written = Win32.write_file(@handle, data, data.length)
+        raise "Error writing to comm port" if bytes_written <= 0
+        bytes_to_write -= bytes_written
+        data = data[bytes_written..-1]
+        raise Timeout::Error, "Write Timeout" if @write_timeout and (Time.now - time > @write_timeout) and bytes_to_write > 0
+      end
+    end
+
+    # (see SerialDriver#read)
+    def read
+      data = ''
+      sleep_time = 0.0
+
+      loop do
+        loop do
+          # Read 1 byte
+          buffer = Win32.read_file(@handle, 1)
+          data << buffer
+          break if buffer.length <= 0 or data.length >= @read_max_length
+        end
+        break if data.length > 0
+        if @read_timeout and sleep_time >= @read_timeout
+          raise Timeout::Error, "Read Timeout"
+        end
+        sleep(@read_polling_period)
+        sleep_time += @read_polling_period
+      end
+
+      data
+    end
+
+    # (see SerialDriver#read_nonblock)
+    def read_nonblock
+      data = ''
+
+      loop do
+        # Read 1 byte
+        buffer = Win32.read_file(@handle, 1)
+        data << buffer
+        break if buffer.length <= 0 or data.length >= @read_max_length
+      end
+
+      data
+    end
+
+  end # class Win32SerialDriver
+
+end # module Cosmos

data/lib/cosmos/packet_logs/meta_packet_log_writer.rb

@@ -0,0 +1,107 @@
+# 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
+
+# Usage Notes:
+# The metadata packet must exist with exactly the same fields as both a command and as a telemetry packet
+# The new_packet_log_conversion.rb WRITE_CONVERSION should be placed on at least one item in the meta packets
+
+require 'cosmos/packet_logs/packet_log_writer'
+
+module Cosmos
+
+  # Writes a given packet at the beginning of each telemetry packet log file
+  class MetaPacketLogWriter < PacketLogWriter
+
+    # See PacketLogWriter#initialize
+    # @param target_name [String] Target name of the metadata packet
+    # @param packet_name [String] Packet name of the metadata packet
+    # @param meta_default_filename [String] Filename containing key/value pairs for default meta packet values
+    # @param log_meta_packet [Boolean] true to log the metadata packet if received during logging.  false to only
+    #   log metadata packets at the beginning of the log.
+    # @param use_tlm_packet [Boolean] true to put the data from the telemetry packet into
+    #   each log.  false to put the data from the command packet.
+    def initialize(
+      log_type,
+      target_name = nil,
+      packet_name = nil,
+      meta_default_filename = nil,
+      log_meta_packet = false,
+      use_tlm_packet = true,
+      log_name = nil,
+      logging_enabled = true,
+      cycle_time = nil,
+      cycle_size = 2000000000,
+      log_directory = nil,
+      asynchronous = false
+    )
+      @target_name = ConfigParser.handle_nil(target_name)
+      @packet_name = ConfigParser.handle_nil(packet_name)
+      @packet = nil
+      @log_meta_packet = ConfigParser.handle_true_false(log_meta_packet)
+      @meta_default_filename = ConfigParser.handle_nil(meta_default_filename)
+      @use_tlm_packet = ConfigParser.handle_true_false(use_tlm_packet)
+
+      # Make sure the packet exists in both commands and telemetry (if given)
+      if @target_name and @packet_name
+        packet = System.telemetry.packet(@target_name, @packet_name)
+        @packet = packet if @use_tlm_packet
+        packet = System.commands.packet(@target_name, @packet_name)
+        @packet = packet if !@use_tlm_packet
+      end
+
+      # Initialize the meta packet (if given)
+      if @meta_default_filename and @packet
+        parser = ConfigParser.new
+        Cosmos.set_working_dir do
+          parser.parse_file(@meta_default_filename) do |keyword, params|
+            begin
+            item = @packet.get_item(keyword)
+            if item.data_type == :STRING or item.data_type == :BLOCK
+              value = params[0]
+            else
+              value = params[0].convert_to_value
+            end
+            @packet.write(keyword, value)
+            rescue => err
+              raise parser.error(err, "ITEM_NAME VALUE")
+            end
+          end
+        end
+      end
+
+      super(log_type, log_name, logging_enabled, cycle_time, cycle_size, log_directory, asynchronous)
+    end
+
+    # Optionally doesn't write the meta packet
+    def write(packet)
+      if @log_meta_packet or !(packet.target_name == @target_name and packet.packet_name == @packet_name)
+        super(packet)
+      end
+    end
+
+    protected
+
+    # Adds the meta packet at the beginning of telemetry packet logs
+    # Mutex is held during this hook
+    def start_new_file_hook
+      if @target_name and @packet_name
+        if @use_tlm_packet
+          packet = System.telemetry.packet(@target_name, @packet_name)
+        else
+          packet = System.commands.packet(@target_name, @packet_name)
+        end
+        # Don't take the mutex because it is already held
+        write_packet(packet, false)
+      end
+    end
+
+  end # class MetaPacketLogWriter
+
+end # module Cosmos

data/lib/cosmos/packet_logs/packet_log_reader.rb

@@ -0,0 +1,439 @@
+# 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/core_ext/io'
+require 'cosmos/packets/packet'
+require 'cosmos/io/buffered_file'
+
+module Cosmos
+
+  # Reads a packet log of either commands or telemetry.
+  class PacketLogReader
+    attr_reader :log_type
+    attr_reader :configuration_name
+    attr_reader :hostname
+
+    # COSMOS 2.0 log file header definition
+    COSMOS2_MARKER = 'COSMOS2_'
+    COSMOS2_HEADER_LENGTH = 128
+    COSMOS2_MARKER_RANGE = 0..7
+    COSMOS2_LOG_TYPE_RANGE = 8..10
+    COSMOS2_CONFIGURATION_NAME_RANGE = 12..43
+    COSMOS2_HOSTNAME_RANGE = 45..127
+
+    # COSMOS 1.0 log file header definition
+    COSMOS1_MARKER = 'COSMOS'
+    COSMOS1_HEADER_LENGTH = 42
+    COSMOS1_MARKER_RANGE = 0..5
+    COSMOS1_LOG_TYPE_RANGE = 6..8
+    COSMOS1_CONFIGURATION_NAME_RANGE = 10..41
+
+    # Create a new log file reader
+    def initialize
+      reset()
+    end
+
+    # Yields back each packet as it is found in the log file.
+    #
+    # @param filename [String] The log file to read
+    # @param identify_and_define [Boolean] Once the packet has been read from
+    #   the log file, whether to both identify the packet by setting the target
+    #   and packet name, and define the packet by populating all the items.
+    # @param start_time [Time|nil] Time at which to start returning packets.
+    #   Packets found with a timestamp before this time are ignored. Pass nil
+    #   to return all packets.
+    # @param end_time [Time|nil] Time at which to stop returning packets.
+    #   Packets found with a timestamp after this time are ignored. Pass nil
+    #   to return all packets.
+    # @yieldparam packet [Packet]
+    def each(filename, identify_and_define = true, start_time = nil, end_time = nil)
+      open(filename)
+
+      seek_to_time(start_time) if start_time
+
+      while true
+        packet = read(identify_and_define)
+        break unless packet
+
+        received_time = packet.received_time
+        if received_time
+          next if start_time and received_time < start_time
+          break if end_time and received_time > end_time
+        end
+
+        yield packet
+      end
+    ensure
+      close()
+    end
+
+    # Returns an analysis of the log file by reading all the packets and
+    # returning information about each packet. This information maps directly
+    # to the parameters need by the {#read_at_offset} method and thus should be
+    # called before using {#read_at_offset}.
+    #
+    # @param filename [String] The filename to analyze
+    # @param progress_callback [Proc] Callback that should receive a single
+    #   floating point parameter which is the percentage done
+    # @return [Array<Array<Integer, Integer, String, String, Time, Time>] Array
+    #   of arrays for each packet found in the log file consisting of:
+    #   [File position, length, target name, packet name, time formatted,
+    #   received time].
+    def packet_offsets(filename, progress_callback = nil)
+      open(filename)
+      offsets = []
+      filesize = size().to_f
+
+      while true
+        current_pos = @file.pos
+        packet = read(false)
+        break unless packet
+        offsets << current_pos
+        progress_callback.call(current_pos / filesize) if progress_callback
+      end
+
+      return offsets
+    ensure
+      close()
+    end
+
+    # @param filename [String] The log filename to open
+    def open(filename)
+      close()
+      reset()
+      @filename = filename
+      @file = BufferedFile.open(@filename, 'rb')
+      @bytes_read = 0
+      read_file_header()
+    rescue => err
+      close()
+      raise err
+    end
+
+    # Closes the current log file
+    def close
+      @file.close if @file and !@file.closed?
+    end
+
+    # Read a packet from the log file
+    #
+    # @param identify_and_define (see #each)
+    # @return [Packet]
+    def read(identify_and_define = true)
+      # Read the Packet Header
+      success, target_name, packet_name, received_time = read_entry_header()
+      return nil unless success
+
+      # Read Packet Data
+      packet_data = @file.read_length_bytes(4)
+      return nil unless packet_data and packet_data.length > 0
+
+      if identify_and_define
+        packet = identify_and_define_packet_data(target_name, packet_name, received_time, packet_data)
+      else
+        # Build Packet
+        packet = Packet.new(target_name, packet_name, :BIG_ENDIAN, nil, packet_data)
+        packet.set_received_time_fast(received_time)
+      end
+
+      packet
+    rescue => err
+      close()
+      raise err
+    end
+
+    # Reads a packet from the opened log file. Should only be used in
+    # conjunction with {#packet_offsets}.
+    #
+    # @param file_offset [Integer] Byte offset into the log file to start
+    #   reading
+    # @param identify_and_define (see #each)
+    # @return [Packet]
+    def read_at_offset(file_offset, identify_and_define = true)
+      @file.seek(file_offset, IO::SEEK_SET)
+      return read(identify_and_define)
+    rescue => err
+      close()
+      raise err
+    end
+
+    # Read the first packet from the log file and reset the file position back
+    # to the current position. This allows the client to call read multiple
+    # times to return packets, call first, and continue calling read which will
+    # return the next packet in the file.
+    #
+    # @return [Packet]
+    def first
+      original_position = @file.pos
+      @file.seek(0, IO::SEEK_SET)
+      read_file_header()
+      packet = read()
+      raise "No first packet found" unless packet
+      @file.seek(original_position, IO::SEEK_SET)
+      packet.clone
+    rescue => err
+      close()
+      raise err
+    end
+
+    # Read the last packet from the log file and reset the file position back
+    # to the current position. This allows the client to call read multiple
+    # times to return packets, call last, and continue calling read which will
+    # return the next packet in the file.
+    #
+    # @return [Packet]
+    def last
+      original_position = @file.pos
+      @file.seek(-1, IO::SEEK_END)
+      packet = search(-1)
+      raise "No last packet found" unless packet
+      @file.seek(original_position, IO::SEEK_SET)
+      packet.clone
+    rescue => err
+      close()
+      raise err
+    end
+
+    # @return [Integer] The size of the log file being processed
+    def size
+      @file.stat.size
+    end
+
+    # @return [Integer] The current file position in the log file
+    def bytes_read
+      @file.pos
+    end
+
+    protected
+
+    def reset
+      @file = nil
+      @filename = nil
+      @log_type = :TLM
+      @configuration_name = nil
+      @hostname = nil
+      @file_header_length = COSMOS2_HEADER_LENGTH
+    end
+
+    # This is best effort. May return unidentified/undefined packets
+    def identify_and_define_packet_data(target_name, packet_name, received_time, packet_data)
+      packet = nil
+      unless (target_name and packet_name)
+        if @log_type == :TLM
+          packet = System.telemetry.identify!(packet_data)
+        else
+          packet = System.commands.identify(packet_data)
+        end
+        packet.set_received_time_fast(received_time) if packet
+      else
+        begin
+          if @log_type == :TLM
+            packet = System.telemetry.packet(target_name, packet_name)
+          else
+            packet = System.commands.packet(target_name, packet_name)
+          end
+          packet.buffer = packet_data
+          packet.set_received_time_fast(received_time)
+        rescue
+          # Could not find a definition for this packet
+          Logger.instance.error "Unknown packet #{target_name} #{packet_name}"
+          packet = Packet.new(target_name, packet_name, :BIG_ENDIAN, nil, packet_data)
+          packet.set_received_time_fast(received_time)
+        end
+      end
+      packet
+    end
+
+    def read_file_header
+      header = @file.read(COSMOS2_HEADER_LENGTH)
+      if header and header.length == COSMOS2_HEADER_LENGTH
+        if header[COSMOS2_MARKER_RANGE] == COSMOS2_MARKER
+          # Found COSMOS 2 File Header
+          @log_type = header[COSMOS2_LOG_TYPE_RANGE].intern
+          @configuration_name = header[COSMOS2_CONFIGURATION_NAME_RANGE]
+          @hostname = header[COSMOS2_HOSTNAME_RANGE].strip
+          @file_header_length = COSMOS2_HEADER_LENGTH
+          System.load_configuration(@configuration_name)
+        elsif header[COSMOS1_MARKER_RANGE] == COSMOS1_MARKER
+          # Found COSMOS 1 File Header
+          @log_type = header[COSMOS1_LOG_TYPE_RANGE].upcase.intern
+          @configuration_name = header[COSMOS1_CONFIGURATION_NAME_RANGE]
+          @hostname = nil
+          @file_header_length = COSMOS1_HEADER_LENGTH
+          # Move back to beginning of first packet
+          @file.seek(COSMOS1_HEADER_LENGTH, IO::SEEK_SET)
+          System.load_configuration(@configuration_name)
+        else
+          raise "COSMOS file header not found on packet log"
+        end
+        raise "Unknown log type #{@log_type}" unless [:CMD, :TLM].include? @log_type
+      else
+        raise "Failed to read at least #{COSMOS2_HEADER_LENGTH} bytes from packet log"
+      end
+    end
+
+    def read_entry_header
+      # Read Received Time
+      time_seconds = @file.read(4)
+      return [nil, nil, nil, nil] if time_seconds.nil? or time_seconds.length != 4
+      time_seconds = time_seconds.unpack('N')[0]
+      time_microseconds = @file.read(4)
+      return [nil, nil, nil, nil] if time_microseconds.nil? or time_microseconds.length != 4
+      time_microseconds = time_microseconds.unpack('N')[0]
+      received_time = Time.at(time_seconds, time_microseconds)
+
+      # Read Target Name
+      target_name = @file.read_length_bytes(1)
+      return [nil, nil, nil, nil] unless target_name and target_name.length > 0
+
+      # Read Packet Name
+      packet_name = @file.read_length_bytes(1)
+      return [nil, nil, nil, nil] unless packet_name and packet_name.length > 0
+
+      return [true, target_name, packet_name, received_time]
+    end
+
+    def test
+      found = false
+
+      # Save original position
+      original_position = @file.pos
+
+      begin
+        # Try to read the packet header
+        # This will fail with file read errors and invalid timestamps
+        success, target_name, packet_name, _ = read_entry_header()
+        if success
+          if target_name !~ File::NON_ASCII_PRINTABLE and packet_name !~ File::NON_ASCII_PRINTABLE
+            packet_data_length = @file.read(4)
+            if packet_data_length.length == 4 and packet_data_length.unpack('N')[0] > 0
+              if @log_type == :TLM
+                if System.telemetry.packet(target_name, packet_name)
+                  found = true
+                end
+              else
+                if System.commands.packet(target_name, packet_name)
+                  found = true
+                end
+              end
+            end
+          end
+        end
+      rescue
+        # Packet not found
+      end
+
+      # Return to the original position
+      @file.seek(original_position, IO::SEEK_SET)
+
+      # Indicate if a packet was found
+      found
+    end
+
+    # Searchs for the nearest packet to the current io position
+    # Returns the packet if found, and leaves the io position
+    # either before or after the packet found
+    def search(offset_increment, leave_position = :AFTER)
+      position = @file.pos
+      @file.seek(0, IO::SEEK_END)
+      size = @file.pos
+      @file.seek(position, IO::SEEK_SET)
+
+      while (@file.pos > 0 and @file.pos < size)
+        if test()
+          # Save position
+          position = @file.pos
+
+          packet = read()
+
+          if packet
+            if leave_position != :AFTER
+              # Restore position
+              @file.seek(position, IO::SEEK_SET)
+            end
+
+            return packet
+          end
+
+          # Restore position
+          @file.seek(position, IO::SEEK_SET)
+        end
+        @file.seek(offset_increment, IO::SEEK_CUR)
+      end
+
+      # Return nil if we search beyond the size of the file
+      nil
+    end
+
+    def seek_to_time(time)
+      if time
+        position = @file.pos
+
+        begin
+          # Read the first packet in the log
+          first_packet = first()
+          raise "Error reading first packet" unless first
+          raise "First Packet does not contain a packet received time" unless first_packet.received_time
+
+          # Read the last packet in the log
+          file_size = size()
+          last_packet = last()
+          raise "Search failed looking for last packet" unless last_packet
+          raise "Last Packet does not contain a packet received time" unless last_packet.received_time
+
+          if time >= first_packet.received_time and time <= last_packet.received_time
+            # Guess at where to start looking for time in log
+            percentage = (time - first_packet.received_time) / (last_packet.received_time - first_packet.received_time)
+            offset = (percentage * file_size.to_f).to_i
+            offset = @file_header_length if offset < @file_header_length
+            @file.seek(offset, IO::SEEK_SET)
+
+            # Move backwards until a packet before the time is found
+            while true
+              packet = search(-1, :BEFORE)
+              break if !packet or packet.received_time <= time
+
+              # Guess again
+              percentage = 1.0 - ((packet.received_time - time) / (packet.received_time - first_packet.received_time))
+              offset = (percentage * @file.pos.to_f).to_i
+              offset = @file_header_length if offset < @file_header_length
+              @file.seek(offset, IO::SEEK_SET)
+            end
+
+            # Move forwards until a packet equal to or after the time is found
+            while true
+              position = @file.pos
+              packet = read(false)
+              raise "Search failed looking for packet after time" unless packet
+              if packet.received_time >= time
+                # Back up this packet so the read can get it because we want it
+                @file.seek(position, IO::SEEK_SET)
+                break
+              end
+            end
+
+          else
+            if time > last_packet.received_time
+              # File is entirely before time, so jump to the end
+              @file.seek(0, IO::SEEK_END)
+            else
+              raise "File does not include time"
+            end
+          end
+        rescue # Optimized search failed or not supported
+          # Restore position
+          @file.seek(position, IO::SEEK_SET)
+        end
+      end
+    end
+
+  end # class PacketLogReader
+
+end # module Cosmos