openc3 6.10.2 → 6.10.3

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

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2025, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -24,6 +24,16 @@ require 'nokogiri'
 require 'openc3/packets/parsers/xtce_parser'
 require 'fileutils'
 
+DYNAMIC_STRING_LEN = 2048
+INVALID_CHARS = '[]./'
+REPLACEMENT_CHAR = '_'
+ALIAS_NAMESPACE = 'COSMOS'
+
+COMBINED_NAME = "COMBINED"
+MAX_64_BIT_INT = 18446744073709551614
+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
@@ -37,13 +47,74 @@ module OpenC3
     #   that were created while parsing the configuration
     # @param output_dir [String] The name of the output directory to generate
     #   the XTCE files. A file is generated for each target.
-    def self.convert(commands, telemetry, output_dir)
-      XtceConverter.new(commands, telemetry, output_dir)
+    def self.convert(commands, telemetry, output_dir, time_association_name)
+      XtceConverter.new(commands, telemetry, output_dir, time_association_name)
+    end
+
+    def self.combine_output_xtce(output_dir, root_target_name = nil)
+      combined_file_directory = File.join(output_dir, 'TARGETS_COMBINED', 'cmd_tlm')
+      begin
+        FileUtils.rm_rf(combined_file_directory)
+      rescue
+        # doesn't exist
+      end
+      file_pattern = File.join(output_dir, "**", "*.xtce")
+      xml_files = Dir.glob(file_pattern)
+      if xml_files.empty?
+          puts "No *.xtce files found to combine."
+      elsif xml_files.length == 1
+          puts "Only one *.xtce file found. No need to unify."
+      else
+        puts "Multiple targets found. Creating Unified XTCE representation."
+        FileUtils.mkdir_p(combined_file_directory)
+        file_basename = "combined"
+        xml_files.each do |file_path|
+          file_basename += "_#{File.basename(file_path, ".*")}"
+        end
+        full_file_name = File.join(combined_file_directory, file_basename.downcase + '.xtce')
+        begin
+          File.delete(full_file_name)
+        rescue
+          # Doesn't exist
+        end
+        xml_files.each do |file_path|
+          file_basename += File.basename(file_path, ".*")
+        end
+        root_builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml['xtce'].SpaceSystem("xmlns:xtce" => "http://www.omg.org/spec/XTCE/20180204",
+                                  "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+                                  "name" => root_target_name ? root_target_name : "root",
+                                  "xsi:schemaLocation" => "http://www.omg.org/spec/XTCE/20180204 https://www.omg.org/spec/XTCE/20180204/SpaceSystem.xsd")
+        end
+        new_doc = root_builder.doc
+        new_root = new_doc.root
+        xml_files.each do |file_path|
+          source_doc = Nokogiri::XML(File.open(file_path))
+          target_root = source_doc.root
+          target_root.attributes.each do |name, attr|
+            unless name == "name"
+              attr.remove
+            end
+          end
+          if root_target_name == target_root["name"]
+            nodes_to_add_reversed = target_root.children.to_a.reverse
+            nodes_to_add_reversed.each do |child_node|
+              new_root.prepend_child(child_node)
+            end
+          else
+            new_root.add_child(target_root)
+          end
+        end
+        File.open(full_file_name, 'w') do |file|
+          file.puts new_doc.to_xml
+        end
+        full_file_name
+      end
     end
 
     private
 
-    def initialize(commands, telemetry, output_dir)
+    def initialize(commands, telemetry, output_dir, time_association_name)
       FileUtils.mkdir_p(output_dir)
 
       # Build target list
@@ -52,6 +123,8 @@ module OpenC3
       commands.each { |target_name, packets| targets << target_name }
       targets.uniq!
 
+      @packet_time_string = time_association_name
+
       targets.each do |target_name|
         next if target_name == 'UNKNOWN'
 
@@ -69,12 +142,19 @@ module OpenC3
 
         # Create the xtce file for this target
         builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
