openc3 7.2.0 → 7.3.0

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

@@ -24,15 +24,46 @@ INVALID_CHARS = '[]./'
 REPLACEMENT_CHAR = '_'
 ALIAS_NAMESPACE = 'COSMOS'
 
-COMBINED_NAME = "COMBINED"
-MAX_64_BIT_INT = 18446744073709551614
+# IntegerRangeType declares minInclusive / maxInclusive as xs:long, so an integer range
+# outside these bounds (a full 64 bit UINT, for example) cannot be expressed as a
+# ValidRange. FloatRangeType uses xs:double and needs no such clamp.
+XS_LONG_MIN = -9223372036854775808
+XS_LONG_MAX = 9223372036854775807
 COSMOS_NATIVE_DERIVED_ITEMS = ['PACKET_TIMESECONDS', 'PACKET_TIMEFORMATTED', 'RECEIVED_TIMESECONDS', 'RECEIVED_TIMEFORMATTED', 'RECEIVED_COUNT']
-PACKET_TIME_STRING = "PACKET_TIME"
 
 module OpenC3
   class XtceConverter
     attr_accessor :current_target_name
 
+    # The namespace COSMOS exports. Files declaring an older namespace still import.
+    XTCE_1_2_NAMESPACE = 'http://www.omg.org/spec/XTCE/20180204'
+    # The OMG schemas are vendored here and validation reads them from disk, so it works
+    # air gapped. The omg.org URL the files declare in schemaLocation is never fetched.
+    SCHEMA_DIR = File.join(PATH, 'data', 'xtce_schemas')
+    SCHEMA_FILE = File.join(SCHEMA_DIR, 'SpaceSystem_20180204.xsd')
+
+    # The XTCE namespace an existing .xtce file declares on its root element
+    #
+    # @param filename [String] Path to a .xtce file
+    # @return [String, nil] The declared namespace, or nil if the file has none
+    def self.xtce_namespace(filename)
+      Nokogiri::XML(File.read(filename)).root&.namespace&.href
+    end
+
+    # Validate an .xtce file against the vendored OMG XTCE 1.2 schema
+    #
+    # Only meaningful for files declaring XTCE_1_2_NAMESPACE. XTCE 1.0 / 1.1 files
+    # import fine but report errors against this schema, so check xtce_namespace first.
+    #
+    # @param filename [String] Path to a .xtce file
+    # @return [Array<String>] Validation error messages, empty when the file is valid
+    def self.schema_errors(filename)
+      # File.open, not File.read: the schema imports xml.xsd relative to itself, which
+      # Nokogiri can only resolve from the IO's path
+      @schema ||= File.open(SCHEMA_FILE) { |f| Nokogiri::XML::Schema(f) }
+      @schema.validate(Nokogiri::XML(File.read(filename))).map(&:message)
+    end
+
     # Output a previously parsed definition file into the XTCE format
     #
     # @param commands [Hash<String=>Packet>] Hash of all the command packets
@@ -206,19 +237,24 @@ module OpenC3
       # Gather and make unique all the packet items
       return unless telemetry[target_name]
 
-      unique_items = telemetry[target_name] ? get_unique(telemetry[target_name]) : {}
+      unique_items = get_unique(telemetry[target_name])
+      has_packet_time = unique_items.include?(@packet_time_string)
 
       xml['xtce'].TelemetryMetaData do
-        xml['xtce'].ParameterTypeSet do
-          unique_items.each do |item_name, item|
-            to_xtce_type(item, 'Parameter', xml)
+        # The schema requires at least one child in each set, so emit neither when the
+        # target's packets hold nothing but DERIVED items. DERIVED items produce a TODO
+        # comment at most, never a ParameterType, so they don't count here.
+        if unique_items.any? { |_item_name, item| item.data_type != :DERIVED }
+          xml['xtce'].ParameterTypeSet do
+            unique_items.each do |item_name, item|
+              to_xtce_type(item, 'Parameter', xml)
+            end
           end
