cosmos 3.8.0 → 3.8.1

data/lib/cosmos/io/io_multiplexer.rb

@@ -19,53 +19,35 @@ module Cosmos
       @streams = []
     end
 
-    # @param args [Array<String>] Argument to send to the print method of each
-    #   stream
-    def print(*args)
-      @streams.each {|stream| stream.print(*args)}
-      nil
+    def write(*args)
+      first = true
+      result = nil
+      @streams.each do |stream|
+        if first
+          result = stream.write(*args)
+          result = self if result == stream
+          first = false
+        else
+          stream.write(*args)
+        end
+      end
+      result
     end
 
-    # @param args [Array<String>] Argument to send to the printf method of each
-    #   stream
-    def printf(*args)
-      @streams.each {|stream| stream.printf(*args)}
-      nil
-    end
-
-    # @param object [Object] Argument to send to the putc method of each
-    #   stream
-    def putc(object)
-      @streams.each {|stream| stream.putc(object)}
-      object
-    end
-
-    # @param args [Array<String>] Argument to send to the puts method of each
-    #   stream
-    def puts(*args)
-      @streams.each {|stream| stream.puts(*args)}
-      nil
-    end
-
-    # Calls flush on each stream
-    def flush
-      @streams.each {|stream| stream.flush}
-    end
-
-    # @param string [String] Argument to send to the write method of each
-    #   stream
-    # @return [Integer] The length of the string argument
-    def write(string)
-      @streams.each {|stream| stream.write(string)}
-      string.length
-    end
-
-    # @param string [String] Argument to send to the write_nonblock method of each
-    #   stream
-    # @return [Integer] The length of the string argument
-    def write_nonblock(string)
-      @streams.each {|stream| stream.write_nonblock(string)}
-      string.length
+    # Forwards IO methods to all streams
+    def method_missing(method_name, *args)
+      first = true
+      result = nil
+      @streams.each do |stream|
+        if first
+          result = stream.send(method_name, *args)
+          result = self if result == stream
+          first = false
+        else
+          stream.send(method_name, *args)
+        end
+      end
+      result
     end
 
     # Removes STDOUT and STDERR from the array of streams

data/lib/cosmos/packets/packet.rb

@@ -185,36 +185,59 @@ module Cosmos
           Logger.instance.warn(msg)
           warnings << msg
         end
-        if item.array_size
-          if item.array_size > 0
-            expected_next_offset = item.bit_offset + item.array_size
-          else
-            expected_next_offset = item.array_size
-          end
+        expected_next_offset = Packet.next_bit_offset(item)
+        previous_item = item
+      end
+      warnings
+    end
+
+    # Checks if the packet has any gaps or overlapped items
+    #
+    # @return [Boolean] true if the packet has no gaps or overlapped items
+    def packed?
+      expected_next_offset = nil
+      @sorted_items.each do |item|
+        if expected_next_offset and item.bit_offset != expected_next_offset
+          return false
+        end
+        expected_next_offset = Packet.next_bit_offset(item)
+      end
+      true
+    end
+
+    # Returns the bit offset of the next item after the current item if items are packed
+    #
+    # @param item [PacketItem] The item to calculate the next offset for
+    # @return [Integer] Bit Offset of Next Item if Packed
+    def self.next_bit_offset(item)
+      if item.array_size
+        if item.array_size > 0
+          next_offset = item.bit_offset + item.array_size
         else
-          expected_next_offset = nil
-          if item.bit_offset > 0
-            # Handle little-endian bit fields
-            byte_aligned = ((item.bit_offset % 8) == 0)
-            if item.endianness == :LITTLE_ENDIAN and (item.data_type == :INT or item.data_type == :UINT) and !(byte_aligned and (item.bit_size == 8 or item.bit_size == 16 or item.bit_size == 32 or item.bit_size == 64))
-              # Bit offset always refers to the most significant bit of a bitfield
-              bits_remaining_in_last_byte = 8 - (item.bit_offset % 8)
-              if item.bit_size > bits_remaining_in_last_byte
-                expected_next_offset = item.bit_offset + bits_remaining_in_last_byte
-              end
+          next_offset = item.array_size
+        end
+      else
+        next_offset = nil
+        if item.bit_offset > 0
+          # Handle little-endian bit fields
+          byte_aligned = ((item.bit_offset % 8) == 0)
+          if item.endianness == :LITTLE_ENDIAN and (item.data_type == :INT or item.data_type == :UINT) and !(byte_aligned and (item.bit_size == 8 or item.bit_size == 16 or item.bit_size == 32 or item.bit_size == 64))
+            # Bit offset always refers to the most significant bit of a bitfield
+            bits_remaining_in_last_byte = 8 - (item.bit_offset % 8)
+            if item.bit_size > bits_remaining_in_last_byte
+              next_offset = item.bit_offset + bits_remaining_in_last_byte
             end
           end
