openc3 5.14.0 → 5.14.2

data/lib/openc3/models/target_model.rb

@@ -869,6 +869,42 @@ module OpenC3
           )
         end
       end
+
+      # Inform microservices of new topics
+      # Need to tell loggers to log, and decom to decom
+      # We do this for no downtime
+      raw_topics = []
+      decom_topics = []
+      packets.each do |packet|
+        if cmd_or_tlm == :TELEMETRY
+          raw_topics << "#{@scope}__TELEMETRY__{#{@name}}__#{packet.packet_name.upcase}"
+          decom_topics << "#{@scope}__DECOM__{#{@name}}__#{packet.packet_name.upcase}"
+        else
+          raw_topics << "#{@scope}__COMMAND__{#{@name}}__#{packet.packet_name.upcase}"
+          decom_topics << "#{@scope}__DECOMCMD__{#{@name}}__#{packet.packet_name.upcase}"
+        end
+      end
+      if cmd_or_tlm == :TELEMETRY
+        Topic.write_topic("MICROSERVICE__#{@scope}__PACKETLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => raw_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__PACKETLOG__#{@name}", raw_topics)
+        Topic.write_topic("MICROSERVICE__#{@scope}__DECOMLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => decom_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__DECOMLOG__#{@name}", decom_topics)
+        Topic.write_topic("MICROSERVICE__#{@scope}__DECOM__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => raw_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__DECOM__#{@name}", raw_topics)
+      else
+        Topic.write_topic("MICROSERVICE__#{@scope}__COMMANDLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => raw_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__COMMANDLOG__#{@name}", raw_topics)
+        Topic.write_topic("MICROSERVICE__#{@scope}__DECOMCMDLOG__#{@name}", {'command' => 'ADD_TOPICS', 'topics' => decom_topics.as_json.to_json})
+        add_topics_to_microservice("#{@scope}__DECOMCMDLOG__#{@name}", decom_topics)
+      end
+    end
+
+    def add_topics_to_microservice(microservice_name, topics)
+      model = MicroserviceModel.get_model(name: microservice_name, scope: @scope)
+      model.topics.concat(topics)
+      model.topics.uniq!
+      model.ignore_changes = true # Don't restart the microservice right now
+      model.update
     end
 
     def deploy_commmandlog_microservice(gem_path, variables, topics, instance = nil, parent = nil)
@@ -1109,7 +1145,6 @@ module OpenC3
       decom_command_topic_list = []
       packet_topic_list = []
       decom_topic_list = []
-      reduced_topic_list = []
       begin
         system.commands.packets(@name).each do |packet_name, packet|
           command_topic_list << "#{@scope}__COMMAND__{#{@name}}__#{packet_name}"
@@ -1122,9 +1157,6 @@ module OpenC3
         system.telemetry.packets(@name).each do |packet_name, packet|
           packet_topic_list << "#{@scope}__TELEMETRY__{#{@name}}__#{packet_name}"
           decom_topic_list  << "#{@scope}__DECOM__{#{@name}}__#{packet_name}"
-          reduced_topic_list << "#{@scope}__REDUCED_MINUTE__{#{@name}}__#{packet_name}"
-          reduced_topic_list << "#{@scope}__REDUCED_HOUR__{#{@name}}__#{packet_name}"
-          reduced_topic_list << "#{@scope}__REDUCED_DAY__{#{@name}}__#{packet_name}"
         end
       rescue
         # No telemetry packets for this target

data/lib/openc3/operators/microservice_operator.rb

@@ -98,28 +98,30 @@ module OpenC3
           previous_parent = @previous_microservices[microservice_name]['parent']
           if @previous_microservices[microservice_name] != microservice_config
             # CHANGED
