cosmos 3.7.1 → 3.8.0

data/lib/cosmos/packets/packet_item.rb

@@ -296,8 +296,238 @@ module Cosmos
       hash
     end
 
+    def to_config(cmd_or_tlm, default_endianness)
+      config = ''
+      if cmd_or_tlm == :TELEMETRY
+        if self.array_size
+          config << "  ARRAY_ITEM #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} #{self.array_size} \"#{self.description.to_s.gsub("\"", "'")}\""
+        elsif self.id_value
+          config << "  ID_ITEM #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} #{self.id_value} \"#{self.description.to_s.gsub("\"", "'")}\""
+        else
+          config << "  ITEM #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} \"#{self.description.to_s.gsub("\"", "'")}\""
+        end
+      else # :COMMAND
+        if self.array_size
+          config << "  ARRAY_PARAMETER #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} #{self.array_size} \"#{self.description.to_s.gsub("\"", "'")}\""
+        elsif self.id_value
+          if self.data_type == :BLOCK or self.data_type == :STRING
+            config << "  ID_PARAMETER #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} \"#{self.default}\" \"#{self.description.to_s.gsub("\"", "'")}\""
+          else
+            config << "  ID_PARAMETER #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} #{self.range.first} #{self.range.last} #{self.default} \"#{self.description.to_s.gsub("\"", "'")}\""
+          end
+        else
+          if self.data_type == :BLOCK or self.data_type == :STRING
+            config << "  PARAMETER #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} \"#{self.default}\" \"#{self.description.to_s.gsub("\"", "'")}\""
+          else
+            config << "  PARAMETER #{self.name.to_s.quote_if_necessary} #{self.bit_offset} #{self.bit_size} #{self.data_type} #{self.range.first} #{self.range.last} #{self.default} \"#{self.description.to_s.gsub("\"", "'")}\""
+          end
+        end
+      end
+      config << " #{self.endianness}" if self.endianness != default_endianness
+      config << "\n"
+
+      config << "    REQUIRED\n" if self.required
+      config << "    FORMAT_STRING #{self.format_string.to_s.quote_if_necessary}\n" if self.format_string
+      config << "    UNITS #{self.units_full.to_s.quote_if_necessary} #{self.units.to_s.quote_if_necessary}\n" if self.units
+      config << "    OVERFLOW #{self.overflow}\n" if self.overflow != :ERROR
+
+      if @states
+        @states.each do |state_name, state_value|
+          config << "    STATE #{state_name.to_s.quote_if_necessary} #{state_value.to_s.quote_if_necessary}"
+          if @hazardous and @hazardous[state_name]
+            config << " HAZARDOUS #{@hazardous[state_name].to_s.quote_if_necessary}"
+          end
+          if @state_colors and @state_colors[state_name]
+            config << " #{@state_colors[state_name]}"
+          end
+          config << "\n"
+        end
+      end
+
+      config << self.read_conversion.to_config(:READ) if self.read_conversion
+      config << self.write_conversion.to_config(:WRITE) if self.write_conversion
+
+      if self.limits
+        if self.limits.values
+          self.limits.values.each do |limits_set, limits_values|
+            config << "    LIMITS #{limits_set} #{self.limits.persistence_setting} #{self.limits.enabled ? 'ENABLED' : 'DISABLED'} #{limits_values[0]} #{limits_values[1]} #{limits_values[2]} #{limits_values[3]} #{limits_values[4]} #{limits_values[5]}\n"
+          end
+        end
+        config << self.limits.response.to_config if self.limits.response
+      end
+
+      if @meta
+        @meta.each do |key, values|
+          config << "    META #{key.to_s.quote_if_necessary} #{values.map {|a| a.to_s.quote_if_necessary}.join(" ")}\n"
+        end
+      end
+
+      config
+    end
+
+    def to_xtce_type(param_or_arg, xml)
+      # TODO: Arrays, Spline Conversions
+      case self.data_type
+      when :INT, :UINT
+        attrs = { :name => (self.name + '_Type') }
+        attrs[:initialValue] = self.default if self.default and !self.array_size
+        attrs[:shortDescription] = self.description if self.description
+        if @states and self.default and @states.key(self.default)
+          attrs[:initialValue] = @states.key(self.default) and !self.array_size
+        end
+        if self.data_type == :INT
+          signed = 'true'
+          encoding = 'twosCompliment'
+        else
+          signed = 'false'
+          encoding = 'unsigned'
+        end
+        if @states
+			    xml['xtce'].send('Enumerated' + param_or_arg + 'Type', attrs) do
+            to_xtce_units(xml)
+            xml['xtce'].IntegerDataEncoding(:sizeInBits => self.bit_size, :encoding => encoding)
+				    xml['xtce'].EnumerationList do
+              @states.each do |state_name, state_value|
+					      xml['xtce'].Enumeration(:value => state_value, :label => state_name)
+              end
+            end
+          end
+        else
+          if (self.read_conversion and self.read_conversion.class == PolynomialConversion) or (self.write_conversion and self.write_conversion.class == PolynomialConversion)
+            type_string = 'Float' + param_or_arg + 'Type'
+          else
+            type_string = 'Integer' + param_or_arg + 'Type'
+            attrs[:signed] = signed
+          end
+          xml['xtce'].send(type_string, attrs) do
+            to_xtce_units(xml)
+            if (self.read_conversion and self.read_conversion.class == PolynomialConversion) or (self.write_conversion and self.write_conversion.class == PolynomialConversion)
+              xml['xtce'].IntegerDataEncoding(:sizeInBits => self.bit_size, :encoding => encoding) do
+                to_xtce_conversion(xml)
+              end
+            else
+              xml['xtce'].IntegerDataEncoding(:sizeInBits => self.bit_size, :encoding => encoding)
+            end
+            if self.limits
+              if self.limits.values
+                self.limits.values.each do |limits_set, limits_values|
+                  if limits_set == :DEFAULT
+                    xml['xtce'].DefaultAlarm do
+                      xml['xtce'].StaticAlarmRanges do
+                        xml['xtce'].WarningRange(:minInclusive => limits_values[1], :maxInclusive => limits_values[2])
+                        xml['xtce'].CriticalRange(:minInclusive => limits_values[0], :maxInclusive => limits_values[3])
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            if self.range
+              xml['xtce'].ValidRange(:minInclusive => self.range.first, :maxInclusive => self.range.last)
+            end
+          end # Type
+        end # if @states
+      when :FLOAT
+        attrs = { :name => (self.name + '_Type'), :sizeInBits => self.bit_size }
+        attrs[:initialValue] = self.default if self.default and !self.array_size
+        attrs[:shortDescription] = self.description if self.description
+        xml['xtce'].send('Float' + param_or_arg + 'Type', attrs) do
+          to_xtce_units(xml)
+          if (self.read_conversion and self.read_conversion.class == PolynomialConversion) or (self.write_conversion and self.write_conversion.class == PolynomialConversion)
+            xml['xtce'].FloatDataEncoding(:sizeInBits => self.bit_size, :encoding => 'IEEE754_1985') do
+              to_xtce_conversion(xml)
+            end
+          else
+            xml['xtce'].FloatDataEncoding(:sizeInBits => self.bit_size, :encoding => 'IEEE754_1985')
+          end
+
+          if self.limits
+            if self.limits.values
+              self.limits.values.each do |limits_set, limits_values|
+                if limits_set == :DEFAULT
+                  xml['xtce'].DefaultAlarm do
+                    xml['xtce'].StaticAlarmRanges do
+                      xml['xtce'].WarningRange(:minInclusive => limits_values[1], :maxInclusive => limits_values[2])
+                      xml['xtce'].CriticalRange(:minInclusive => limits_values[0], :maxInclusive => limits_values[3])
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          if self.range
+            xml['xtce'].ValidRange(:minInclusive => self.range.first, :maxInclusive => self.range.last)
+          end
+
+        end # Type
+      when :STRING
+        # TODO: COSMOS Variably sized strings are not supported in XTCE
+        attrs = { :name => (self.name + '_Type'), :characterWidth => 8 }
+        attrs[:initialValue] = self.default if self.default and !self.array_size
+        attrs[:shortDescription] = self.description if self.description
+        xml['xtce'].send('String' + param_or_arg + 'Type', attrs) do
+          to_xtce_units(xml)
+          xml['xtce'].StringDataEncoding(:encoding => 'UTF-8') do
+					  xml['xtce'].SizeInBits do
+              xml['xtce'].Fixed do
+                xml['xtce'].FixedValue(self.bit_size.to_s)
+              end
+            end
+          end
+        end
+      when :BLOCK
+        # TODO: COSMOS Variably sized blocks are not supported in XTCE
+        # TODO: Write string to hex method to support initial value
+        attrs = { :name => (self.name + '_Type') }
+        attrs[:shortDescription] = self.description if self.description
+        #attrs[:initialValue] = self.default if self.default and !self.array_size
+        xml['xtce'].send('Binary' + param_or_arg + 'Type', attrs) do
+          to_xtce_units(xml)
+          xml['xtce'].BinaryDataEncoding do
+					  xml['xtce'].SizeInBits do
+              xml['xtce'].FixedValue(self.bit_size.to_s)
+            end
+          end
+        end
+      when :DERIVED
+        raise "DERIVED data type not supported in XTCE"
+      end
+    end
+
+    def to_xtce_item(param_or_arg, xml)
+      xml['xtce'].send(param_or_arg, :name => self.name, "#{param_or_arg.downcase}TypeRef" => self.name + '_Type')
+    end
+
     protected
 