-          unless expected_next_offset
-            if item.bit_size > 0
-              expected_next_offset = item.bit_offset + item.bit_size
-            else
-              expected_next_offset = item.bit_size
-            end
+        end
+        unless next_offset
+          if item.bit_size > 0
+            next_offset = item.bit_offset + item.bit_size
+          else
+            next_offset = item.bit_size
           end
         end
-        previous_item = item
       end
-      warnings
+      next_offset
     end
 
     # Id items are used by the identify? method to determine if a raw buffer of
@@ -338,6 +361,15 @@ module Cosmos
             synchronize_allow_reads() do
               if @read_conversion_cache[item]
                 value = @read_conversion_cache[item]
+
+                # Make sure cached value is not modified by anyone by creating
+                # a deep copy
+                if String === value
+                  value = value.clone
+                elsif Array === value
+                  value = Marshal.load(Marshal.dump(value))
+                end
+
                 using_cached_value = true
               end
             end
@@ -355,6 +387,14 @@ module Cosmos
               synchronize_allow_reads() do
                 @read_conversion_cache ||= {}
                 @read_conversion_cache[item] = value
+
+                # Make sure cached value is not modified by anyone by creating
+                # a deep copy
+                if String === value
+                  value = value.clone
+                elsif Array === value
+                  value = Marshal.load(Marshal.dump(value))
+                end
               end
             end
           end

data/lib/cosmos/packets/packet_config.rb

@@ -370,10 +370,51 @@ module Cosmos
                   attrs = { :name => (packet_name + '_Base'), :abstract => "true" }
                   xml['xtce'].SequenceContainer(attrs) do
                     xml['xtce'].EntryList do
+                      packed = packet.packed?
                       packet.sorted_items.each do |item|
                         next if item.data_type == :DERIVED
-                        # TODO: Handle explicit bit offset in packet and nonunique item names
-                        xml['xtce'].ParameterRefEntry(:parameterRef => item.name)
+                        # TODO: Handle nonunique item names
+                        if item.array_size
+                          xml['xtce'].ArrayParameterRefEntry(:parameterRef => item.name) do
+                            if !packed
+                              if item.bit_offset >= 0
+                                xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerStart') do
+                                  xml['xtce'].FixedValue(item.bit_offset)
+                                end
+                              else
+                                xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerEnd') do
+                                  xml['xtce'].FixedValue(-item.bit_offset)
+                                end
+                              end
+                            end
+                            xml['xtce'].DimensionList do
+                              xml['xtce'].Dimension do
+                                xml['xtce'].StartingIndex do
+                                  xml['xtce'].FixedValue(0)
+                                end
+                                xml['xtce'].EndingIndex do
+                                  xml['xtce'].FixedValue((item.array_size / item.bit_size) - 1)
+                                end
+                              end
+                            end
+                          end
+                        else
+                          if packed
+                            xml['xtce'].ParameterRefEntry(:parameterRef => item.name)
+                          else
+                            xml['xtce'].ParameterRefEntry(:parameterRef => item.name) do
+                              if item.bit_offset >= 0
+                                xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerStart') do
+                                  xml['xtce'].FixedValue(item.bit_offset)
+                                end
+                              else
+                                xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerEnd') do
+                                  xml['xtce'].FixedValue(-item.bit_offset)
+                                end
+                              end
+                            end
+                          end
+                        end
                       end
                     end
                   end # Abstract SequenceContainer
@@ -417,9 +458,50 @@ module Cosmos
                     end # ArgumentList
                     xml['xtce'].CommandContainer(:name => "#{target_name}_#{packet_name}_CommandContainer") do
                       xml['xtce'].EntryList do
+                        packed = packet.packed?
                         packet.sorted_items.each do |item|
                           next if item.data_type == :DERIVED