-          xml['xtce'].SpaceSystem("xmlns:xtce" => "http://www.omg.org/space/xtce",
+          xml['xtce'].SpaceSystem("xmlns:xtce" => "http://www.omg.org/spec/XTCE/20180204",
                                   "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
                                   "name" => target_name,
-                                  "xsi:schemaLocation" => "http://www.omg.org/space/xtce http://www.omg.org/spec/XTCE/20061101/06-11-06.xsd") do
+                                  "xsi:schemaLocation" => "http://www.omg.org/spec/XTCE/20180204 https://www.omg.org/spec/XTCE/20180204/SpaceSystem.xsd") do
             create_telemetry(xml, telemetry, target_name)
-            create_commands(xml, commands, target_name)
+            # Get the Telemetry items to avoid clashing parameters
+            if telemetry[target_name]
+              unique_tlm_params = telemetry[target_name] ? get_unique(telemetry[target_name]) : {}
+            else
+              unique_tlm_params = {}
+            end
+            create_commands(xml, commands, target_name, unique_tlm_params)
+            create_algorithms(xml, telemetry, target_name)
           end # SpaceSystem
         end # builder
         File.open(filename, 'w') do |file|
@@ -83,8 +163,46 @@ module OpenC3
       end
     end
 
+    def create_algorithms(xml, telemetry, target_name)
+      return unless telemetry[target_name]
+      derived = {}
+      telemetry[target_name].each do |packet_name, packet|
+        packet.sorted_items.each do |item|
+          next if item.data_type != :DERIVED
+          next if COSMOS_NATIVE_DERIVED_ITEMS.include?(item.name)
+          next if item.name == @packet_time_string
+          derived[packet_name] = item
+        end
+      end
+      return unless derived.length > 0
+      algorithm_xml = Nokogiri::XML::Builder.new do |alg_xml|
+        alg_xml.AlgorithmSet do
+          derived.each do |packet_name, item|
+            alg_xml.CustomAlgorithm("name" => "#{packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_" \
+                                    "#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_#{item.read_conversion.class.name}") do
+              alg_xml.ExternalAlgorithmSet do
+                alg_xml.ExternalAlgorithm("implementationName" => "TODO", "algorithmLocation" => "TODO")
+              end
+              alg_xml.InputSet do
+                alg_xml.InputParameterInstanceRef( :parameterRef => "TODO", :instance => "0", :useCalibratedValue => "TODO")
+              end
+              alg_xml.OutputSet do
+                alg_xml.OutputParameterRef( :parameterRef => "#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}")
+              end
+              alg_xml.TriggerSet( :name => "triggerSet") do
+                alg_xml.OnParameterUpdateTrigger( :parameterRef => "TODO")
+              end
+            end
+          end
+        end
+      end
+      xml['xtce'].comment "TODO \n#{algorithm_xml.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION | Nokogiri::XML::Node::SaveOptions::FORMAT)}\n"
+    end
+
     def create_telemetry(xml, telemetry, target_name)
       # Gather and make unique all the packet items
+      return unless telemetry[target_name]
+
       unique_items = telemetry[target_name] ? get_unique(telemetry[target_name]) : {}
 
       xml['xtce'].TelemetryMetaData do
@@ -93,31 +211,39 @@ module OpenC3
             to_xtce_type(item, 'Parameter', xml)
           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)
+            to_xtce_item(item, 'Parameter', xml, has_packet_time: has_packet_time)
           end
         end
 
         if telemetry[target_name]
           xml['xtce'].ContainerSet do
             telemetry[target_name].each do |packet_name, packet|
-              attrs = { :name => (packet_name + '_Base'), :abstract => "true" }
-              xml['xtce'].SequenceContainer(attrs) do
-                process_entry_list(xml, packet, :TELEMETRY)
-              end
-
-              attrs = { :name => packet_name }
+              # Replaces invalid characters if any exist
+              attrs = { :name => packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR) }
               attrs['shortDescription'] = packet.description if packet.description
               xml['xtce'].SequenceContainer(attrs) do