-        end
-        has_packet_time = unique_items.include?(@packet_time_string)
 
-        xml['xtce'].ParameterSet do
-          unique_items.each do |item_name, item|
-            to_xtce_item(item, 'Parameter', xml, has_packet_time: has_packet_time)
+          xml['xtce'].ParameterSet do
+            unique_items.each do |item_name, item|
+              to_xtce_item(item, 'Parameter', xml, has_packet_time: has_packet_time)
+            end
           end
         end
 
@@ -228,6 +264,20 @@ module OpenC3
               # Replaces invalid characters if any exist
               attrs = { :name => packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR) }
               attrs['shortDescription'] = packet.description if packet.description
+              container_name = packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR)
+              has_id_items = (packet.id_items && packet.id_items.length > 0)
+
+              # RestrictionCriteria only exists on a BaseContainer, so a packet with ID
+              # items needs something to inherit from: an abstract container holding the
+              # entries, which the concrete container then restricts. Pointing the
+              # BaseContainer at its own container instead would make it inherit from
+              # itself, which is a cycle for any consumer that resolves inheritance.
+              if has_id_items
+                xml['xtce'].SequenceContainer(:name => "#{container_name}_Base", :abstract => "true") do
+                  process_entry_list(xml, packet, :TELEMETRY)
+                end
+              end
+
               xml['xtce'].SequenceContainer(attrs) do
                 # Adds an alias if any invalid characters exist
                 if packet_name.count(INVALID_CHARS) > 0
@@ -240,9 +290,10 @@ module OpenC3
                     xml['xtce'].AncillaryData("true", :name => "ALLOW_SHORT")
                   end
                 end
-                process_entry_list(xml, packet, :TELEMETRY)
-                xml['xtce'].BaseContainer(:containerRef => (packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR))) do
-                  if packet.id_items && packet.id_items.length > 0
+                if has_id_items
+                  # The entries come from the base container. EntryList is required.
+                  xml['xtce'].EntryList
+                  xml['xtce'].BaseContainer(:containerRef => "#{container_name}_Base") do
                     xml['xtce'].RestrictionCriteria do
                       xml['xtce'].ComparisonList do
                         packet.id_items.each do |item|
@@ -251,6 +302,8 @@ module OpenC3
                       end
                     end
                   end
+                else
+                  process_entry_list(xml, packet, :TELEMETRY)
                 end
               end # SequenceContainer
             end # telemetry.each
@@ -279,8 +332,6 @@ module OpenC3
             end
           end
         end
-        #unique_command_args_without_ids = get_unique_without_ids(commands[target_name])
-        #if unique_command_args_without_ids.size > 0
         xml['xtce'].ArgumentTypeSet do
           commands[target_name].each do |packet_name, packet|
             packet.items.each do |arg_name, arg|
@@ -292,36 +343,64 @@ module OpenC3
         end
         xml['xtce'].MetaCommandSet do
           commands[target_name].each do |packet_name, packet|
-            attrs = { :name => packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR) }
+            command_name = packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR)
+            attrs = { :name => command_name }
             attrs['shortDescription'] = packet.description if packet.description
+            argument_list_sorted_items = get_sorted_non_id_items(packet.sorted_items)
+            has_id_items = (packet.id_items && packet.id_items.length > 0)
+
+            # Like telemetry above, the ID comparisons live in a RestrictionCriteria,
+            # which only exists on a BaseContainer, so emit an abstract MetaCommand
+            # holding the arguments and entries for the concrete one to inherit and
+            # restrict. Referencing its own CommandContainer would be a cycle.
+            if has_id_items
+              xml['xtce'].MetaCommand(:name => "#{command_name}_Base", :abstract => "true") do
+                if argument_list_sorted_items.size > 0
+                  xml['xtce'].ArgumentList do
+                    argument_list_sorted_items.each do |item|
+                      to_xtce_item(item, 'Argument', xml, prefix: command_name + "_")
+                    end
+                  end # ArgumentList
+                end
+                xml['xtce'].CommandContainer(:name => "#{command_name}_CommandsBase") do
+                  process_entry_list(xml, packet, :COMMAND, unique_tlm_params)
+                end # Command Container
+              end # MetaCommand
+            end
+
             xml['xtce'].MetaCommand(attrs) do
               if packet_name.count(INVALID_CHARS) > 0
                 xml['xtce'].AliasSet do
                   xml['xtce'].Alias(:nameSpace => ALIAS_NAMESPACE, :alias => packet_name)
                 end # AliasSet
               end # If packet contains invalid chars