-            scope = microservice_name.split("__")[0]
-            Logger.info("Changed microservice detected: #{microservice_name}\nWas: #{@previous_microservices[microservice_name]}\nIs: #{microservice_config}", scope: scope)
-            if parent or previous_parent
-              if parent == previous_parent
-                # Same Parent - Respawn parent
-                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
-              elsif parent and previous_parent
-                # Parent changed - Respawn both parents
-                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
-                @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
-              elsif parent
-                # Moved under a parent - Respawn parent and kill standalone
-                @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
-                @removed_microservices[microservice_name] = microservice_config
-              else # previous_parent
-                # Moved to standalone - Respawn previous parent and make new
-                @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
-                @new_microservices[microservice_name] = microservice_config
+            if not microservice_config['ignore_changes']
+              scope = microservice_name.split("__")[0]
+              Logger.info("Changed microservice detected: #{microservice_name}\nWas: #{@previous_microservices[microservice_name]}\nIs: #{microservice_config}", scope: scope)
+              if parent or previous_parent
+                if parent == previous_parent
+                  # Same Parent - Respawn parent
+                  @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                elsif parent and previous_parent
+                  # Parent changed - Respawn both parents
+                  @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                  @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+                elsif parent
+                  # Moved under a parent - Respawn parent and kill standalone
+                  @changed_microservices[parent] = @microservices[parent] if @microservices[parent] and @previous_microservices[parent]
+                  @removed_microservices[microservice_name] = microservice_config
+                else # previous_parent
+                  # Moved to standalone - Respawn previous parent and make new
+                  @changed_microservices[previous_parent] = @microservices[previous_parent] if @microservices[previous_parent] and @previous_microservices[previous_parent]
+                  @new_microservices[microservice_name] = microservice_config
+                end
+              else
+                # Respawn regular microservice
+                @changed_microservices[microservice_name] = microservice_config
               end
-            else
-              # Respawn regular microservice
-              @changed_microservices[microservice_name] = microservice_config
             end
           end
         else

data/lib/openc3/packets/commands.rb

@@ -303,6 +303,10 @@ module OpenC3
       @config.commands
     end
 
+    def dynamic_add_packet(packet, affect_ids: false)
+      @config.dynamic_add_packet(packet, :COMMAND, affect_ids: affect_ids)
+    end
+
     protected
 
     def set_parameters(command, params, range_checking)

data/lib/openc3/packets/limits_response.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 # This file implements a class to handle responses to limits state changes.

data/lib/openc3/packets/packet_config.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 2024, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -31,6 +31,7 @@ require 'openc3/packets/parsers/format_string_parser'
 require 'openc3/packets/parsers/processor_parser'
 require 'openc3/packets/parsers/xtce_parser'
 require 'openc3/packets/parsers/xtce_converter'
+require 'openc3/utilities/python_proxy'
 require 'openc3/conversions'
 require 'openc3/processors'
 require 'nokogiri'
@@ -82,6 +83,9 @@ module OpenC3
     # defined by that identification.  Telemetry version
     attr_reader :tlm_id_value_hash
 
+    # @return [String] Language of current target (ruby or python)
+    attr_reader :language
+
     COMMAND = "Command"
     TELEMETRY = "Telemetry"
 
@@ -117,7 +121,7 @@ module OpenC3
     # @param filename [String] The name of the configuration file
     # @param process_target_name [String] The target name. Pass nil when parsing
     #   an xtce file to automatically determine the target name.
-    def process_file(filename, process_target_name)
+    def process_file(filename, process_target_name, language = 'ruby')
       # Handle .xtce files
       extension = File.extname(filename).to_s.downcase
       if extension == ".xtce" or extension == ".xml"
@@ -128,13 +132,14 @@ module OpenC3
       # Partial files are included into another file and thus aren't directly processed
       return if File.basename(filename)[0] == '_' # Partials start with underscore
 
+      @language = language
       @converted_type = nil
       @converted_bit_size = nil
       @proc_text = ''
       @building_generic_conversion = false
 
       process_target_name = process_target_name.upcase
-      parser = ConfigParser.new("https://openc3.com/docs/v5")
+      parser = ConfigParser.new("https://docs.openc3.com/docs")
       parser.instance_variable_set(:@target_name, process_target_name)
       parser.parse_file(filename) do |keyword, params|
         if @building_generic_conversion