-                xml['xtce'].EntryList
-                xml['xtce'].BaseContainer(:containerRef => (packet_name + '_Base')) do
+                # Adds an alias if any invalid characters exist
+                if packet_name.count(INVALID_CHARS) > 0
+                  xml['xtce'].AliasSet do
+                    xml['xtce'].Alias(:nameSpace => ALIAS_NAMESPACE, :alias => packet_name)
+                  end
+                end
+                if packet.short_buffer_allowed
+                  xml['xtce'].AncillaryDataSet do
+                    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
                     xml['xtce'].RestrictionCriteria do
                       xml['xtce'].ComparisonList do
                         packet.id_items.each do |item|
-                          xml['xtce'].Comparison(:parameterRef => item.name, :value => item.id_value)
+                          xml['xtce'].Comparison(:parameterRef => item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR), :value => item.id_value)
                         end
                       end
                     end
@@ -130,57 +256,136 @@ module OpenC3
       end # TelemetryMetaData
     end
 
-    def create_commands(xml, commands, target_name)
+    def create_commands(xml, commands, target_name, unique_tlm_params = {})
       return unless commands[target_name]
 
       xml['xtce'].CommandMetaData do
+        unique_id_items = get_unique_id_items(commands[target_name])
+        # Create Parameters for any ID item so it can be used in a comparison.
+        if unique_id_items.size > 0
+          xml['xtce'].ParameterTypeSet do
+            unique_id_items.each do |item_name, item|
+              prefix = unique_tlm_params.include?(item_name) ? "CMD_" : ""
+              to_xtce_type(item, 'Parameter', xml, prefix: prefix)
+            end
+          end
+          xml['xtce'].ParameterSet do
+            unique_id_items.each do |item_name, item|
+              prefix = unique_tlm_params.include?(item_name) ? "CMD_" : ""
+              to_xtce_item(item, 'Parameter', xml, prefix: prefix)
+            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
-          get_unique(commands[target_name]).each do |arg_name, arg|
-            to_xtce_type(arg, 'Argument', xml)
+          commands[target_name].each do |packet_name, packet|
+            packet.items.each do |arg_name, arg|
+              next if arg.data_type == :DERIVED
+              next if unique_id_items.key?(arg_name.tr(INVALID_CHARS, REPLACEMENT_CHAR))
+              to_xtce_type(arg, 'Argument', xml, prefix: packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + "_")
+            end
           end
         end
         xml['xtce'].MetaCommandSet do
           commands[target_name].each do |packet_name, packet|
-            attrs = { :name => packet_name + "_Base", :abstract => "true" }
-            xml['xtce'].MetaCommand(attrs) do
-              xml['xtce'].ArgumentList do
-                packet.sorted_items.each do |item|
-                  next if item.data_type == :DERIVED
-
-                  to_xtce_item(item, 'Argument', xml)
-                end
-              end # ArgumentList
-              xml['xtce'].CommandContainer(:name => "#{target_name}_#{packet_name}_CommandContainer") do
-                process_entry_list(xml, packet, :COMMAND)
-              end
-            end # Abstract MetaCommand
-
-            attrs = { :name => packet_name }
+            attrs = { :name => packet_name.tr(INVALID_CHARS, REPLACEMENT_CHAR) }
             attrs['shortDescription'] = packet.description if packet.description
             xml['xtce'].MetaCommand(attrs) do
-              xml['xtce'].BaseMetaCommand(:metaCommandRef => packet_name + "_Base") 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
+                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) + "_")
+                  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
-                  xml['xtce'].ArgumentAssignmentList do
-                    packet.id_items.each do |item|
-                      xml['xtce'].ArgumentAssignment(:argumentName => item.name, :argumentValue => item.id_value)
-                    end
-                  end # ArgumentAssignmentList
-                end
-              end # BaseMetaCommand
-            end # Actual MetaCommand
-          end # commands.each
+                  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
+                          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 # If id items
+              end # Command Container
+            end # MetaCommand
+          end # each command packet
         end # MetaCommandSet
       end # CommandMetaData
     end
 