-                          xml['xtce'].ArgumentRefEntry(:argumentRef => item.name)
+                          if item.array_size
+                            xml['xtce'].ArrayArgumentRefEntry(:parameterRef => item.name) do
+                              if !packed
+                                if item.bit_offset >= 0
+                                  xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerStart') do
+                                    xml['xtce'].FixedValue(item.bit_offset)
+                                  end
+                                else
+                                  xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerEnd') do
+                                    xml['xtce'].FixedValue(-item.bit_offset)
+                                  end
+                                end
+                              end
+                              xml['xtce'].DimensionList do
+                                xml['xtce'].Dimension do
+                                  xml['xtce'].StartingIndex do
+                                    xml['xtce'].FixedValue(0)
+                                  end
+                                  xml['xtce'].EndingIndex do
+                                    xml['xtce'].FixedValue((item.array_size / item.bit_size) - 1)
+                                  end
+                                end
+                              end
+                            end
+                          else
+                            if packed
+                              xml['xtce'].ArgumentRefEntry(:argumentRef => item.name)
+                            else
+                              xml['xtce'].ArgumentRefEntry(:argumentRef => item.name) do
+                                if item.bit_offset >= 0
+                                  xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerStart') do
+                                    xml['xtce'].FixedValue(item.bit_offset)
+                                  end
+                                else
+                                  xml['xtce'].LocationInContainerInBits(:referenceLocation => 'containerEnd') do
+                                    xml['xtce'].FixedValue(-item.bit_offset)
+                                  end
+                                end
+                              end
+                            end
+                          end
                         end
                       end
                     end
@@ -492,11 +574,6 @@ module Cosmos
       if XTCE_IGNORED_ELEMENTS.include?(element.name)
         return false
       end
-      #~ if element.name == 'LongDescription'
-        #~ puts "#{'  ' * depth}<#{element.name}> #{xtce_format_attributes(element)} #{element.text}"
-      #~ else
-        #~ puts "#{'  ' * depth}<#{element.name}> #{xtce_format_attributes(element)}"
-      #~ end
 
       case element.name
       when 'SpaceSystem'
@@ -510,11 +587,17 @@ module Cosmos
         finish_packet()
         @current_cmd_or_tlm = COMMAND
 
-      when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet', 'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria', 'ComparisonList', 'MetaCommandSet', 'DefaultCalibrator', 'ArgumentTypeSet', 'ArgumentList', 'ArgumentAssignmentList'
+      when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet', 'EntryList', 'DefaultCalibrator', 'DefaultAlarm',
+        'RestrictionCriteria', 'ComparisonList', 'MetaCommandSet', 'DefaultCalibrator', '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 = OpenStruct.new
+        @current_type.endianness = :BIG_ENDIAN
         element.attributes.each do |att_name, att|
           @current_type[att.name] = att.value
         end
@@ -541,6 +624,30 @@ module Cosmos
           @current_type.sizeInBits = 8 # This is undocumented but appears to be the design
         end
 
+      when 'ArrayParameterType', 'ArrayArgumentType'
+        @current_type = OpenStruct.new
+        element.attributes.each do |att_name, att|
+          @current_type[att.name] = att.value
+        end
+        if element.name =~ /Argument/
+          @argument_types[element["name"]] = @current_type
+        else
+          @parameter_types[element["name"]] = @current_type
+        end
+
+      when 'ByteOrderList'
+        xtce_recurse_element(element, depth + 1) do |element, depth|
+          if element.name == 'Byte'
+            if element['byteSignificance'] and element['byteSignificance'].to_i == 0
+              @current_type.endianness = :LITTLE_ENDIAN
+            end
+            false
+          else
+            true
+          end
+        end
+        return false # Already recursed
+
       when "SizeInBits"
         xtce_recurse_element(element, depth + 1) do |element, depth|
           if element.name == 'FixedValue'
@@ -581,7 +688,7 @@ module Cosmos
       when 'PolynomialCalibrator'
         xtce_recurse_element(element, depth + 1) do |element, depth|
           if element.name == 'Term'
-            index = Integer(element['exponent'])
+            index = Float(element['exponent']).to_i
             coeff = Float(element['coefficient'])
             @current_type.conversion ||= PolynomialConversion.new([])
             @current_type.conversion.coeffs[index] = coeff
@@ -657,25 +764,80 @@ module Cosmos
           @current_packet.description = element.text
         end
 
-      when 'ParameterRefEntry', 'ArgumentRefEntry'
-        if element.name =~ /Argument/
-          # Look up the argument and argument type
-          argument = @arguments[element['argumentRef']]
-          raise "argumentRef #{element['argumentRef']} not found" unless argument
-          argument_type = @argument_types[argument.argumentTypeRef]
-          raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type
-          refName = 'argumentRef'
-          object = argument
-          type = argument_type
-        else
+      when 'ParameterRefEntry', 'ArgumentRefEntry', 'ArrayParameterRefEntry', 'ArrayArgumentRefEntry'
+        reference_location, bit_offset = xtce_handle_location_in_container_in_bits(element)
+
+        array_type = nil
+        array_bit_size = nil
+        if element.name =~ /Parameter/
           # Look up the parameter and parameter type
           parameter = @parameters[element['parameterRef']]
           raise "parameterRef #{element['parameterRef']} not found" unless parameter
           parameter_type = @parameter_types[parameter.parameterTypeRef]
           raise "parameterTypeRef #{parameter.parameterTypeRef} not found" unless parameter_type