+    def to_xtce_units(xml)
+      if self.units
+        xml['xtce'].UnitSet do
+          xml['xtce'].Unit(self.units, :description => self.units_full)
+        end
+      else
+        xml['xtce'].UnitSet
+      end
+    end
+
+    def to_xtce_conversion(xml)
+      if self.read_conversion
+        conversion = self.read_conversion
+      else
+        conversion = self.write_conversion
+      end
+      if conversion and conversion.class == PolynomialConversion
+        xml['xtce'].DefaultCalibrator do
+					xml['xtce'].PolynomialCalibrator do
+            conversion.coeffs.each_with_index do |coeff, index|
+						  xml['xtce'].Term(:coefficient => coeff, :exponent => index)
+            end
+					end
+        end
+      end
+    end
+
     # Convert a value into the given data type
     def convert(value, data_type)
       case data_type

data/lib/cosmos/packets/parsers/packet_parser.rb

@@ -68,33 +68,15 @@ module Cosmos
 
     def create_command(target_name, commands, warnings)
       packet = create_packet(target_name)
-      warning = check_for_duplicate('Command', commands, packet)
-      warnings << warning if warning
-      commands[packet.target_name] ||= {}
-      packet
+      PacketParser.finish_create_command(packet, commands, warnings)
     end
 
     def create_telemetry(target_name, telemetry, latest_data, warnings)
       packet = create_packet(target_name)