+    def get_numerical_item_initial_value(item)
+      initial_value = nil
+      if item.states && item.default && !item.array_size
+        # Invert hash so we can get the initial value. If not found remove the initial value.
+        inverted_enum_states = item.states.invert
+        if inverted_enum_states.include?(item.default)
+          initial_value = inverted_enum_states[item.default]
+        end
+      elsif item.default && !item.array_size
+        initial_value = item.default
+      end
+      if initial_value == "1970-01-01T00:00:00Z"
+      initial_value = 0
+      end
+      initial_value
+    end
+
+    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?
+          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
+        end
+      end
+      initial_value
+    end
+
     def get_unique(items)
       unique = {}
       items.each do |packet_name, packet|
         packet.sorted_items.each do |item|
-          next if item.data_type == :DERIVED
+          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
 
-          unique[item.name] ||= []
-          unique[item.name] << item
+    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|
@@ -188,17 +393,45 @@ module OpenC3
           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] = unique_items[0]
       end
       unique
     end
 
+    def get_sorted_non_id_items(items)
+      sorted_items = []
+      items.each do |item|
+        next if item.data_type == :DERIVED
+        next if item.id_value
+        sorted_items.push(item)
+      end
+      sorted_items
+    end
+
+    def get_unique_id_items(items)
+      unique = {}
+      items.each do |packet_name, packet|
+        packet.id_items.each do |item|
+          next if item.data_type == :DERIVED
+          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.tr(INVALID_CHARS, REPLACEMENT_CHAR)] = unique_items[0]
+          next
+        end
+        unique[item_name.tr(INVALID_CHARS, REPLACEMENT_CHAR)] = unique_items[0]
+      end
+      unique
+    end
+
     # This method is almost the same for commands and telemetry except for the
     # XML element name: [Array]ArgumentRefEntry vs [Array]ParameterRefEntry,
     # and XML reference: argumentRef vs parameterRef.
     # Thus we build the name and use send to dynamically dispatch.
-    def process_entry_list(xml, packet, cmd_vs_tlm)
+    def process_entry_list(xml, packet, cmd_vs_tlm, unique_tlm_params = {})
       if cmd_vs_tlm == :COMMAND
         type = "Argument"
       else # :TELEMETRY
@@ -208,11 +441,12 @@ module OpenC3
         packed = packet.packed?
         packet.sorted_items.each do |item|
           next if item.data_type == :DERIVED
-
-          # TODO: Handle nonunique item names
+          temp_type = item.id_value ? "Parameter" : type
+          prefix = (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
-            xml['xtce'].public_send("Array#{type}RefEntry".intern, :parameterRef => item.name) do
+            reference_symbol = temp_type == "Argument" ? :parameterRef : "#{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
                 xml['xtce'].Dimension do
@@ -227,9 +461,9 @@ module OpenC3
             end
           else
             if packed
-              xml['xtce'].public_send("#{type}RefEntry".intern, "#{type.downcase}Ref".intern => item.name)
+              xml['xtce'].public_send("#{temp_type}RefEntry".intern, "#{temp_type.downcase}Ref".intern => prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR))
             else
-              xml['xtce'].public_send("#{type}RefEntry".intern, "#{type.downcase}Ref".intern => item.name) do
+              xml['xtce'].public_send("#{temp_type}RefEntry".intern, "#{temp_type.downcase}Ref".intern => prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)) do
                 set_fixed_value(xml, item)
               end
             end
@@ -250,29 +484,45 @@ module OpenC3
       end
     end
 
-    def to_xtce_type(item, param_or_arg, xml)
-      # TODO: Spline Conversions
+    def to_xtce_type(item, param_or_arg, xml, prefix: "")
       case item.data_type
       when :INT, :UINT
-        to_xtce_int(item, param_or_arg, xml)
+        to_xtce_int(item, param_or_arg, xml, prefix:prefix)
       when :FLOAT
-        to_xtce_float(item, param_or_arg, xml)
+        to_xtce_float(item, param_or_arg, xml, prefix: prefix)
       when :STRING
