cosmos 3.0.0

data/lib/cosmos/conversions/conversion.rb

@@ -0,0 +1,47 @@
+# 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
+
+  # Performs a general conversion via the implementation of the call method
+  class Conversion
+
+    # @return [Symbol] The converted data type. Must be one of
+    #   {Cosmos::StructureItem#data_type}
+    attr_reader :converted_type
+    # @return [Integer] The size in bits of the converted value
+    attr_reader :converted_bit_size
+
+    # Create a new conversion
+    def initialize
+      @converted_type = nil
+      @converted_bit_size = nil
+    end
+
+    # Perform the conversion on the value.
+    #
+    # @param value [Object] The value to convert
+    # @param packet [Packet] The packet which contains the value. This can
+    #   be useful to reach into the packet and use other values in the
+    #   conversion.
+    # @param buffer [String] The packet buffer
+    # @return The converted value
+    def call(value, packet, buffer)
+      raise "call method must be defined by subclass"
+    end
+
+    # @return [String] The conversion class
+    def to_s
+      self.class.to_s.split('::')[-1]
+    end
+
+  end # class Conversion
+
+end # module Cosmos

data/lib/cosmos/conversions/generic_conversion.rb

@@ -0,0 +1,55 @@
+# 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/conversions/conversion'
+require 'cosmos/packets/binary_accessor'
+
+module Cosmos
+
+  # Performs a generic conversion by evaluating Ruby code
+  class GenericConversion < Conversion
+
+    # @return [String] The Ruby code to evaluate which should return the
+    #   converted value
+    attr_accessor :code_to_eval
+
+    # @param code_to_eval [String] The Ruby code to evaluate which should
+    #   return the converted value
+    # @param converted_type [Symbol] The converted data type. Must be one of
+    #   {BinaryAccessor::DATA_TYPES}
+    # @param converted_bit_size [Integer] The size in bits of the converted
+    #   value
+    def initialize(code_to_eval, converted_type = nil, converted_bit_size = nil)
+      super()
+      @code_to_eval = code_to_eval
+      if ConfigParser.handle_nil(converted_type)
+        converted_type = converted_type.to_s.upcase.intern
+        raise "Invalid type #{converted_type}" unless BinaryAccessor::DATA_TYPES.include?(converted_type)
+        @converted_type = converted_type
+      end
+      @converted_bit_size = Integer(converted_bit_size) if ConfigParser.handle_nil(converted_bit_size)
+    end
+
+    # (see Cosmos::Conversion#call)
+    def call(value, packet, buffer)
+      myself = packet # For backwards compatibility
+      if true or myself # Remove unused variable warning for myself
+        return eval(@code_to_eval)
+      end
+    end
+
+    # @return [String] The conversion class followed by the code to evaluate
+    def to_s
+      "#{@code_to_eval}"
+    end
+
+  end # class GenericConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/new_packet_log_conversion.rb

@@ -0,0 +1,45 @@
+# 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/conversions/conversion'
+require 'cosmos/packet_logs'
+require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server'
+
+module Cosmos
+
+  # Creates new packet logs whenever it executes
+  class NewPacketLogConversion < Conversion
+
+    # Initializes converted_type to :FLOAT and converted_bit_size to 64
+    #
+    # @param packet_log_writer_name [String] Name of the packet log writer to start new logs on
+    def initialize(packet_log_writer_name = 'ALL')
+      @packet_log_writer_name = packet_log_writer_name
+    end
+
+    # @param (see Conversion#call)
+    # @return [Varies] The value given
+    def call(value, packet, buffer)
+      if CmdTlmServer.instance and CmdTlmServer.packet_logging
+        CmdTlmServer.instance.start_logging(@packet_log_writer_name)
+      end
+      value
+    end
+
+    # @return [String] The name of the class and the associated packet log writer name
+    def to_s
+      result = super()
+      result << " (#{@packet_log_writer_name})"
+      result
+    end
+
+  end # class NewPacketLogConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/polynomial_conversion.rb