-              argument_list_sorted_items = get_sorted_non_id_items(packet.sorted_items)
-              if argument_list_sorted_items.size > 0
+              if has_id_items
+                xml['xtce'].BaseMetaCommand(:metaCommandRef => "#{command_name}_Base")
+              elsif argument_list_sorted_items.size > 0
                 xml['xtce'].ArgumentList do
                   argument_list_sorted_items.each do |item|
-                    to_xtce_item(item, 'Argument', xml, prefix: packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + "_")
+                    to_xtce_item(item, 'Argument', xml, prefix: command_name + "_")
                   end
                 end # ArgumentList
               end # If Arguments List is greater than 0
-              xml['xtce'].CommandContainer(:name => "#{packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_Commands") do
-                process_entry_list(xml, packet, :COMMAND, unique_tlm_params)
-                  #xml['xtce'].BaseContainer(:containerRef => "#{target_name}_#{packet_name}_CommandContainer")
-                if packet.id_items && packet.id_items.length > 0
-                  packet.id_items.each do |item|
-                    xml['xtce'].BaseContainer(:containerRef => "#{packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_Commands") do
-                      xml['xtce'].RestrictionCriteria do
-                        xml['xtce'].ComparisonList do
+              xml['xtce'].CommandContainer(:name => "#{command_name}_Commands") do
+                if has_id_items
+                  # The entries come from the base container. EntryList is required.
+                  xml['xtce'].EntryList
+                  # A CommandContainer allows only one BaseContainer, so emit all ID
+                  # comparisons in a single RestrictionCriteria/ComparisonList.
+                  xml['xtce'].BaseContainer(:containerRef => "#{command_name}_CommandsBase") do
+                    xml['xtce'].RestrictionCriteria do
+                      xml['xtce'].ComparisonList do
+                        packet.id_items.each do |item|
                           item_prefix = unique_tlm_params.include?(item.name) ? "CMD_" : ""
                           xml['xtce'].Comparison(:parameterRef => item_prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR),:value => item.id_value)
                         end
-                      end # Restriction Criteria
-                    end # Base Container
-                  end # for each packet ID item
+                      end
+                    end # Restriction Criteria
+                  end # Base Container
+                else
+                  process_entry_list(xml, packet, :COMMAND, unique_tlm_params)
                 end # If id items
               end # Command Container
             end # MetaCommand
@@ -347,17 +426,34 @@ module OpenC3
       initial_value
     end
 
+    # Ending index of an array item's single dimension. XTCE indices are inclusive, so
+    # an array of N elements ends at N - 1. A non-positive bit size means a variable
+    # length array whose element count isn't known at export time, reported as a single
+    # element.
+    def array_ending_index(item)
+      return 0 if item.bit_size <= 0 || item.array_size <= 0
+
+      (item.array_size / item.bit_size) - 1
+    end
+
+    # Initial value for a String or Binary type. Pass :BLOCK / 'Binary' for binary
+    # items and :STRING / 'String' for string items.
     def get_string_or_block_initial_value(item, string_or_binary)
       initial_value = nil
       if item.default && !item.array_size