-      warning = check_for_duplicate('Telemetry', telemetry, packet)
-      warnings << warning if warning
-
-      # Add received time packet items
-      item = packet.define_item('RECEIVED_TIMESECONDS', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, '%0.6f', ReceivedTimeSecondsConversion.new)
-      item.description = 'COSMOS Received Time (UTC, Floating point, Unix epoch)'
-      item = packet.define_item('RECEIVED_TIMEFORMATTED', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, nil, ReceivedTimeFormattedConversion.new)
-      item.description = 'COSMOS Received Time (Local time zone, Formatted string)'
-      item = packet.define_item('RECEIVED_COUNT', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, nil, ReceivedCountConversion.new)
-      item.description = 'COSMOS packet received count'
-
-      unless telemetry[packet.target_name]
-        telemetry[packet.target_name] = {}
-        latest_data[packet.target_name] = {}
-      end
-      packet
+      PacketParser.finish_create_telemetry(packet, telemetry, latest_data, warnings)
     end
 
-    private
+    #private
 
     def create_packet(target_name)
       params = @parser.parameters
@@ -108,7 +90,7 @@ module Cosmos
       Packet.new(target_name, packet_name, endianness, description)
     end
 
-    def check_for_duplicate(type, list, packet)
+    def self.check_for_duplicate(type, list, packet)
       msg = nil
       if list[packet.target_name]
         if list[packet.target_name][packet.packet_name]
