cosmos 4.1.1 → 4.2.0

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

@@ -11,7 +11,11 @@
 require 'ostruct'
 
 module Cosmos
+  # Parses a macro definition in a command or telemetry configuration file.
+  # Note: Using ERB to define multiple items is now the preferred solution.
   class MacroParser
+    @macro = nil
+
     # Adds a new item to the Macro
     def self.new_item
       return unless @macro
@@ -113,6 +117,5 @@ module Cosmos
         @macro.format_order = 'ds'
       end
     end
-
   end
-end # module Cosmos
+end

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

@@ -8,24 +8,30 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-require 'cosmos/packets/packet_config'
 require 'cosmos/packets/packet_item'
 
 module Cosmos
-
+  # Parses a packet item definition and creates a new PacketItem
   class PacketItemParser
+    # This number is a little arbitrary but there are definitely issues at
+    # 1 million and you really shouldn't be doing anything this big anyway
+    BIG_ARRAY_SIZE = 100_000
+
     # @param parser [ConfigParser] Configuration parser
     # @param packet [Packet] The packet the item should be added to
-    # @param cmd_or_tlm [String] Whether this is :bn
-    def self.parse(parser, packet, cmd_or_tlm)
-      parser = PacketItemParser.new(parser)
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    # @param warnings [Array<String>] Array of warning strings from PacketConfig
+    def self.parse(parser, packet, cmd_or_tlm, warnings)
+      parser = PacketItemParser.new(parser, warnings)
       parser.verify_parameters(cmd_or_tlm)
       parser.create_packet_item(packet, cmd_or_tlm)
     end
 
     # @param parser [ConfigParser] Configuration parser
-    def initialize(parser)
+    # @param warnings [Array<String>] Array of warning strings from PacketConfig
+    def initialize(parser, warnings)
       @parser = parser
+      @warnings = warnings
       @usage = get_usage()
     end
 
@@ -43,7 +49,13 @@ module Cosmos
     end
 
     def create_packet_item(packet, cmd_or_tlm)