@@ -258,7 +263,7 @@ module OpenC3
         rescue
           # Doesn't exist
         end
-        packets.each do |packet_name, packet|
+        packets.each do |_packet_name, packet|
           File.open(filename, 'a') do |file|
             file.puts packet.to_config(:TELEMETRY)
             file.puts ""
@@ -276,7 +281,7 @@ module OpenC3
         rescue
           # Doesn't exist
         end
-        packets.each do |packet_name, packet|
+        packets.each do |_packet_name, packet|
           File.open(filename, 'a') do |file|
             file.puts packet.to_config(:COMMAND)
             file.puts ""
@@ -315,30 +320,60 @@ module OpenC3
           hash = @cmd_id_value_hash[@current_packet.target_name]
           hash = {} unless hash
           @cmd_id_value_hash[@current_packet.target_name] = hash
-          update_id_value_hash(hash)
+          update_id_value_hash(@current_packet, hash)
         else
           @telemetry[@current_packet.target_name][@current_packet.packet_name] = @current_packet
           hash = @tlm_id_value_hash[@current_packet.target_name]
           hash = {} unless hash
           @tlm_id_value_hash[@current_packet.target_name] = hash
-          update_id_value_hash(hash)
+          update_id_value_hash(@current_packet, hash)
         end
         @current_packet = nil
         @current_item = nil
       end
     end
 
+    def dynamic_add_packet(packet, cmd_or_tlm = :TELEMETRY, affect_ids: false)
+      if cmd_or_tlm == :COMMAND
+        @commands[packet.target_name][packet.packet_name] = packet
+
+        if affect_ids
+          hash = @cmd_id_value_hash[packet.target_name]
+          hash = {} unless hash
+          @cmd_id_value_hash[packet.target_name] = hash
+          update_id_value_hash(packet, hash)
+        end
+      else
+        @telemetry[packet.target_name][packet.packet_name] = packet
+
+        # Update latest_data lookup for telemetry
+        packet.sorted_items.each do |item|
+          target_latest_data = @latest_data[packet.target_name]
+          target_latest_data[item.name] ||= []
+          latest_data_packets = target_latest_data[item.name]
+          latest_data_packets << packet unless latest_data_packets.include?(packet)
+        end
+
+        if affect_ids
+          hash = @tlm_id_value_hash[packet.target_name]
+          hash = {} unless hash
+          @tlm_id_value_hash[packet.target_name] = hash
+          update_id_value_hash(packet, hash)
+        end
+      end
+    end
+
     protected
 
-    def update_id_value_hash(hash)
-      if @current_packet.id_items.length > 0
+    def update_id_value_hash(packet, hash)
+      if packet.id_items.length > 0
         key = []
-        @current_packet.id_items.each do |item|
+        packet.id_items.each do |item|
           key << item.id_value
         end
-        hash[key] = @current_packet
+        hash[key] = packet
       else
-        hash['CATCHALL'.freeze] = @current_packet
+        hash['CATCHALL'.freeze] = packet
       end
     end
 
@@ -394,7 +429,7 @@ module OpenC3
 
       # Define a processor class that will be called once when a packet is received
       when 'PROCESSOR'
-        ProcessorParser.parse(parser, @current_packet, @current_cmd_or_tlm)
+        ProcessorParser.parse(parser, @current_packet, @current_cmd_or_tlm, @language)
 
       when 'DISABLE_MESSAGES'
         usage = "#{keyword}"
@@ -433,18 +468,27 @@ module OpenC3
         parser.verify_num_parameters(0, 0, usage)
         @current_packet.hidden = true
         @current_packet.disabled = true
+
       when 'ACCESSOR'
         usage = "#{keyword} <Accessor class name>"
         parser.verify_num_parameters(1, nil, usage)
         begin