-        to_xtce_string(item, param_or_arg, xml, 'String')
+        to_xtce_string(item, param_or_arg, xml, 'String', prefix: prefix)
       when :BLOCK
-        to_xtce_string(item, param_or_arg, xml, 'Binary')
-      else
-        raise "#{item.data_type} data type not supported in XTCE"
+        to_xtce_string(item, param_or_arg, xml, 'Binary', prefix: prefix)
+      when :DERIVED
+        if !COSMOS_NATIVE_DERIVED_ITEMS.include?(item.name)
+          to_xtce_derived(item, param_or_arg, xml, prefix: prefix)
+        end
       end
 
       # Handle arrays
       if item.array_size
         # The above will have created the type for the array entries.   Now we create the type for the actual array.
-        attrs = { :name => (item.name + '_ArrayType') }
+
+        attrs = { :name => (prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + '_ArrayType') }
         attrs[:shortDescription] = item.description if item.description
-        attrs[:arrayTypeRef] = (item.name + '_Type')
-        attrs[:numberOfDimensions] = '1' # OpenC3 Only supports one-dimensional arrays
-        xml['xtce'].public_send('Array' + param_or_arg + 'Type', attrs)
+        attrs[:arrayTypeRef] = (prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + '_Type')
+        xml['xtce'].public_send('Array' + param_or_arg + 'Type', attrs) do
+          xml['xtce'].DimensionList do
+            xml['xtce'].Dimension do
+              xml['xtce'].StartingIndex do
+                xml['xtce'].FixedValue do
+                  xml['xtce'].text 0
+                end # FixedValue
+              end # StartingIndex
+              xml['xtce'].EndingIndex do
+                xml['xtce'].FixedValue do
+                  xml['xtce'].text 0 # OpenC3 Only supports one-dimensional arrays
+                end # FixedValue
+              end # EndingIndex
+            end # Dimension
+          end # DimensionList
+        end # Array<param_or_arg>Type
       end
     end
 
@@ -291,25 +541,38 @@ module OpenC3
       end
     end
 
-    def to_xtce_int(item, param_or_arg, xml)
-      attrs = { :name => (item.name + '_Type') }
+    def to_xtce_int(item, param_or_arg, xml, prefix: "")
+      attrs = { :name => (prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + '_Type') }
       attrs[:initialValue] = item.default if item.default and !item.array_size
       attrs[:shortDescription] = item.description if item.description
+      if attrs[:initialValue] == "1970-01-01T00:00:00Z"
+        attrs[:initialValue] = "0"
+      end
       if item.states and item.default and item.states.key(item.default)
         attrs[:initialValue] = item.states.key(item.default) and !item.array_size
       end
       if item.data_type == :INT
         signed = 'true'
-        encoding = 'twosCompliment'
+        encoding = 'twosComplement'
       else
         signed = 'false'
         encoding = 'unsigned'
       end
       if item.states
+        # Invert hash so we can get the initial value. If not found remove the initial value.
+        inverted_enum_states = item.states.invert
+        if inverted_enum_states.include?(item.default)
+          attrs[:initialValue] = inverted_enum_states[item.default]
+        else
+          attrs.delete(:initialValue)
+        end
         xml['xtce'].public_send('Enumerated' + param_or_arg + 'Type', attrs) do
-          to_xtce_endianness(item, xml)
           to_xtce_units(item, xml)
-          xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
+          if item.endianness == :LITTLE_ENDIAN and item.bit_size > 8
+            xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding, :byteOrder => "leastSignificantByteFirst")
+          else
+            xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
+          end
           xml['xtce'].EnumerationList do
             item.states.each do |state_name, state_value|
               # Skip the special OpenC3 'ANY' enumerated state
@@ -327,53 +590,86 @@ module OpenC3
           attrs[:signed] = signed
         end
         xml['xtce'].public_send(type_string, attrs) do
