openc3 5.12.0 → 5.14.0

data/lib/openc3/models/target_model.rb

@@ -742,7 +742,7 @@ module OpenC3
       end
     end
 
-    def update_store(system)
+    def update_target_model(system)
       target = system.targets[@name]
 
       # Add in the information from the target and update
@@ -754,10 +754,11 @@ module OpenC3
       @tlm_unique_id_mode = target.tlm_unique_id_mode
       @limits_groups = system.limits.groups.keys
       update()
+    end
 
-      # Store Packet Definitions
-      system.telemetry.all.each do |target_name, packets|
-        Store.del("#{@scope}__openc3tlm__#{target_name}")
+    def update_store_telemetry(packet_hash, clear_old: true)
+      packet_hash.each do |target_name, packets|
+        Store.del("#{@scope}__openc3tlm__#{target_name}") if clear_old
         packets.each do |packet_name, packet|
           Logger.info "Configuring tlm packet: #{target_name} #{packet_name}"
           begin
@@ -773,8 +774,11 @@ module OpenC3
           CvtModel.set(json_hash, target_name: packet.target_name, packet_name: packet.packet_name, scope: @scope)
         end
       end
-      system.commands.all.each do |target_name, packets|
-        Store.del("#{@scope}__openc3cmd__#{target_name}")
+    end
+
+    def update_store_commands(packet_hash, clear_old: true)
+      packet_hash.each do |target_name, packets|
+        Store.del("#{@scope}__openc3cmd__#{target_name}") if clear_old
         packets.each do |packet_name, packet|
           Logger.info "Configuring cmd packet: #{target_name} #{packet_name}"
           begin
@@ -785,7 +789,9 @@ module OpenC3
           end
         end
       end
-      # Store Limits Groups
+    end
+
+    def update_store_limits_groups(system)
       system.limits.groups.each do |group, items|
         begin
           Store.hset("#{@scope}__limits_groups", group, JSON.generate(items))
@@ -794,23 +800,77 @@ module OpenC3
           raise err
         end
       end
-      # Merge in Limits Sets
+    end
+
+    def update_store_limits_sets(system)
       sets = Store.hgetall("#{@scope}__limits_sets")
       sets ||= {}
       system.limits.sets.each do |set|
         sets[set.to_s] = "false" unless sets.key?(set.to_s)
       end
       Store.hmset("#{@scope}__limits_sets", *sets)
+    end
 
+    def update_store_item_map
       # Create item_map
       item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
       item_map = self.class.build_item_to_packet_map(@name, scope: @scope)
       Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
       @@item_map_cache[@name] = [Time.now, item_map]
+    end
 
+    def update_store(system, clear_old: true)
+      update_target_model(system)
+      update_store_telemetry(system.telemetry.all, clear_old: clear_old)
+      update_store_commands(system.commands.all, clear_old: clear_old)
+      update_store_limits_groups(system)
+      update_store_limits_sets(system)
+      update_store_item_map()
       return system
     end
 
+    def dynamic_update(packets, cmd_or_tlm = :TELEMETRY, filename = "dynamic_tlm.txt")
+      # Build hash of targets/packets
+      packet_hash = {}
+      packets.each do |packet|
+        target_name = packet.target_name.upcase
+        packet_hash[target_name] ||= {}
+        packet_name = packet.packet_name.upcase
+        packet_hash[target_name][packet_name] = packet
+      end
+
+      # Update Redis
+      if cmd_or_tlm == :TELEMETRY
+        update_store_telemetry(packet_hash, clear_old: false)
+        update_store_item_map()
+      else
+        update_store_commands(packet_hash, clear_old: false)
+      end
+
+      # Build dynamic file for cmd_tlm
+      configs = {}
+      packets.each do |packet|
+        target_name = packet.target_name.upcase
+        configs[target_name] ||= ""
+        config = configs[target_name]
+        config << packet.to_config(cmd_or_tlm)
+        config << "\n"
+      end
+      configs.each do |target_name, config|
+        begin
+          bucket_key = "#{@scope}/targets_modified/#{target_name}/cmd_tlm/#{filename}"
+          client = Bucket.getClient()
+          client.put_object(
+            # Use targets_modified to save modifications
+            # This keeps the original target clean (read-only)
+            bucket: ENV['OPENC3_CONFIG_BUCKET'],
+            key: bucket_key,
+            body: config
+          )
+        end
+      end
+    end
+
     def deploy_commmandlog_microservice(gem_path, variables, topics, instance = nil, parent = nil)
       microservice_name = "#{@scope}__COMMANDLOG#{instance}__#{@name}"
       microservice = MicroserviceModel.new(
@@ -990,6 +1050,7 @@ module OpenC3
           cmd: ["ruby", "multi_microservice.rb", *@children],
           work_dir: '/openc3/lib/openc3/microservices',
           plugin: @plugin,
+          needs_dependencies: @needs_dependencies,
           scope: @scope
         )
         microservice.create