-          klass = OpenC3.require_class(params[0])
-          if params.length > 1
-            @current_packet.accessor = klass.new(@current_packet, *params[1..-1])
+          if @language == 'ruby'
+            klass = OpenC3.require_class(params[0])
+            if params.length > 1
+              @current_packet.accessor = klass.new(@current_packet, *params[1..-1])
+            else
+              @current_packet.accessor = klass.new(@current_packet)
+            end
           else
-            @current_packet.accessor = klass.new(@current_packet)
+            if params.length > 1
+              @current_packet.accessor = PythonProxy.new('Accessor', params[0], @current_packet, *params[1..-1])
+            else
+              @current_packet.accessor = PythonProxy.new('Accessor', params[0], @current_packet)
+            end
           end
-        rescue Exception => err
-          raise parser.error(err)
+        rescue Exception => e
+          raise parser.error(e)
         end
 
       when 'TEMPLATE'
@@ -458,8 +502,8 @@ module OpenC3
 
         begin
           @current_packet.template = parser.read_file(params[0])
-        rescue Exception => err
-          raise parser.error(err)
+        rescue Exception => e
+          raise parser.error(e)
         end
 
       when 'RESPONSE'
@@ -500,16 +544,19 @@ module OpenC3
         usage = "#{keyword} <conversion class filename> <custom parameters> ..."
         parser.verify_num_parameters(1, nil, usage)
         begin
-          klass = OpenC3.require_class(params[0])
-          conversion = klass.new(*params[1..(params.length - 1)])
-          @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
-          if klass != ProcessorConversion and (conversion.converted_type.nil? or conversion.converted_bit_size.nil?)
-            msg = "Read Conversion #{params[0]} on item #{@current_item.name} does not specify converted type or bit size"
-            @warnings << msg
-            Logger.instance.warn @warnings[-1]
+          if @language == 'ruby'
+            klass = OpenC3.require_class(params[0])
+            conversion = klass.new(*params[1..(params.length - 1)])
+            @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
+            if klass != ProcessorConversion and (conversion.converted_type.nil? or conversion.converted_bit_size.nil?)
+              msg = "Read Conversion #{params[0]} on item #{@current_item.name} does not specify converted type or bit size"
+              @warnings << msg
+              Logger.instance.warn @warnings[-1]
+            end
+          else
+            conversion = PythonProxy.new('Conversion', params[0], *params[1..(params.length - 1)])
+            @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
           end
-        rescue Exception => err
-          raise parser.error(err)
         end
 
       # Apply a polynomial conversion to the current item
@@ -570,7 +617,7 @@ module OpenC3
       # Define a response class that will be called when the limits state of the
       # current item changes.
       when 'LIMITS_RESPONSE'
-        LimitsResponseParser.parse(parser, @current_item, @current_cmd_or_tlm)
+        LimitsResponseParser.parse(parser, @current_item, @current_cmd_or_tlm, @language)
 
       # Define a printf style formatting string for the current telemetry item
       when 'FORMAT_STRING'

data/lib/openc3/packets/packet_item.rb

@@ -23,6 +23,7 @@
 require 'openc3/packets/structure_item'
 require 'openc3/packets/packet_item_limits'
 require 'openc3/conversions/conversion'
+require 'openc3/utilities/python_proxy'
 require 'openc3/io/json_rpc' # Includes needed as_json code
 
 module OpenC3
@@ -129,7 +130,7 @@ module OpenC3
 
     def read_conversion=(read_conversion)
       if read_conversion
-        raise ArgumentError, "#{@name}: read_conversion must be a OpenC3::Conversion but is a #{read_conversion.class}" unless OpenC3::Conversion === read_conversion
+        raise ArgumentError, "#{@name}: read_conversion must be a OpenC3::Conversion but is a #{read_conversion.class}" unless OpenC3::Conversion === read_conversion or OpenC3::PythonProxy === read_conversion
 
         @read_conversion = read_conversion.clone
       else
@@ -139,7 +140,7 @@ module OpenC3
 
     def write_conversion=(write_conversion)
       if write_conversion