-          to_xtce_endianness(item, xml)
           to_xtce_units(item, xml)
           if (item.read_conversion and item.read_conversion.class == PolynomialConversion) or (item.write_conversion and item.write_conversion.class == PolynomialConversion)
-            xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding) do
-              to_xtce_conversion(item, xml)
+            if item.endianness == :LITTLE_ENDIAN and item.bit_size >= 8
+              xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding, :byteOrder => "leastSignificantByteFirst") do
+                to_xtce_conversion(item, xml)
+              end
+            else
+              xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding) do
+                to_xtce_conversion(item, xml)
+              end
             end
           else
-            xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
+            if item.endianness == :LITTLE_ENDIAN and item.bit_size >= 8
+              xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding, :byteOrder => "leastSignificantByteFirst")
+            else
+              xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
+            end
           end
           to_xtce_limits(item, xml)
-          if item.range
-            xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
+          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
 
-    def to_xtce_float(item, param_or_arg, xml)
-      attrs = { :name => (item.name + '_Type'), :sizeInBits => item.bit_size }
+    def to_xtce_float(item, param_or_arg, xml, prefix: "")
+      attrs = { :name => (prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR) + '_Type'), :sizeInBits => item.bit_size }
       attrs[:initialValue] = item.default if item.default and !item.array_size
       attrs[:shortDescription] = item.description if item.description
       xml['xtce'].public_send('Float' + param_or_arg + 'Type', attrs) do
-        to_xtce_endianness(item, xml)
         to_xtce_units(item, xml)
         if (item.read_conversion and item.read_conversion.class == PolynomialConversion) or (item.write_conversion and item.write_conversion.class == PolynomialConversion)
-          xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985') do
+          if item.endianness == :LITTLE_ENDIAN and item.bit_size >= 8
+            xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985', :byteOrder => "leastSignificantByteFirst") do
             to_xtce_conversion(item, xml)
           end
+          else
+            xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985') do
+              to_xtce_conversion(item, xml)
+            end
+          end
         else
-          xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985')
+          if item.endianness == :LITTLE_ENDIAN and item.bit_size >= 8
+            xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985', :byteOrder => "leastSignificantByteFirst")
+          else
+            xml['xtce'].FloatDataEncoding(:sizeInBits => item.bit_size, :encoding => 'IEEE754_1985')
+          end
         end
         to_xtce_limits(item, xml)
-        if item.range
-          xml['xtce'].ValidRange(:minInclusive => item.range.first, :maxInclusive => item.range.last)
+        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
     end
 
-    def to_xtce_string(item, param_or_arg, xml, string_or_binary)
-      # TODO: OpenC3 Variably sized strings are not supported in XTCE
-      attrs = { :name => (item.name + '_Type') }
+    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
-          attrs[:initialValue] = item.default.inspect
+          if string_or_binary == 'String'
+            attrs[:initialValue] = item.default.inspect
+          else
+            attrs[:initialValue] = item.default.inspect.unpack('H*').first
+          end
         end
       end
       attrs[:shortDescription] = item.description if item.description
@@ -384,10 +680,15 @@ module OpenC3
           xml['xtce'].StringDataEncoding(:encoding => 'UTF-8') do
             xml['xtce'].SizeInBits do
               xml['xtce'].Fixed do
-                xml['xtce'].FixedValue(item.bit_size.to_s)
-              end
-            end
-          end
+                if item.bit_size != 0
+                  xml['xtce'].FixedValue(item.bit_size.to_s)
+                else
+                  xml['xtce'].FixedValue(DYNAMIC_STRING_LEN)
+                end # if statement
+              end # </Fixed>
+              xml['xtce'].TerminationChar("00")
+            end # </SizeInBits>
+          end # </StringDataEncoding>
         else
           xml['xtce'].BinaryDataEncoding do
             xml['xtce'].SizeInBits do
@@ -398,11 +699,74 @@ module OpenC3
       end
     end
 