@@ -0,0 +1,57 @@
+# 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/conversions/conversion'
+require 'cosmos/ext/polynomial_conversion'
+
+module Cosmos
+
+  # Performs a polynomial conversion on the value
+  class PolynomialConversion < Conversion
+
+    # @return [Array<Float>] The polynomial coefficients
+    attr_accessor :coeffs
+
+    # Initializes the conversion with the given polynomial coefficients. Sets
+    # the converted_type to :FLOAT and the converted_bit_size to 64.
+    #
+    # @param coeff_array [Array<Float>] The polynomial coefficients
+    def initialize(coeff_array)
+      super()
+      @coeffs = []
+      coeff_array.each do |coeff|
+        @coeffs << coeff.to_f
+      end
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] The value with the polynomial applied
+    # def call(value, myself, buffer)
+
+    # @return [String] Class followed by the list of coefficients
+    def to_s
+      result = ""
+      @coeffs.length.times do |index|
+        if index == 0
+          result << "#{@coeffs[index]}"
+        elsif index == 1
+          result << " + #{@coeffs[index]}x"
+        else
+          result << " + #{@coeffs[index]}x^#{index}"
+        end
+      end
+      result
+    end
+
+  end # class PolynomialConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/processor_conversion.rb

@@ -0,0 +1,46 @@
+# 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/conversions/conversion'
+
+module Cosmos
+
+  # Retrieves the result from an item processor
+  class ProcessorConversion < Conversion
+
+    # @param processor_name [String] The name of the associated processor
+    # @param result_name [String] The name of the associated result in the processor
+    # @param converted_type [String or nil] The datatype of the result of the processor
+    # @param converted_bit_size [Integer or nil] The bit size of the result of the processor
+    def initialize(processor_name, result_name, converted_type = nil, converted_bit_size = nil)
+      super()
+      @processor_name = processor_name.to_s.upcase
+      @result_name = result_name.to_s.upcase.intern
+      if ConfigParser.handle_nil(converted_type)
+        @converted_type = converted_type.to_s.upcase.intern
+        raise ArgumentError, "Unknown converted type: #{converted_type}" if !BinaryAccessor::DATA_TYPES.include?(@converted_type)
+      end
+      @converted_bit_size = Integer(converted_bit_size) if ConfigParser.handle_nil(converted_bit_size)
+    end
+
+    # @param (see Conversion#call)
+    # @return [Varies] The result of the associated processor
+    def call(value, packet, buffer)
+      packet.processors[@processor_name].results[@result_name] || 0 # Never return nil
+    end
+
+    # @return [String] The type of processor
+    def to_s
+      "ProcessorConversion #{@processor_name} #{@result_name}"
+    end
+
+  end # class ProcessorConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/received_count_conversion.rb

@@ -0,0 +1,33 @@
+# 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/conversions/conversion'
+
+module Cosmos
+
+  # Converts the packet received count as a derived telemetry item
+  class ReceivedCountConversion < Conversion
+
+    # Initializes converted_type to :UINT and converted_bit_size to 32
+    def initialize
+      super()
+      @converted_type = :UINT
+      @converted_bit_size = 32
+    end
+
+    # @param (see Conversion#call)
+    # @return [Integer] packet.received_count
+    def call(value, packet, buffer)
+      packet.received_count
+    end
+
+  end # class ReceivedCountConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/received_time_formatted_conversion.rb

@@ -0,0 +1,37 @@
+# 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/conversions/conversion'
+
+module Cosmos
+
+  # Converts the packet received time object into a formatted string.
+  class ReceivedTimeFormattedConversion < Conversion
+
+    # Initializes converted_type to :STRING and converted_bit_size to 0
+    def initialize
+      super()
+      @converted_type = :STRING
+      @converted_bit_size = 0
+    end
+
+    # @param (see Conversion#call)
+    # @return [String] Formatted packet time
+    def call(value, packet, buffer)
+      if packet.received_time
+        return packet.received_time.formatted
+      else
+        return 'No Packet Received Time'
+      end
+    end
+
+  end # class ReceivedTimeFormattedConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/received_time_seconds_conversion.rb