-        raise ArgumentError, "#{@name}: write_conversion must be a OpenC3::Conversion but is a #{write_conversion.class}" unless OpenC3::Conversion === write_conversion
+        raise ArgumentError, "#{@name}: write_conversion must be a OpenC3::Conversion but is a #{write_conversion.class}" unless OpenC3::Conversion === write_conversion or OpenC3::PythonProxy === write_conversion
 
         @write_conversion = write_conversion.clone
       else

data/lib/openc3/packets/packet_item_limits.rb

@@ -21,6 +21,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/packets/limits_response'
+require 'openc3/utilities/python_proxy'
 
 module OpenC3
   # Maintains knowledge of limits for a PacketItem
@@ -96,7 +97,7 @@ module OpenC3
 
     def response=(response)
       if response
-        raise ArgumentError, "response must be a OpenC3::LimitsResponse but is a #{response.class}" unless OpenC3::LimitsResponse === response
+        raise ArgumentError, "response must be a OpenC3::LimitsResponse but is a #{response.class}" unless OpenC3::LimitsResponse === response or OpenC3::PythonProxy === response
 
         @response = response.clone
       else

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

@@ -14,26 +14,29 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2023, OpenC3, Inc.
+# All changes Copyright 2024, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/utilities/python_proxy'
+
 module OpenC3
   class LimitsResponseParser
     # @param parser [ConfigParser] Configuration parser
     # @param item [Packet] The current item
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
-    def self.parse(parser, item, cmd_or_tlm)
-      parser = LimitsResponseParser.new(parser)
+    def self.parse(parser, item, cmd_or_tlm, language = 'ruby')
+      parser = LimitsResponseParser.new(parser, language)
       parser.verify_parameters(cmd_or_tlm)
       parser.create_limits_response(item)
     end
 
     # @param parser [ConfigParser] Configuration parser
-    def initialize(parser)
+    def initialize(parser, language = 'ruby')
       @parser = parser
+      @language = language
     end
 
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
@@ -48,15 +51,23 @@ module OpenC3
 
     # @param item [PacketItem] The item the limits response should be added to
     def create_limits_response(item)
-      klass = OpenC3.require_class(@parser.parameters[0])
+      if @language == 'ruby'
+        klass = OpenC3.require_class(@parser.parameters[0])
 
-      if @parser.parameters[1]
-        item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])
+        if @parser.parameters[1]
+          item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])
+        else
+          item.limits.response = klass.new
+        end
       else
-        item.limits.response = klass.new
+        if @parser.parameters[1]
+          item.limits.response = PythonProxy.new('LimitsResponse', @parser.parameters[0], *@parser.parameters[1..(@parser.parameters.length - 1)])
+        else
+          item.limits.response = PythonProxy.new('LimitsResponse', @parser.parameters[0], [])
+        end
       end
-    rescue Exception => err
-      raise @parser.error(err, @usage)
+    rescue Exception => e
+      raise @parser.error(e, @usage)
     end
   end
 end

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

@@ -21,21 +21,23 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/processors'
+require 'openc3/utilities/python_proxy'
 
 module OpenC3
   class ProcessorParser
     # @param parser [ConfigParser] Configuration parser
     # @param packet [Packet] The current packet
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
-    def self.parse(parser, packet, cmd_or_tlm)
-      parser = ProcessorParser.new(parser)
+    def self.parse(parser, packet, cmd_or_tlm, language = 'ruby')
+      parser = ProcessorParser.new(parser, language)
       parser.verify_parameters(cmd_or_tlm)
       parser.create_processor(packet)
     end
 
     # @param parser [ConfigParser] Configuration parser
-    def initialize(parser)
+    def initialize(parser, language = 'ruby')
       @parser = parser
+      @language = language
     end
 
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
@@ -50,16 +52,23 @@ module OpenC3
 
     # @param packet [Packet] The packet the processor should be added to
     def create_processor(packet)