data/lib/openc3/packets/json_packet.rb

@@ -65,66 +65,97 @@ module OpenC3
     # @param name [String] Name of the item to read - Should already by upcase
     # @param value_type (see #read_item)
     def read(name, value_type = :CONVERTED, reduced_type = nil)
+      value = nil
+      array_index = nil
+      if name[-1] == ']'
+        open_bracket_index = name.index('[')
+        if open_bracket_index
+          array_index = name[(open_bracket_index + 1)..-2].to_i
+          name = name[0..(open_bracket_index - 1)]
+        end
+      end
       if reduced_type
         raise "Reduced types only support RAW or CONVERTED value types: #{value_type} unsupported" if value_type == :WITH_UNITS or value_type == :FORMATTED
         if value_type == :CONVERTED
           case reduced_type
           when :AVG
             value = @json_hash["#{name}__CA"]
-            return value if value
           when :STDDEV
             value = @json_hash["#{name}__CS"]
-            return value if value
           when :MIN
             value = @json_hash["#{name}__CN"]
-            return value if value
           when :MAX
             value = @json_hash["#{name}__CX"]
-            return value if value
+          end
+          if value
+            value = value[array_index] if array_index
+            return value
           end
         end
         case reduced_type
         when :AVG
           value = @json_hash["#{name}__A"]
-          return value if value
         when :STDDEV
           value = @json_hash["#{name}__S"]
-          return value if value
         when :MIN
           value = @json_hash["#{name}__N"]
-          return value if value
         when :MAX
           value = @json_hash["#{name}__X"]
-          return value if value
+        end
+        if value
+          value = value[array_index] if array_index
+          return value
         end
       end
       if value_type == :WITH_UNITS
         value = @json_hash["#{name}__U"]
-        return value if value
+        if value
+          value = value[array_index] if array_index
+          return value
+        end
       end
       if value_type == :WITH_UNITS or value_type == :FORMATTED
         value = @json_hash["#{name}__F"]
-        return value if value
+        if value
+          value = value[array_index] if array_index
+          return value
+        end
 
         value = @json_hash["#{name}__C"]
-        return value.to_s if value
+        if value
+          value = value[array_index] if array_index
+          return value.to_s
+        end
 
         value = @json_hash[name]
-        return value.to_s if value
+        if value
+          value = value[array_index] if array_index
+          return value.to_s
+        end
 
         return nil
       end
       if value_type == :CONVERTED
         value = @json_hash["#{name}__C"]
-        return value if value
+        if value
+          value = value[array_index] if array_index
+          return value
+        end
       end
-      return @json_hash[name]
+      value = @json_hash[name]
+      if value
+        value = value[array_index] if array_index
+        return value
+      end
+      return nil
     end
 
     def read_with_limits_state(name, value_type = :CONVERTED, reduced_type = nil)
       value = read(name, value_type, reduced_type)
       limits_state = @json_hash["#{name}__L"]
-      limits_state.intern if limits_state
+      if limits_state
+        limits_state = limits_state.intern
+      end
       return [value, limits_state]
     end
 

data/lib/openc3/packets/packet.rb

@@ -89,6 +89,18 @@ module OpenC3
     # @return [String] Base data for building packet
     attr_reader :template
 