-    def to_xtce_item(item, param_or_arg, xml)
+    def to_xtce_derived(item, param_or_arg, xml, prefix: "")
+      if item.name == @packet_time_string
+        xml << "\n<!--TODO: \n" \
+               "\t<xtce:AbsoluteTime#{param_or_arg}Type name=\"#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_Type\">\n" \
+               "\t\t<TODO/>\n" \
+               "\t</xtce:AbsoluteTime#{param_or_arg}Type>"
+               "-->\n"
+      else
+        description_string = item.description ? "shortDescription=\"#{item.description}\"" : ""
+        xml << "\n<!--TODO: \n" \
+               "\t<xtce:TODO#{param_or_arg}Type name=\"#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_Type\" #{description_string} />\n" \
+               "-->\n"
+      end
+    end
+
+    def to_xtce_item(item, param_or_arg, xml, prefix: "", has_packet_time: false)
+      replaced_item_name = prefix + item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)
       if item.array_size
-        xml['xtce'].public_send(param_or_arg, :name => item.name, "#{param_or_arg.downcase}TypeRef" => item.name + '_ArrayType')
+        type_suffix = "_ArrayType"
+      else
+        type_suffix = "_Type"
+      end
+      attrs = {:name => replaced_item_name, "#{param_or_arg.downcase}TypeRef" => replaced_item_name + type_suffix}
+      needs_alias = item.name.count(INVALID_CHARS) > 0 || !prefix.empty?
+      if param_or_arg.downcase == "argument"
+        # Set the name to just be the item name since ArgumentsTypes
+        # will use the packet name as a prefix but not in the actual argument name.
+        # Maintains the individual type between arguments with a shared name.
+        needs_alias = item.name.count(INVALID_CHARS) > 0
+        attrs[:name] = item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)
+        initial_value = case item.data_type
+        when :INT, :UINT, :FLOAT
+          get_numerical_item_initial_value(item)
+        when :STRING, :BLOCK
+          get_string_or_block_initial_value(item, item.data_type)
+        when :DERIVED
+          nil
+        end
+        attrs[:initialValue] = initial_value
+      end
+      if item.data_type == :DERIVED
+        if COSMOS_NATIVE_DERIVED_ITEMS.include?(item.name)
+          return
+        end
+        parameter_comment = "\n<!-- TODO: \n" \
+                 "\t<xtce:#{param_or_arg} name=\"#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}\" #{param_or_arg.downcase}TypeRef=\"#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}_Type\">\n" \
+                 "\t\t<xtce:ParameterProperties dataSource=\"derived\"/>\n"
+
+        if needs_alias
+          parameter_comment += "\t\t<xtce:AliasSet>\n" \
+                 "\t\t\t<xtce:Alias nameSpace=\"COSMOS\" alias=\"#{item.name.tr(INVALID_CHARS, REPLACEMENT_CHAR)}\"/>\n" \
+                 "\t\t</xtce:AliasSet>\n"
+        end
+        parameter_comment += "\t</xtce:#{param_or_arg}>\n-->\n"
+        xml << parameter_comment
       else
-        xml['xtce'].public_send(param_or_arg, :name => item.name, "#{param_or_arg.downcase}TypeRef" => item.name + '_Type')
+        xml['xtce'].public_send(param_or_arg, attrs) do
+          if needs_alias
+            xml['xtce'].AliasSet do
+              xml['xtce'].Alias(:nameSpace => ALIAS_NAMESPACE, :alias => item.name)
+            end
+          end
+          if has_packet_time
+            xml['xtce'].ParameterProperties do
+              xml['xtce'].TimeAssociation(:parameterRef => @packet_time_string)
+            end
+          end
+        end
       end
     end
 
@@ -437,10 +801,10 @@ module OpenC3
           xml['xtce'].PolynomialCalibrator do
             conversion.coeffs.each_with_index do |coeff, index|
               xml['xtce'].Term(:coefficient => coeff, :exponent => index)
-            end
-          end
-        end
-      end
+            end # for each loop
+          end # </PolynomialCalibrator>
+        end # </DefaultCalibrator>
+      end # if PolynomialConversion
     end
   end
 end