@@ -119,5 +101,31 @@ module Cosmos
       msg
     end
 
+    def self.finish_create_command(packet, commands, warnings)
+      warning = PacketParser.check_for_duplicate('Command', commands, packet)
+      warnings << warning if warning
+      commands[packet.target_name] ||= {}
+      packet
+    end
+
+    def self.finish_create_telemetry(packet, telemetry, latest_data, warnings)
+      warning = PacketParser.check_for_duplicate('Telemetry', telemetry, packet)
+      warnings << warning if warning
+
+      # Add received time packet items
+      item = packet.define_item('RECEIVED_TIMESECONDS', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, '%0.6f', ReceivedTimeSecondsConversion.new)
+      item.description = 'COSMOS Received Time (UTC, Floating point, Unix epoch)'
+      item = packet.define_item('RECEIVED_TIMEFORMATTED', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, nil, ReceivedTimeFormattedConversion.new)
+      item.description = 'COSMOS Received Time (Local time zone, Formatted string)'
+      item = packet.define_item('RECEIVED_COUNT', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, nil, ReceivedCountConversion.new)
+      item.description = 'COSMOS packet received count'
+
+      unless telemetry[packet.target_name]
+        telemetry[packet.target_name] = {}
+        latest_data[packet.target_name] = {}
+      end
+      packet
+    end
+
   end
 end # module Cosmos

data/lib/cosmos/processors/new_packet_log_processor.rb

@@ -29,6 +29,11 @@ module Cosmos
       end
     end
 
+    # Convert to configuration file string
+    def to_config
+      "  PROCESSOR #{@name} #{self.class.name.to_s.class_name_to_filename} #{@packet_log_writer_name}\n"
+    end
+
   end # class NewPacketLogProcessor
 
 end # module Cosmos

data/lib/cosmos/processors/processor.rb

@@ -66,6 +66,11 @@ module Cosmos
     end
     alias dup clone
 
+    # Convert to configuration file string
+    def to_config
+      "  PROCESSOR #{@name} #{self.class.name.to_s.class_name_to_filename} #{@value_type}\n"
+    end
+
   end # class Processor
 
 end # module Cosmos

data/lib/cosmos/processors/statistics_processor.rb

@@ -60,6 +60,11 @@ module Cosmos
     end
     alias dup clone
 
+    # Convert to configuration file string
+    def to_config
+      "  PROCESSOR #{@name} #{self.class.name.to_s.class_name_to_filename} #{@item_name} #{@samples_to_average} #{@value_type}\n"
+    end
+
   end # class StatisticsProcessor
 
 end # module Cosmos

data/lib/cosmos/processors/watermark_processor.rb

@@ -39,6 +39,11 @@ module Cosmos
       @results[:LOW_WATER] = nil
     end
 
+    # Convert to configuration file string
+    def to_config
+      "  PROCESSOR #{@name} #{self.class.name.to_s.class_name_to_filename} #{@item_name} #{@value_type}\n"
+    end
+
   end # class WatermarkProcessor
 
 end # module Cosmos

data/lib/cosmos/script/extract.rb

@@ -25,7 +25,7 @@ module Cosmos
     end
 
     def extract_fields_from_cmd_text(text)
-      split_string = text.split(/\s*with\s*/i, 2)
+      split_string = text.split(/\s+with\s+/i, 2)
       raise "ERROR: 'with' must be followed by parameters : #{text}" if split_string.length == 1 and text =~ /\s*with\s*/i
 
       # Extract target_name and cmd_name

data/lib/cosmos/tools/packet_viewer/packet_viewer.rb

@@ -35,7 +35,11 @@ module Cosmos
       @tlm_thread = nil
       @shutdown_tlm_thread = false
       @mode = :WITH_UNITS