+    # @return [Array<Target Name, Packet Name>] Related response packet
+    attr_accessor :response
+
+    # @return [Array<Target Name, Packet Name>] Related error response packet
+    attr_accessor :error_response
+
+    # @return [Array<Target Name, Screen Name>] Related telemetry screen
+    attr_accessor :screen
+
+    # @return [Array<Array<Target Name, Packet Name, Item Name>>] Related items
+    attr_accessor :related_items
+
     # Valid format types
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
 
@@ -297,6 +309,10 @@ module OpenC3
       @config_name
     end
 
+    def clear_config_name
+      @config_name = nil
+    end
+
     # (see Structure#buffer=)
     def buffer=(buffer)
       synchronize() do
@@ -306,7 +322,6 @@ module OpenC3
           Logger.instance.error "#{@target_name} #{@packet_name} received with actual packet length of #{buffer.length} but defined length of #{@defined_length}"
         end
         @read_conversion_cache.clear if @read_conversion_cache
-        process()
       end
     end
 
@@ -861,6 +876,33 @@ module OpenC3
       item.description = 'OpenC3 packet received count'
     end
 
+    # Reset the packet to just derived items
+    def clear_all_non_derived_items
+      @defined_length = 0
+      @defined_length_bits = 0
+      @pos_bit_size = 0
+      @neg_bit_size = 0
+      @fixed_size = true
+      @short_buffer_allowed = false
+      @id_items = nil
+      @limits_items = nil
+      new_items = {}
+      new_sorted_items = []
+      @items.each do |name, item|
+        if item.data_type == :DERIVED
+          new_items[name] = item
+        end
+      end
+      @sorted_items.each do |item|
+        if item.data_type == :DERIVED
+          new_sorted_items << item
+        end
+      end
+      @items = new_items
+      @sorted_items = new_sorted_items
+      clear_config_name()
+    end
+
     # Enable limits on an item by name
     #
     # @param name [String] Name of the item to enable limits
@@ -1008,6 +1050,13 @@ module OpenC3
       else
         config << "COMMAND #{@target_name.to_s.quote_if_necessary} #{@packet_name.to_s.quote_if_necessary} #{@default_endianness} \"#{@description}\"\n"
       end
+      if @accessor.class.to_s != 'OpenC3::BinaryAccessor'
+        config << "  ACCESSOR #{@accessor.class.to_s} #{@accessor.args.map { |a| a.to_s.quote_if_necessary }.join(" ")}\n"
+      end
+      # TODO: Add TEMPLATE_ENCODED so this can always be done inline regardless of content
+      if @template
+        config << "  TEMPLATE '#{@template}'"
+      end
       config << "  ALLOW_SHORT\n" if @short_buffer_allowed
       config << "  HAZARDOUS #{@hazardous_description.to_s.quote_if_necessary}\n" if @hazardous
       config << "  DISABLE_MESSAGES\n" if @messages_disabled
@@ -1025,7 +1074,7 @@ module OpenC3
 
       if @meta
         @meta.each do |key, values|
-          config << "  META #{key.to_s.quote_if_necessary} #{values.map { |a| a..to_s.quote_if_necessary }.join(" ")}\n"
+          config << "  META #{key.to_s.quote_if_necessary} #{values.map { |a| a.to_s.quote_if_necessary }.join(" ")}\n"
         end
       end
 
@@ -1043,6 +1092,20 @@ module OpenC3
         end
       end
 
+      if @response
+        config << "  RESPONSE #{@response[0].to_s.quote_if_necessary} #{@response[1].to_s.quote_if_necessary}"
+      end
+      if @error_response
+        config << "  ERROR_RESPONSE #{@error_response[0].to_s.quote_if_necessary} #{@error_response[1].to_s.quote_if_necessary}"
+      end
+      if @screen
+        config << "  SCREEN #{@screen[0].to_s.quote_if_necessary} #{@screen[1].to_s.quote_if_necessary}"
+      end
+      if @related_items
+        @related_items.each do |target_name, packet_name, item_name|
+          config << "  RELATED_ITEM #{target_name.to_s.quote_if_necessary} #{packet_name.to_s.quote_if_necessary} #{item_name.to_s.quote_if_necessary}"
+        end
+      end
       config
     end
 
@@ -1086,6 +1149,18 @@ module OpenC3
           items << item.as_json(*a)
         end
       end