-        unless item.default.is_printable?
+        if string_or_binary == :BLOCK || string_or_binary == 'Binary'
+          # Binary initialValue is xs:hexBinary: raw hex digits, no 0x prefix
+          initial_value = item.default.simple_formatted
+        elsif !item.default.is_printable? || item.default.upcase.start_with?('0X')
+          # XML can't carry the non printable bytes of a string default, so COSMOS
+          # writes them as a 0x prefixed hex escape. A printable default that starts
+          # with 0x has to be escaped the same way, otherwise the importer reads it
+          # back as binary and "0xABCD" round trips as the bytes \xAB\xCD.
           initial_value = '0x' + item.default.simple_formatted
         else
-          if string_or_binary == :STRING
-            initial_value = item.default.inspect
-          else
-            initial_value = item.default.inspect.unpack('H*').first
-          end
+          # String initialValue is the value itself. Quoting it (inspect) would make
+          # the quotes part of the default for anything but our own importer.
+          initial_value = item.default
         end
       end
       initial_value
@@ -381,26 +477,6 @@ module OpenC3
       unique
     end
 
-    def get_unique_without_ids(items)
-      unique = {}
-      items.each do |packet_name, packet|
-        packet.sorted_items.each do |item|
-          next if item.data_type == :DERIVED
-          next if item.id_value
-          unique[item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)] ||= []
-          unique[item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)] << item
-        end
-      end
-      unique.each do |item_name, unique_items|
-        if unique_items.length <= 1
-          unique[item_name] = unique_items[0]
-          next
-        end
-        unique[item_name] = unique_items[0]
-      end
-      unique
-    end
-
     def get_sorted_non_id_items(items)
       sorted_items = []
       items.each do |item|
@@ -445,10 +521,15 @@ module OpenC3
         packet.sorted_items.each do |item|
           next if item.data_type == :DERIVED
           temp_type = item.id_value ? "Parameter" : type
-          prefix = (cmd_vs_tlm == :COMMAND && unique_tlm_params.include?(item.name)) ? "CMD_" : ""
+          # Only ID items become Parameters in CommandMetaData, where a name shared with
+          # a telemetry parameter is a real collision and gets a CMD_ prefix. Arguments
+          # are scoped to their MetaCommand and are declared unprefixed, so prefixing the
+          # reference here would point at an Argument that doesn't exist.
+          prefix = (temp_type == "Parameter" && cmd_vs_tlm == :COMMAND && unique_tlm_params.include?(item.name)) ? "CMD_" : ""
           if item.array_size
-            # Requiring parameterRef for argument arrays appears to be a defect in the schema
-            reference_symbol = temp_type == "Argument" ? :parameterRef : "#{temp_type.downcase}Ref".to_sym
+            # XTCE 1.2 defines dedicated argumentRef/parameterRef attributes for
+            # Array{Argument,Parameter}RefEntry, so derive the reference from the type.
+            reference_symbol = "#{temp_type.downcase}Ref".to_sym
             xml['xtce'].public_send("Array#{temp_type}RefEntry".intern, reference_symbol => prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)) do
               set_fixed_value(xml, item) if !packed
               xml['xtce'].DimensionList do
@@ -457,7 +538,7 @@ module OpenC3
                     xml['xtce'].FixedValue(0)
                   end
                   xml['xtce'].EndingIndex do
-                    xml['xtce'].FixedValue((item.array_size / item.bit_size) - 1)
+                    xml['xtce'].FixedValue(array_ending_index(item))
                   end
                 end
               end
@@ -520,7 +601,9 @@ module OpenC3
               end # StartingIndex
               xml['xtce'].EndingIndex do
                 xml['xtce'].FixedValue do
-                  xml['xtce'].text 0 # OpenC3 Only supports one-dimensional arrays
+                  # OpenC3 only supports one-dimensional arrays, which is the single
+                  # Dimension above. The indices give that dimension's length.
+                  xml['xtce'].text array_ending_index(item)
                 end # FixedValue
               end # EndingIndex
             end # Dimension
@@ -611,16 +694,10 @@ module OpenC3
               xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
             end
           end