@@ -0,0 +1,37 @@
+# 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/conversions/conversion'
+
+module Cosmos
+
+  # Converts the packet received time into floating point seconds.
+  class ReceivedTimeSecondsConversion < Conversion
+
+    # Initializes converted_type to :FLOAT and converted_bit_size to 64
+    def initialize
+      super()
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] Packet received time in seconds
+    def call(value, packet, buffer)
+      if packet.received_time
+        return packet.received_time.to_f
+      else
+        return 0.0
+      end
+    end
+
+  end # class ReceivedTimeSecondsConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/segmented_polynomial_conversion.rb

@@ -0,0 +1,128 @@
+# 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/conversions/conversion'
+
+module Cosmos
+
+  # Segmented polynomial conversions consist of polynomial conversions that are
+  # applied for a range of values.
+  class SegmentedPolynomialConversion < Conversion
+
+    # A polynomial conversion segment which applies the conversion from the
+    # lower bound (inclusive) until another segment's lower bound is
+    # encountered.
+    class Segment
+      # @return [Integer] The value at which point this polynomial conversion
+      #   should apply. All values >= to this value will be converted using the
+      #   given coefficients.
+      attr_reader :lower_bound
+      # @return [Array<Integer>] The polynomial coefficients
+      attr_reader :coeffs
+
+      # Creates a polynomial conversion segment. Multiple Segments are used to
+      # implemnt a {SegmentedPolynomialConversion}.
+      #
+      # @param lower_bound [Integer] The value at which point this polynomial conversion
+      #   should apply. All values >= to this value will be converted using the
+      #   given coefficients.
+      # @param coeffs [Array<Integer>] The polynomial coefficients
+      def initialize(lower_bound, coeffs)
+        @lower_bound = lower_bound
+        @coeffs = coeffs
+      end
+
+      # Implement the comparison operator to compared based on the lower_bound
+      # but sort in reverse order so the segment with the largest lower_bound
+      # comes first. This makes the calculation code in call easier.
+      #
+      # @param other_segment [Segment] The segment to compare
+      # @return [Integer] 1 if self.lower_bound > other_segment.lower_bound, 0
+      #   if they are equal, -1 if self.lower_bound < other_segment.lower_bound
+      def <=>(other_segment)
+        return other_segment.lower_bound <=> @lower_bound
+      end
+
+      # Perform the polynomial conversion
+      #
+      # @param value [Numeric] The value to convert
+      # @return [Float] The converted value
+      def calculate(value)
+        converted = 0.0
+        @coeffs.length.times do |index|
+          converted += @coeffs[index].to_f * (value ** index)
+        end
+        return converted
+      end
+    end
+
+    # Initialize the converted_type to :FLOAT and converted_bit_size to 64.
+    def initialize
+      @segments = []
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # Add a segment to the segmented polynomial. The lower bound is inclusive, but
+    # is ignored for the segment with the lowest lower_bound.
+    #
+    # @param lower_bound [Integer] The value at which point this polynomial conversion
+    #   should apply. All values >= to this value will be converted using the
+    #   given coefficients.
+    # @param coeffs [Array<Integer>] The polynomial coefficients
+    def add_segment(lower_bound, *coeffs)
+      @segments << Segment.new(lower_bound, coeffs)
+      @segments.sort!
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] The value with the polynomial applied
+    def call(value, packet, buffer)
+      # Try to find correct segment
+      @segments.each do |segment|
+        if value >= segment.lower_bound
+          return segment.calculate(value)
+        end
+      end
+
+      # Default to using segment with smallest lower_bound
+      segment = @segments[-1]
+      if segment
+        return @segments[-1].calculate(value)
+      else
+        return nil
+      end
+    end
+
+    # @return [String] The name of the class followed by a description of all
+    #   the polynomial segments.
+    def to_s
+      result = ""
+      count = 0
+      @segments.each do |segment|
+        result << "\n" if count > 0
+        result << "Lower Bound: #{segment.lower_bound} Polynomial: "
+        segment.coeffs.length.times do |index|
+          if index == 0
+            result << "#{segment.coeffs[index]}"
+          elsif index == 1
+            result << " + #{segment.coeffs[index]}x"
+          else
+            result << " + #{segment.coeffs[index]}x^#{index}"
+          end
+        end
+        count += 1
+      end
+      result
+    end
+
+  end # class SegmentedPolynomialConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/unix_time_conversion.rb