+      if @response
+        config['response'] = @response
+      end
+      if @error_response
+        config['error_response'] = @error_response
+      end
+      if @screen
+        config['screen'] = @screen
+      end
+      if @related_items
+        config['related_items'] = @related_items
+      end
 
       config
     end
@@ -1117,6 +1192,19 @@ module OpenC3
       hash['items'].each do |item|
         packet.define(PacketItem.from_json(item))
       end
+      if hash['response']
+        packet.response = hash['response']
+      end
+      if hash['error_response']
+        packet.error_response = hash['error_response']
+      end
+      if hash['screen']
+        packet.screen = hash['screen']
+      end
+      if hash['related_items']
+        packet.related_items = hash['related_items']
+      end
+
       packet
     end
 
@@ -1144,8 +1232,6 @@ module OpenC3
       json_hash
     end
 
-    protected
-
     # Performs packet specific processing on the packet.
     # Intended to only be run once for each packet received
     def process(buffer = @buffer)
@@ -1156,6 +1242,8 @@ module OpenC3
       end
     end
 
+    protected
+
     def handle_limits_states(item, value)
       # Retrieve limits state for the given value
       limits_state = item.state_colors[value]

data/lib/openc3/packets/packet_config.rb

@@ -119,7 +119,8 @@ module OpenC3
     #   an xtce file to automatically determine the target name.
     def process_file(filename, process_target_name)
       # Handle .xtce files
-      if File.extname(filename).to_s.downcase == ".xtce"
+      extension = File.extname(filename).to_s.downcase
+      if extension == ".xtce" or extension == ".xml"
         XtceParser.process(@commands, @telemetry, @warnings, filename, process_target_name)
         return
       end
@@ -213,7 +214,8 @@ module OpenC3
               'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM',\
               'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM',\
               'APPEND_ARRAY_PARAMETER', 'ALLOW_SHORT', 'HAZARDOUS', 'PROCESSOR', 'META',\
-              'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED', 'ACCESSOR', 'TEMPLATE', 'TEMPLATE_FILE'
+              'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED', 'ACCESSOR', 'TEMPLATE', 'TEMPLATE_FILE',\
+              'RESPONSE', 'ERROR_RESPONSE', 'SCREEN', 'RELATED_ITEM'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
 
             process_current_packet(parser, keyword, params)
@@ -459,7 +461,30 @@ module OpenC3
         rescue Exception => err
           raise parser.error(err)
         end
+
+      when 'RESPONSE'
+        usage = "#{keyword} <Target Name> <Packet Name>"
+        parser.verify_num_parameters(2, 2, usage)
+        @current_packet.response = [params[0].upcase, params[1].upcase]
+
+      when 'ERROR_RESPONSE'
+        usage = "#{keyword} <Target Name> <Packet Name>"
+        parser.verify_num_parameters(2, 2, usage)
+        @current_packet.error_response = [params[0].upcase, params[1].upcase]
+
+      when 'SCREEN'
+        usage = "#{keyword} <Target Name> <Screen Name>"
+        parser.verify_num_parameters(2, 2, usage)
+        @current_packet.screen = [params[0].upcase, params[1].upcase]
+
+      when 'RELATED_ITEM'
+        usage = "#{keyword} <Target Name> <Packet Name> <Item Name>"
+        parser.verify_num_parameters(3, 3, usage)
+        @current_packet.related_items ||= []
+        @current_packet.related_items << [params[0].upcase, params[1].upcase, params[2].upcase]
+
       end
+
     end
 
     def process_current_item(parser, keyword, params)

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

@@ -181,7 +181,8 @@ module OpenC3
       when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet',
         'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria',
         'ComparisonList', 'MetaCommandSet', 'ArgumentTypeSet', 'ArgumentList',
-        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime'
+        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime',
+        'AncillaryDataSet', 'AncillaryData'
         # Do Nothing
 
       when 'ErrorDetectCorrect'
@@ -446,6 +447,9 @@ module OpenC3
         process_ref_entry(element)
         return false # Already recursed
 
+      when 'ContainerRefEntry'
+        xtce_handle_base_container('ContainerRefEntry', element)
+
       when 'BaseContainer'
         # Handled in SequenceContainer/CommandContainer