+          # ValidRange comes from IntegerDataType and DefaultAlarm from
+          # IntegerParameterType, which extends it, so ValidRange must be emitted first.
+          to_xtce_valid_range(item, param_or_arg, xml)
           to_xtce_limits(item, xml)
-          if item.range and item.range.last <= MAX_64_BIT_INT
-            if param_or_arg == "Parameter"
-              xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
-            else
-              xml['xtce'].ValidRangeSet do
-                xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
-              end
-            end
-          end
         end # Type
       end # if item.states
     end
@@ -648,15 +725,35 @@ module OpenC3
             xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985')
           end
         end
+        # ValidRange comes from FloatDataType and DefaultAlarm from FloatParameterType,
+        # which extends it, so ValidRange must be emitted first.
+        to_xtce_valid_range(item, param_or_arg, xml)
         to_xtce_limits(item, xml)
-        if item.range and item.range.last < MAX_64_BIT_INT
-          if param_or_arg == "Parameter"
-            xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
-          else
-            xml['xtce'].ValidRangeSet do
-                xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
-            end
-          end
+      end
+    end
+
+    # Emit the item minimum / maximum as an XTCE ValidRange. Arguments wrap it in a
+    # ValidRangeSet; parameters use a bare ValidRange.
+    def to_xtce_valid_range(item, param_or_arg, xml)
+      return unless item.range
+
+      minimum = item.range.first
+      maximum = item.range.last
+      if item.data_type == :INT or item.data_type == :UINT
+        # IntegerRangeType is xs:long, so a wider range (a full 64 bit UINT, for
+        # example) can't be expressed and is dropped rather than emitted invalid.
+        return if minimum < XS_LONG_MIN or maximum > XS_LONG_MAX
+      else
+        # FloatRangeType is xs:double, which covers any finite float. Infinity and NaN
+        # have no valid xs:double lexical form here, so skip them.
+        return unless minimum.finite? and maximum.finite?
+      end
+
+      if param_or_arg == "Parameter"
+        xml['xtce'].ValidRange(:minInclusive => minimum, :maxInclusive => maximum)
+      else
+        xml['xtce'].ValidRangeSet do
+          xml['xtce'].ValidRange(:minInclusive => minimum, :maxInclusive => maximum)
         end
       end
     end
@@ -664,20 +761,11 @@ module OpenC3
     def to_xtce_string(item, param_or_arg, xml, string_or_binary, prefix: "")
       attrs = { :name => (prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + '_Type') }
       attrs[:characterWidth] = 8 if string_or_binary == 'String'
-      if item.default && !item.array_size
-        unless item.default.is_printable?
-          attrs[:initialValue] = '0x' + item.default.simple_formatted
-        else
-          if string_or_binary == 'String'
-            attrs[:initialValue] = item.default.inspect
-          else
-            attrs[:initialValue] = item.default.inspect.unpack('H*').first
-          end
-        end
-      end
+      initial_value = get_string_or_block_initial_value(item, string_or_binary)
+      attrs[:initialValue] = initial_value if initial_value
       attrs[:shortDescription] = item.description if item.description
       xml['xtce'].public_send(string_or_binary + param_or_arg + 'Type', attrs) do
-        # Don't call to_xtce_endianness for Strings or Blocks
+        # Strings and Blocks don't get a byteOrder
         to_xtce_units(item, xml)
         if string_or_binary == 'String'
           xml['xtce'].StringDataEncoding(:encoding => 'UTF-8') do
@@ -764,7 +852,9 @@ module OpenC3
               xml['xtce'].Alias(:nameSpace => ALIAS_NAMESPACE, :alias => item.name)
             end
           end
-          if has_packet_time
+          # The time item is the source of the association, so it doesn't get one -
+          # pointing it at itself says a parameter is its own timestamp.
+          if has_packet_time && item.name != @packet_time_string
             xml['xtce'].ParameterProperties do
               xml['xtce'].TimeAssociation(:parameterRef => @packet_time_string)
             end