-      # require should be performed in target.txt
-      klass = OpenC3.require_class(@parser.parameters[1])
+      if @language == 'ruby'
+        # require should be performed in target.txt
+        klass = OpenC3.require_class(@parser.parameters[1])
 
-      if @parser.parameters[2]
-        processor = klass.new(*@parser.parameters[2..(@parser.parameters.length - 1)])
+        if @parser.parameters[2]
+          processor = klass.new(*@parser.parameters[2..(@parser.parameters.length - 1)])
+        else
+          processor = klass.new
+        end
+        raise ArgumentError, "processor must be a OpenC3::Processor but is a #{processor.class}" unless OpenC3::Processor === processor
       else
-        processor = klass.new
+        if @parser.parameters[2]
+          processor = PythonProxy.new('Processor', @parser.parameters[1], *@parser.parameters[2..(@parser.parameters.length - 1)])
+        else
+          processor = PythonProxy.new('Processor', @parser.parameters[1], [])
+        end
       end
-      raise ArgumentError, "processor must be a OpenC3::Processor but is a #{processor.class}" unless OpenC3::Processor === processor
-
       processor.name = get_processor_name()
       packet.processors[processor.name] = processor
     rescue Exception => err

data/lib/openc3/packets/telemetry.rb

@@ -442,5 +442,9 @@ module OpenC3
     def all
       @config.telemetry
     end
+
+    def dynamic_add_packet(packet, affect_ids: false)
+      @config.dynamic_add_packet(packet, :TELEMETRY, affect_ids: affect_ids)
+    end
   end # class Telemetry
 end

data/lib/openc3/system/system.rb

@@ -60,6 +60,9 @@ module OpenC3
     # The current limits set
     @@limits_set = nil
 
+    # Callbacks to call once @@instance is created
+    @@post_instance_callbacks = []
+
     # @return [Symbol] The current limits_set of the system returned from Redis
     def self.limits_set
       unless @@limits_set
@@ -72,6 +75,14 @@ module OpenC3
       @@limits_set = value.to_s.intern
     end
 
+    def self.add_post_instance_callback(callback)
+      if @@instance
+        callback.call()
+      else
+        @@post_instance_callbacks << callback
+      end
+    end
+
     def self.setup_targets(target_names, base_dir, scope:)
       # Nothing to do if there are no targets
       return if target_names.nil? or target_names.length == 0
@@ -121,11 +132,30 @@ module OpenC3
       raise "System.instance parameters are required on first call" unless target_names and target_config_dir
 
       @@instance_mutex.synchronize do
+        return @@instance if @@instance
         @@instance ||= self.new(target_names, target_config_dir)
+        @@post_instance_callbacks.each do |callback|
+          callback.call
+        end
         return @@instance
       end
     end
 
+    # Dynamically add packets to the system instance
+    #
+    # @param dynamic_packets [Array of packets]
+    # @param cmd_or_tlm [Symbol] :COMMAND or :TELEMETRY
+    # @param affect_ids [Boolean] Whether to affect packet id lookup or not
+    def self.dynamic_update(dynamic_packets, cmd_or_tlm = :TELEMETRY, affect_ids: false)
+      dynamic_packets.each do |packet|
+        if cmd_or_tlm == :TELEMETRY
+          @@instance.telemetry.dynamic_add_packet(packet, affect_ids: affect_ids)
+        else
+          @@instance.commands.dynamic_add_packet(packet, affect_ids: affect_ids)
+        end
+      end
+    end
+
     # Create a new System object.
     #
     # @param target_names [Array of target names]
@@ -149,7 +179,7 @@ module OpenC3
       @targets[target.name] = target
       errors = [] # Store all errors processing the cmd_tlm files
       target.cmd_tlm_files.each do |cmd_tlm_file|
-        @packet_config.process_file(cmd_tlm_file, target.name)
+        @packet_config.process_file(cmd_tlm_file, target.name, target.language)
       rescue Exception => error
         errors << "Error processing #{cmd_tlm_file}:\n#{error.message}"
       end