+          if element.name == 'ArrayParameterRefEntry'
+            array_type = parameter_type
+            parameter_type = @parameter_types[array_type.arrayTypeRef]
+            raise "arrayTypeRef #{parameter.arrayTypeRef} not found" unless parameter_type
+          end
           refName = 'parameterRef'
           object = parameter
           type = parameter_type
+        else
+          # Look up the argument and argument type
+          if element.name == 'ArrayArgumentRefEntry'
+            # Requiring parameterRef for argument arrays appears to be a defect in the schema
+            argument = @arguments[element['parameterRef']]
+            raise "parameterRef #{element['parameterRef']} not found" unless argument
+            argument_type = @argument_types[argument.argumentTypeRef]
+            raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type
+            array_type = argument_type
+            argument_type = @argument_types[array_type.arrayTypeRef]
+            raise "arrayTypeRef #{array_type.arrayTypeRef} not found" unless argument_type
+            refName = 'parameterRef'
+          else
+            argument = @arguments[element['argumentRef']]
+            raise "argumentRef #{element['argumentRef']} not found" unless argument
+            argument_type = @argument_types[argument.argumentTypeRef]
+            raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type
+            refName = 'argumentRef'
+          end
+          object = argument
+          type = argument_type
+        end
+
+        bit_size = Integer(type.sizeInBits)
+
+        if array_type
+          array_num_items = 1
+          # Need to determine dimensions
+          xtce_recurse_element(element, depth + 1) do |element, depth|
+            if element.name == 'Dimension'
+              starting_index = 0
+              ending_index = 0
+              element.children.each do |child_element|
+                if child_element.name == 'StartingIndex'
+                  child_element.children.each do |child_element2|
+                    if child_element2.name == 'FixedValue'
+                      starting_index = child_element2.text.to_i
+                    end
+                  end
+                elsif child_element.name == 'EndingIndex'
+                  child_element.children.each do |child_element2|
+                    if child_element2.name == 'FixedValue'
+                      ending_index = child_element2.text.to_i
+                    end
+                  end
+                  array_num_items *= ((ending_index - starting_index).abs + 1)
+                end
+                false # Don't recurse again
+              end
+              false # Don't recurse again
+            else
+              true # Keep recursing
+            end
+          end
+          array_bit_size = array_num_items * bit_size
         end
 
         # Add item to packet
@@ -697,7 +859,21 @@ module Cosmos
           raise "Referenced Parameter/Argument has no xtce_encoding: #{element[refName]}"
         end
 