-      item = PacketItem.new(@parser.parameters[0],
+      item_name = @parser.parameters[0].upcase
+      if packet.items[item_name]
+        msg = "#{packet.target_name} #{packet.packet_name} #{item_name} redefined."
+        Logger.instance.warn msg
+        @warnings << msg
+      end
+      item = PacketItem.new(item_name,
                             get_bit_offset(),
                             get_bit_size(),
                             get_data_type(),
@@ -94,7 +106,17 @@ module Cosmos
     def get_array_size
       return nil unless (@parser.keyword.include?('ARRAY'))
       index = append? ? 3 : 4
-      Integer(@parser.parameters[index])
+      array_bit_size = Integer(@parser.parameters[index])
+      items = array_bit_size / get_bit_size()
+      if items >= BIG_ARRAY_SIZE
+        warning = "Performance Issue!\n"\
+          "In #{@parser.filename}:#{@parser.line_number} your definition of:\n"\
+          "#{@parser.line}\n"\
+          "creates an array with #{items} elements. Consider creating a BLOCK if this is binary data."
+        Logger.warn(warning)
+        @warnings << warning
+      end
+      array_bit_size
     rescue => err
       raise @parser.error(err, @usage)
     end
@@ -131,7 +153,7 @@ module Cosmos
 
       index = append? ? 3 : 4
       data_type = get_data_type()
-      if data_type == :STRING or data_type == :BLOCK        
+      if data_type == :STRING or data_type == :BLOCK
         # If the default value is 0x<data> (no quotes), it is treated as
         # binary data.  Otherwise, the default value is considered to be a string.
         if (@parser.parameters[index].upcase.start_with?("0X")         and
@@ -171,13 +193,11 @@ module Cosmos
     # There are many different usages of the ITEM and PARAMETER keywords so
     # parse the keyword and parameters to generate the correct usage information.
     def get_usage
-      keyword = @parser.keyword
-      params = @parser.parameters
-      usage = "#{keyword} <ITEM NAME> "
-      usage << "<BIT OFFSET> " unless keyword.include?("APPEND")
+      usage = "#{@parser.keyword} <ITEM NAME> "
+      usage << "<BIT OFFSET> " unless @parser.keyword.include?("APPEND")
       usage << bit_size_usage()
       usage << type_usage()
-      usage << "<TOTAL ARRAY BIT SIZE> " if keyword.include?("ARRAY")
+      usage << "<TOTAL ARRAY BIT SIZE> " if @parser.keyword.include?("ARRAY")
       usage << id_usage()
       usage << "<DESCRIPTION (Optional)> <ENDIANNESS (Optional)>"
       usage
@@ -198,7 +218,6 @@ module Cosmos
 
       # Build up the parameter type usage based on the keyword
       usage = "<TYPE: "
-      params = @parser.parameters
       # ARRAY types don't have min or max or default values
       if keyword.include?("ARRAY")
         usage << "INT/UINT/FLOAT/STRING/BLOCK> "
@@ -229,6 +248,5 @@ module Cosmos
         "<ID VALUE> "
       end
     end
-
   end
-end # module Cosmos
+end

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

@@ -50,7 +50,7 @@ module Cosmos
       packet.sorted_items.each do |item|
         item.check_default_and_range_data_types()
       end
-    rescue => err
+    rescue
       # Add the target name and packet name to the error message so the user
       # can debug where the error occurred
       raise $!, "#{packet.target_name} #{packet.packet_name} #{$!}", $!.backtrace
@@ -111,14 +111,7 @@ module Cosmos
     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'
+      packet.define_reserved_items()
 
       unless telemetry[packet.target_name]
         telemetry[packet.target_name] = {}
@@ -128,4 +121,4 @@ module Cosmos
     end
 
   end
-end # module Cosmos
+end

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

@@ -168,13 +168,13 @@ module Cosmos
           unique[item.name] << item
         end
       end
-      unique.each do |item_name, items|
-        if items.length <= 1
-          unique[item_name] = items[0]
+      unique.each do |item_name, unique_items|
+        if unique_items.length <= 1
+          unique[item_name] = unique_items[0]
           next
         end
         # TODO: need to make sure all the items in the array are exactly the same
-        unique[item_name] = items[0]
+        unique[item_name] = unique_items[0]
       end
       unique
     end
@@ -260,6 +260,20 @@ module Cosmos
       end
     end
 
+    def to_xtce_limits(item, xml)
+      return unless item.limits && item.limits.values
+      item.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
+
     def to_xtce_int(item, param_or_arg, xml)
       attrs = { :name => (item.name + '_Type') }
       attrs[:initialValue] = item.default if item.default and !item.array_size
@@ -302,20 +316,7 @@ module Cosmos
           else
             xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
           end
-          if item.limits
-            if item.limits.values
-              item.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
+          to_xtce_limits(item, xml)
           if item.range
             xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
           end
@@ -337,22 +338,7 @@ module Cosmos
         else
           xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985')
         end
-
-        if item.limits
-          if item.limits.values
-            item.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
-
+        to_xtce_limits(item, xml)
         if item.range
           xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
         end
@@ -372,7 +358,7 @@ module Cosmos
       end
       attrs[:shortDescription] = item.description if item.description
       xml['xtce'].send(string_or_binary + param_or_arg + 'Type', attrs) do
-        to_xtce_endianness(item, xml)
+        # Don't call to_xtce_endianness for Strings or Blocks
         to_xtce_units(item, xml)
         if string_or_binary == 'String'
           xml['xtce'].StringDataEncoding(:encoding => 'UTF-8') do

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

@@ -10,7 +10,6 @@
 
 require 'nokogiri'
 require 'ostruct'
-require 'cosmos/packets/packet_config'
 
 module Cosmos
 
@@ -55,16 +54,17 @@ module Cosmos
       @commands = commands
       @telemetry = telemetry
       @warnings = warnings
+      @current_packet = nil
       parse(filename, target_name)
     end
 
     def parse(filename, target_name)
       doc = File.open(filename) { |f| Nokogiri::XML(f, nil, nil, Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS) }
-      xtce_process_element(doc.root, 0)
+      xtce_process_element(doc.root)
       @current_target_name = target_name if target_name
       doc.root.children.each do |child|
-        xtce_recurse_element(child, 1) do |element, depth|
-          xtce_process_element(element, depth)
+        xtce_recurse_element(child) do |element|
+          xtce_process_element(element)
         end
       end
       finish_packet()
@@ -100,7 +100,13 @@ module Cosmos
     end
 
     def set_packet_endianness
-      item_endianness = @current_packet.sorted_items.collect { |item| item.endianness }.uniq
+      item_endianness = @current_packet.sorted_items.collect do |item|
+        # Strings and Blocks endianness don't matter so ignore them
+        item.endianness if (item.data_type != :STRING && item.data_type != :BLOCK)
+      end
+      # Compact to get rid of nils from skipping Strings and Blocks
+      # Uniq to get rid of duplicates which results in an array of 1 or 2 items
+      item_endianness = item_endianness.compact.uniq
       if item_endianness.length == 1 # All items have the same endianness
         # default_endianness is read_only since it affects how items are added
         # thus we have to use instance_variable_set here to override it
@@ -137,7 +143,7 @@ module Cosmos
 
     XTCE_IGNORED_ELEMENTS = ['text', 'AliasSet', 'Alias', 'Header']
 
-    def xtce_process_element(element, depth)
+    def xtce_process_element(element)
       if XTCE_IGNORED_ELEMENTS.include?(element.name)
         return false
       end
@@ -154,14 +160,17 @@ module Cosmos
         finish_packet()
         @current_cmd_or_tlm = PacketConfig::COMMAND
 
-      when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet', 'EntryList', 'DefaultCalibrator', 'DefaultAlarm',
-        'RestrictionCriteria', 'ComparisonList', 'MetaCommandSet', 'DefaultCalibrator', 'ArgumentTypeSet', 'ArgumentList', 'ArgumentAssignmentList',
-        'LocationInContainerInBits'
-
+      when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet',
+        'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria',
+        'ComparisonList', 'MetaCommandSet', 'ArgumentTypeSet', 'ArgumentList',
+        'ArgumentAssignmentList', 'LocationInContainerInBits'
         # Do Nothing
 
-      when 'EnumeratedParameterType', 'EnumeratedArgumentType', 'IntegerParameterType', 'IntegerArgumentType', 'FloatParameterType', 'FloatArgumentType',
-        'StringParameterType', 'StringArgumentType', 'BinaryParameterType', 'BinaryArgumentType'
+      when 'EnumeratedParameterType', 'EnumeratedArgumentType',
+        'IntegerParameterType', 'IntegerArgumentType',
+        'FloatParameterType', 'FloatArgumentType',
+        'StringParameterType', 'StringArgumentType',
+        'BinaryParameterType', 'BinaryArgumentType'
         @current_type = create_new_type(element)
         @current_type.endianness = :BIG_ENDIAN
 
@@ -187,10 +196,10 @@ module Cosmos
 
       when 'ByteOrderList'
         byte_list = []
-        xtce_recurse_element(element, depth + 1) do |element, depth|
-          if element.name == 'Byte'
-            if element['byteSignificance']
-              byte_list << element['byteSignificance'].to_i
+        xtce_recurse_element(element) do |block_element|
+          if block_element.name == 'Byte'
+            if block_element['byteSignificance']
+              byte_list << block_element['byteSignificance'].to_i
             end
           end
           true
@@ -228,9 +237,9 @@ module Cosmos
         return false # Already recursed
 
       when "SizeInBits"
-        xtce_recurse_element(element, depth + 1) do |element, depth|
-          if element.name == 'FixedValue'
-            @current_type.sizeInBits = Integer(element.text)
+        xtce_recurse_element(element) do |block_element|
+          if block_element.name == 'FixedValue'
+            @current_type.sizeInBits = Integer(block_element.text)
             false
           else
             true
@@ -239,10 +248,10 @@ module Cosmos
         return false # Already recursed
 
       when 'UnitSet'
-        xtce_recurse_element(element, depth + 1) do |element, depth|
-          if element.name == 'Unit'
-            units = element.text.to_s
-            description = element['description'].to_s
+        xtce_recurse_element(element) do |block_element|
+          if block_element.name == 'Unit'
+            units = block_element.text.to_s
+            description = block_element['description'].to_s
             description = units if description.empty?
             units = description if units.empty?
 
@@ -252,7 +261,7 @@ module Cosmos
             else
               @current_type.units << ('/' + units)
             end
-            @current_type.units << "^#{element['power']}" if element['power']
+            @current_type.units << "^#{block_element['power']}" if block_element['power']
 
             @current_type.units_full ||= ''
             if @current_type.units_full.empty?
@@ -266,12 +275,11 @@ module Cosmos
         return false # Already recursed
 
       when 'PolynomialCalibrator'
-        xtce_recurse_element(element, depth + 1) do |element, depth|
-          if element.name == 'Term'
-            index = Float(element['exponent']).to_i
-            coeff = Float(element['coefficient'])
+        xtce_recurse_element(element) do |block_element|
+          if block_element.name == 'Term'
+            exponent = Float(block_element['exponent']).to_i
             @current_type.conversion ||= PolynomialConversion.new([])
-            @current_type.conversion.coeffs[index] = coeff
+            @current_type.conversion.coeffs[exponent] = Float(block_element['coefficient'])
             @current_type.conversion.coeffs.each_with_index do |value, index|
               @current_type.conversion.coeffs[index] = 0.0 if value.nil?
             end
@@ -281,15 +289,15 @@ module Cosmos
         return false # Already recursed
 
       when 'StaticAlarmRanges'
-        xtce_recurse_element(element, depth + 1) do |element, depth|
-          if element.name == 'WarningRange'
+        xtce_recurse_element(element) do |block_element|
+          if block_element.name == 'WarningRange'
             @current_type.limits ||= [0.0, 0.0, 0.0, 0.0]
-            @current_type.limits[1] = Float(element['minInclusive']) if element['minInclusive']
-            @current_type.limits[2] = Float(element['maxInclusive']) if element['maxInclusive']
-          elsif element.name == 'CriticalRange'
+            @current_type.limits[1] = Float(block_element['minInclusive']) if block_element['minInclusive']
+            @current_type.limits[2] = Float(block_element['maxInclusive']) if block_element['maxInclusive']
+          elsif block_element.name == 'CriticalRange'
             @current_type.limits ||= [0.0, 0.0, 0.0, 0.0]
-            @current_type.limits[0] = Float(element['minInclusive']) if element['minInclusive']
-            @current_type.limits[3] = Float(element['maxInclusive']) if element['maxInclusive']
+            @current_type.limits[0] = Float(block_element['minInclusive']) if block_element['minInclusive']
+            @current_type.limits[3] = Float(block_element['maxInclusive']) if block_element['maxInclusive']
           end
           true
         end
@@ -345,7 +353,7 @@ module Cosmos
         end
 
       when 'ParameterRefEntry', 'ArgumentRefEntry', 'ArrayParameterRefEntry', 'ArrayArgumentRefEntry'
-        process_ref_entry(element, depth)
+        process_ref_entry(element)
         return false # Already recursed
 
       when 'BaseContainer'
@@ -399,12 +407,12 @@ module Cosmos
       return true # Recurse further
     end
 
-    def process_ref_entry(element, depth)
+    def process_ref_entry(element)
       reference_location, bit_offset = xtce_handle_location_in_container_in_bits(element)
       object, type, data_type, array_type = get_object_types(element)
       bit_size = Integer(type.sizeInBits)
       if array_type
-        array_bit_size = process_array_type(element, depth, bit_size)
+        array_bit_size = process_array_type(element, bit_size)
       else
         array_bit_size = nil # in define_item, nil indicates the item is not an array
       end
@@ -477,14 +485,14 @@ module Cosmos
       return [object, type, data_type, array_type]
     end
 
-    def process_array_type(element, depth, bit_size)
+    def process_array_type(element, bit_size)
       array_num_items = 1
       # Need to determine dimensions
-      xtce_recurse_element(element, depth + 1) do |element, depth|
-        if element.name == 'Dimension'
+      xtce_recurse_element(element) do |block_element|
+        if block_element.name == 'Dimension'
           starting_index = 0
           ending_index = 0
-          element.children.each do |child_element|
+          block_element.children.each do |child_element|
             if child_element.name == 'StartingIndex'
               child_element.children.each do |child_element2|
                 if child_element2.name == 'FixedValue'
@@ -623,10 +631,10 @@ module Cosmos
       return string
     end
 
-    def xtce_recurse_element(element, depth, &block)
-      return unless yield(element, depth)
+    def xtce_recurse_element(element, &block)
+      return unless yield(element)
       element.children.each do |child_element|
-        xtce_recurse_element(child_element, depth + 1, &block)
+        xtce_recurse_element(child_element, &block)
       end
     end