-      @polling_rate = 1.0
+      if options.rate
+        @polling_rate = options.rate
+      else
+        @polling_rate = 1.0
+      end
       @colorblind = false
 
       initialize_actions()
@@ -249,7 +253,7 @@ module Cosmos
     end
 
     def file_options
-      @polling_rate = Qt::InputDialog.getDouble(self, tr("Options"), tr("Polling Rate:"), @polling_rate, 0, 1000, 1, nil)
+      @polling_rate = Qt::InputDialog.getDouble(self, tr("Options"), tr("Polling Rate (sec):"), @polling_rate, 0, 1000, 1, nil)
     end
 
     def update_all
@@ -531,6 +535,7 @@ module Cosmos
             end
             options.packet = split
           end
+          option_parser.on("-r", "--rate PERIOD", "Set the polling rate to PERIOD (unit seconds)") { |arg| options.rate = Float(arg) } 
         end
 
         super(option_parser, options)

data/lib/cosmos/tools/tlm_grapher/data_objects/housekeeping_data_object.rb

@@ -163,7 +163,9 @@ module Cosmos
         # Bail on the values if they are NaN or nil as we can't graph them
         return if x_value.nil? || y_value.nil? ||
           (x_value.respond_to?(:nan?) && x_value.nan?) ||
-          (y_value.respond_to?(:nan?) && y_value.nan?)
+          (y_value.respond_to?(:nan?) && y_value.nan?) ||
+          (x_value.respond_to?(:infinite?) && x_value.infinite?) ||
+          (y_value.respond_to?(:infinite?) && y_value.infinite?)
         @formatted_x_values << packet.read(@formatted_time_item_name) if @formatted_time_item_name
 
         upper_index  = nil

data/lib/cosmos/tools/tlm_grapher/data_objects/xy_data_object.rb

@@ -195,7 +195,9 @@ module Cosmos
         # Bail on the values if they are NaN or nil as we can't graph them
         return if x_value.nil? || y_value.nil? ||
           (x_value.respond_to?(:nan?) && x_value.nan?) ||
-          (y_value.respond_to?(:nan?) && y_value.nan?)
+          (y_value.respond_to?(:nan?) && y_value.nan?) ||
+          (x_value.respond_to?(:infinite?) && x_value.infinite?) ||
+          (y_value.respond_to?(:infinite?) && y_value.infinite?)
 
         time_value = packet.read(@time_item_name) if @time_item_name
 

data/lib/cosmos/tools/tlm_viewer/widgets/limits_widget.rb

@@ -34,6 +34,16 @@ module Cosmos
     end
 
     def value=(data)
+      if String === data
+        substring = data[0..2]
+        if substring == "Inf".freeze
+          data = Float::INFINITY
+        elsif substring == "-In".freeze
+          data = -Float::INFINITY
+        elsif substring == "NaN".freeze
+          data = Float::NAN
+        end
+      end
       @value = data.to_f
       update()
     end

data/lib/cosmos/tools/tlm_viewer/widgets/limitsbar_widget.rb

@@ -81,12 +81,20 @@ module Cosmos
       @low_value = red_low - 0.1 * @bar_scale
       @high_value = red_high + 0.1 * @bar_scale
 
-      @line_pos = (@x_pad + (@value - @low_value) / @bar_scale * @bar_width).to_i
-      if @line_pos < @x_pad
-        @line_pos = @x_pad
-      end
-      if @line_pos > @x_pad + @bar_width
-        @line_pos = @bar_width + @x_pad
+      if @value.is_a?(Float) && (@value.infinite? || @value.nan?)
+        if @value.infinite? == 1
+          @line_pos = @bar_width + @x_pad
+        else
+          @line_pos = @x_pad
+        end
+      else
+        @line_pos = (@x_pad + (@value - @low_value) / @bar_scale * @bar_width).to_i
+        if @line_pos < @x_pad
+          @line_pos = @x_pad
+        end
+        if @line_pos > @x_pad + @bar_width
+          @line_pos = @bar_width + @x_pad
+        end
       end
 
       dc.addLineColor(@line_pos, @y_pad - 3, @line_pos, @y_pad + @bar_height + 3)