-        item = @current_packet.append_item(object.name, Integer(type.sizeInBits), data_type) #, array_size = nil, endianness = @default_endianness, overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
+        if bit_offset
+          case reference_location
+          when 'containerStart'
+            item = @current_packet.define_item(object.name, bit_offset, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
+          when 'containerEnd'
+            item = @current_packet.define_item(object.name, -bit_offset, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
+          when 'previousEntry', nil
+            item = @current_packet.define_item(object.name, @current_packet.length + bit_offset, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
+          when 'nextEntry'
+            raise 'nextEntry is not supported'
+          end
+        else
+          item = @current_packet.append_item(object.name, bit_size, data_type, array_bit_size, type.endianness) # overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
+        end
+
         item.description = type.shortDescription if type.shortDescription
         if type.states
           item.states = type.states
@@ -713,27 +889,24 @@ module Cosmos
           end
 
           # Need to set min, max, and default
-          if data_type == :INT
-            item.range = (-(2 ** (Integer(type.sizeInBits) - 1)))..((2 ** (Integer(type.sizeInBits) - 1)) - 1)
-            if type.minInclusive and type.maxInclusive
-              item.range = Integer(type.minInclusive)..Integer(type.maxInclusive)
-            end
-            item.default = 0
-            if item.states and item.states[type.initialValue.to_s.upcase]
-              item.default = Integer(item.states[type.initialvalue.to_s.upcase])
+          if data_type == :INT or data_type == :UINT
+            if data_type == :INT
+              item.range = (-(2 ** (Integer(type.sizeInBits) - 1)))..((2 ** (Integer(type.sizeInBits) - 1)) - 1)
             else
-              item.default = Integer(type.initialValue) if type.initialValue
+              item.range = 0..((2 ** Integer(type.sizeInBits)) - 1)
             end
-          elsif data_type == :UINT
-            item.range = 0..((2 ** Integer(type.sizeInBits)) - 1)
             if type.minInclusive and type.maxInclusive
               item.range = Integer(type.minInclusive)..Integer(type.maxInclusive)
             end
-            item.default = 0
-            if item.states and item.states[type.initialValue.to_s.upcase]
-              item.default = Integer(item.states[type.initialValue.to_s.upcase])
+            if item.array_size
+              item.default = []
             else
-              item.default = Integer(type.initialValue) if type.initialValue
+              item.default = 0
+              if item.states and item.states[type.initialValue.to_s.upcase]
+                item.default = Integer(item.states[type.initialValue.to_s.upcase])
+              else
+                item.default = Integer(type.initialValue) if type.initialValue
+              end
             end
           elsif data_type == :FLOAT
             if Integer(type.sizeInBits) == 32
@@ -744,19 +917,31 @@ module Cosmos
             if type.minInclusive and type.maxInclusive
               item.range = Float(type.minInclusive)..Float(type.maxInclusive)
             end
-            item.default = 0.0
-            item.default = Float(type.initialValue) if type.initialValue
+            if item.array_size
+              item.default = []
+            else
+              item.default = 0.0
+              item.default = Float(type.initialValue) if type.initialValue
+            end
           elsif data_type == :STRING
-            if type.initialValue
-              item.default = type.initialValue
+            if item.array_size
+              item.default = []
             else
-              item.default = ''
+              if type.initialValue
+                item.default = type.initialValue
+              else
+                item.default = ''
+              end
             end
           elsif data_type == :BLOCK
-            if type.initialValue
-              item.default = type.initialValue
+            if item.array_size
+              item.default = []
             else
-              item.default = ''
+              if type.initialValue
+                item.default = type.initialValue
+              else
+                item.default = ''
+              end
             end
           end
         else
@@ -774,6 +959,8 @@ module Cosmos
           end
         end
 
+        return false # Already recursed
+
       when 'BaseContainer'
         # Handled in SequenceContainer/CommandContainer
 
@@ -879,6 +1066,19 @@ module Cosmos
       end
     end
 
+    def xtce_handle_location_in_container_in_bits(element)
+      element.children.each do |child_element|
+        if child_element.name == 'LocationInContainerInBits'
+          child_element.children.each do |child_element2|
+            if child_element2.name == 'FixedValue'
+              return [child_element['referenceLocation'], Integer(child_element2.text)]
+            end
+          end
+        end
+      end
+      return [nil, nil]
+    end
+
     def process_current_packet(parser, keyword, params)
       case keyword
 
@@ -1079,9 +1279,9 @@ module Cosmos
         end
         usage = "MINIMUM_VALUE <MINIMUM VALUE>"
         parser.verify_num_parameters(1, 1, usage)
-        @current_item.range =
-          Range.new(ConfigParser.handle_defined_constants(
-            params[0].convert_to_value), @current_item.range.end)
+        min = ConfigParser.handle_defined_constants(
+          params[0].convert_to_value, @current_item.data_type, @current_item.bit_size)
+        @current_item.range = Range.new(min, @current_item.range.end)
 
       # Update the maximum value for the current command parameter
       when 'MAXIMUM_VALUE'
@@ -1090,9 +1290,9 @@ module Cosmos
         end
         usage = "MAXIMUM_VALUE <MAXIMUM VALUE>"
         parser.verify_num_parameters(1, 1, usage)
-        @current_item.range =
-          Range.new(@current_item.range.begin,
-                    ConfigParser.handle_defined_constants(params[0].convert_to_value))
+        max = ConfigParser.handle_defined_constants(
+          params[0].convert_to_value, @current_item.data_type, @current_item.bit_size)
+        @current_item.range = Range.new(@current_item.range.begin, max)
 
       # Update the default value for the current command parameter
       when 'DEFAULT_VALUE'
@@ -1105,8 +1305,8 @@ module Cosmos
             (@current_item.data_type == :BLOCK))
           @current_item.default = params[0]
         else
-          @current_item.default =
-            ConfigParser.handle_defined_constants(params[0].convert_to_value)
+          @current_item.default = ConfigParser.handle_defined_constants(
+            params[0].convert_to_value, @current_item.data_type, @current_item.bit_size)
         end
 
       # Update the overflow type for the current command parameter