@@ -783,16 +873,6 @@ module OpenC3
       end
     end
 
-    def to_xtce_endianness(item, xml)
-      if item.endianness == :LITTLE_ENDIAN and item.bit_size > 8
-        xml['xtce'].ByteOrderList do
-          (((item.bit_size - 1) / 8) + 1).times do |byte_significance|
-            xml['xtce'].Byte(:byteSignificance => byte_significance)
-          end
-        end
-      end
-    end
-
     def to_xtce_conversion(item, xml)
       if item.read_conversion
         conversion = item.read_conversion

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

@@ -154,7 +154,10 @@ module OpenC3
       current_type
     end
 
-    XTCE_IGNORED_ELEMENTS = ['text', 'AliasSet', 'Alias', 'Header']
+    XTCE_IGNORED_ELEMENTS = ['text', 'Alias', 'Header']
+
+    # Namespace COSMOS writes its own item names into when the XTCE name had to differ
+    COSMOS_ALIAS_NAMESPACE = 'COSMOS'
 
     def xtce_process_element(element)
       if XTCE_IGNORED_ELEMENTS.include?(element.name)
@@ -418,6 +421,30 @@ module OpenC3
         end
         @arguments[element["name"]] = @current_argument
 
+      when 'AliasSet'
+        # COSMOS records the original item name here whenever it had to write a different
+        # one: a name containing characters XTCE forbids, or the CMD_ prefix that keeps a
+        # command ID item from colliding with a telemetry parameter of the same name.
+        # Restoring it means a name survives an export / import round trip. References
+        # elsewhere in the document still use the XTCE name, which is what the parameter
+        # and argument lookups are keyed by, so nothing else has to change.
+        cosmos_alias = element.elements.find do |child|
+          child.name == 'Alias' && child['nameSpace'] == COSMOS_ALIAS_NAMESPACE
+        end
+        if cosmos_alias and cosmos_alias['alias']
+          case element.parent&.name
+          when 'Parameter'
+            @current_parameter&.cosmos_name = cosmos_alias['alias']
+          when 'Argument'
+            @current_argument&.cosmos_name = cosmos_alias['alias']
+          else
+            # Do Nothing - COSMOS also writes aliases on SequenceContainer, MetaCommand
+            # and SpaceSystem to carry the original packet and target names. Those are
+            # not restored: a packet is registered under its name as soon as it is
+            # created, so renaming it here would leave the registration disagreeing.
+          end
+        end
+
       when 'ParameterProperties'
         element.attributes.each do |att_name, att|
           @current_parameter[att.name] = att.value
@@ -452,8 +479,10 @@ module OpenC3
         # Handled in MetaCommand
 
       when 'Comparison'
-        # Need to set ID value for item
-        item = @current_packet.get_item(element['parameterRef'])
+        # Need to set ID value for item. The reference is the XTCE name, which is not the
+        # item's name when an alias restored the original.
+        parameter = @parameters[element['parameterRef']]
+        item = @current_packet.get_item(parameter ? cosmos_item_name(parameter) : element['parameterRef'])
         item.id_value = Integer(element['value'])
         if @current_cmd_or_tlm == PacketConfig::COMMAND
           item.default = item.id_value
@@ -476,8 +505,9 @@ module OpenC3
         xtce_handle_base_container('BaseContainer', element)
 
       when 'ArgumentAssignment'
-        # Need to set ID value for item
-        item = @current_packet.get_item(element['argumentName'])
+        # Need to set ID value for item, by the item's name rather than the XTCE name
+        argument = @arguments[element['argumentName']]
+        item = @current_packet.get_item(argument ? cosmos_item_name(argument) : element['argumentName'])
         value = element['argumentValue']
         if item.states && item.states[value.to_s.upcase]
           item.id_value = item.states[value.to_s.upcase]
@@ -496,9 +526,16 @@ module OpenC3
       return true # Recurse further
     end
 