@@ -0,0 +1,50 @@
+# 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/conversions/conversion'
+
+module Cosmos
+
+  # Converts a unix format time: Epoch Jan 1 1970, seconds and microseconds
+  class UnixTimeConversion < Conversion
+
+    # Initializes the time item to grab from the packet
+    #
+    # @param seconds_item_name [String] The telemetry item in the packet which
+    #   represents the number of seconds since the UNIX time epoch
+    # @param microseconds_item_name [String] The telemetry item in the packet
+    #   which represents microseconds
+    def initialize(seconds_item_name, microseconds_item_name = nil)
+      @seconds_item_name = seconds_item_name
+      @microseconds_item_name = microseconds_item_name
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] Packet time in seconds since UNIX epoch
+    def call(value, packet, buffer)
+      if @microseconds_item_name
+        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), packet.read(@microseconds_item_name, :RAW, buffer))
+      else
+        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), 0)
+      end
+    end
+
+    # @return [String] The name of the class followed by the time conversion
+    def to_s
+      if @microseconds_item_name
+        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), packet.read('#{@microseconds_item_name}', :RAW, buffer))"
+      else
+        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), 0)"
+      end
+    end
+
+  end # class UnixTimeConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/unix_time_formatted_conversion.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
+
+require 'cosmos/conversions/unix_time_conversion'
+
+module Cosmos
+
+  # Converts a unix format time: Epoch Jan 1 1970, seconds and microseconds,
+  # into a formatted string.
+  class UnixTimeFormattedConversion < UnixTimeConversion
+
+    # Initializes converted_type to :STRING and converted_bit_size to 0
+    #
+    # @param seconds_item_name [String] The telemetry item in the packet which
+    #   represents the number of seconds since the UNIX time epoch
+    # @param microseconds_item_name [String] The telemetry item in the packet
+    #   which represents microseconds
+    def initialize(seconds_item_name, microseconds_item_name = nil)
+      super(seconds_item_name, microseconds_item_name)
+      @converted_type = :STRING
+      @converted_bit_size = 0
+    end
+
+    # @param (see Conversion#call)
+    # @return [String] Formatted packet time
+    def call(value, packet, buffer)
+      super.formatted
+    end
+
+    # @return [String] The name of the class followed by the time conversion
+    def to_s
+      super << ".formatted"
+    end
+
+  end # class UnixTimeFormattedConversion
+
+end # module Cosmos

data/lib/cosmos/conversions/unix_time_seconds_conversion.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
+
+require 'cosmos/conversions/unix_time_conversion'
+
+module Cosmos
+
+  # Converts a unix format time: Epoch Jan 1 1970, seconds and microseconds,
+  # into a floating point number.
+  class UnixTimeSecondsConversion < UnixTimeConversion
+
+    # Initializes converted_type to :FLOAT and converted_bit_size to 64
+    #
+    # @param seconds_item_name [String] The telemetry item in the packet which
+    #   represents the number of seconds since the UNIX time epoch
+    # @param microseconds_item_name [String] The telemetry item in the packet
+    #   which represents microseconds
+    def initialize(seconds_item_name, microseconds_item_name = nil)
+      super(seconds_item_name, microseconds_item_name)
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] Packet time in seconds since UNIX epoch
+    def call(value, packet, buffer)
+      super.to_f
+    end
+
+    # @return [String] The name of the class followed by the time conversion
+    def to_s
+      super << ".to_f"
+    end
+
+  end # class UnixTimeSecondsConversion
+
+end # module Cosmos

data/lib/cosmos/conversions.rb

@@ -0,0 +1,13 @@
+# encoding: ascii-8bit
+
+require 'cosmos/conversions/conversion'
+require 'cosmos/conversions/generic_conversion'
+require 'cosmos/conversions/new_packet_log_conversion'
+require 'cosmos/conversions/polynomial_conversion'
+require 'cosmos/conversions/processor_conversion'
+require 'cosmos/conversions/received_count_conversion'
+require 'cosmos/conversions/received_time_formatted_conversion'
+require 'cosmos/conversions/received_time_seconds_conversion'
+require 'cosmos/conversions/segmented_polynomial_conversion'
+require 'cosmos/conversions/unix_time_formatted_conversion'
+require 'cosmos/conversions/unix_time_seconds_conversion'