+    # The COSMOS name of a parameter / argument: its alias when the XTCE name had to
+    # differ from it, otherwise the XTCE name itself
+    def cosmos_item_name(object)
+      object.cosmos_name || object.name
+    end
+
     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)
+      item_name = cosmos_item_name(object)
       bit_size = Integer(type.sizeInBits)
       if array_type
         array_bit_size = process_array_type(element, bit_size)
@@ -509,16 +546,18 @@ module OpenC3
       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)
+          item = @current_packet.define_item(item_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)
+          item = @current_packet.define_item(item_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)
+          # Packet#length is bytes while the location is bits, so the offset is measured
+          # from the end of what has been defined so far in bits
+          item = @current_packet.define_item(item_name, (@current_packet.length * 8) + 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)
+        item = @current_packet.append_item(item_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
@@ -534,15 +573,15 @@ module OpenC3
       if /Parameter/.match?(element.name)
         # Look up the parameter and parameter type
         parameter = @parameters[element['parameterRef']]
-        raise "parameterRef #{element['parameterRef']} not found" unless parameter
+        raise "parameterRef #{element['parameterRef']} not found (parameter lookup)" unless parameter
 
         parameter_type = @parameter_types[parameter.parameterTypeRef]
-        raise "parameterTypeRef #{parameter.parameterTypeRef} not found" unless parameter_type
+        raise "parameterTypeRef #{parameter.parameterTypeRef} not found (parameter type lookup)" 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
+          raise "arrayTypeRef #{parameter.arrayTypeRef} not found (array parameter type)" unless parameter_type
         end
         refName = 'parameterRef'
         object = parameter
@@ -550,24 +589,25 @@ module OpenC3
       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
+          # XTCE 1.2 requires argumentRef on ArrayArgumentRefEntry. Older XTCE
+          # (1.0/1.1) and files exported by prior COSMOS versions used parameterRef
+          # here (a defect in those schemas), so accept it as a fallback.
+          refName = element['argumentRef'] ? 'argumentRef' : 'parameterRef'
+          argument = @arguments[element[refName]]
+          raise "#{refName} #{element[refName]} not found (array argument lookup)" unless argument
 
           argument_type = @argument_types[argument.argumentTypeRef]
-          raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type
+          raise "argumentTypeRef #{argument.argumentTypeRef} not found (array argument type lookup)" 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'
+          raise "arrayTypeRef #{array_type.arrayTypeRef} not found (array argument element type)" unless argument_type
         else
           argument = @arguments[element['argumentRef']]
-          raise "argumentRef #{element['argumentRef']} not found" unless argument
+          raise "argumentRef #{element['argumentRef']} not found (argument lookup)" unless argument
 
           argument_type = @argument_types[argument.argumentTypeRef]
-          raise "argumentTypeRef #{argument.argumentTypeRef} not found" unless argument_type
+          raise "argumentTypeRef #{argument.argumentTypeRef} not found (argument type lookup)" unless argument_type
 
           refName = 'argumentRef'
         end
@@ -692,10 +732,18 @@ module OpenC3
           item.default = []
         else
           if type.initialValue
-            if type.initialValue.upcase.start_with?("0X")
+            if data_type == :BLOCK
+              # Binary initialValue is xs:hexBinary (raw hex, optional 0x prefix)
+              begin
+                item.default = type.initialValue.hex_to_byte_string
+              rescue ArgumentError, TypeError => e
+                raise "#{item.name} initialValue '#{type.initialValue}' is not valid hexBinary (#{e.message})"
+              end
+            elsif type.initialValue.upcase.start_with?("0X")
               item.default = type.initialValue.hex_to_byte_string
             else
-              # Strip quotes from strings
+              # Strip the quotes COSMOS 7.2 and earlier wrote around string defaults.
+              # Current exports write the value unquoted.
               if type.initialValue[0] == '"' && type.initialValue[-1] == '"'
                 item.default = type.initialValue[1..-2]
               else