openc3 5.15.1 → 5.16.0

data/lib/openc3/models/activity_model.rb

@@ -14,7 +14,7 @@
 # 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
@@ -24,6 +24,7 @@
 
 require 'openc3/models/model'
 require 'openc3/topics/timeline_topic'
+require 'securerandom'
 
 module OpenC3
   class ActivityError < StandardError; end
@@ -128,7 +129,7 @@ module OpenC3
       self.new(**json.transform_keys(&:to_sym), name: name, scope: scope)
     end
 
-    attr_reader :duration, :start, :stop, :kind, :data, :events, :fulfillment
+    attr_reader :start, :stop, :kind, :data, :events, :fulfillment, :recurring
 
     def initialize(
       name:,
@@ -138,9 +139,9 @@ module OpenC3
       data:,
       scope:,
       updated_at: 0,
-      duration: 0,
       fulfillment: nil,
-      events: nil
+      events: nil,
+      recurring: {}
     )
       super("#{scope}#{PRIMARY_KEY}__#{name}", name: name, scope: scope)
       set_input(
@@ -150,22 +151,24 @@ module OpenC3
         kind: kind,
         data: data,
         events: events,
+        recurring: recurring,
       )
       @updated_at = updated_at
     end
 
-    # validate_time will be called on create this will pull the time up to MAX_DURATION of an activity
-    # this will make sure that the activity is the only activity on the timeline for the duration of the
-    # activity. Score is the Seconds since the Unix Epoch: (%s) Number of seconds since 1970-01-01 00:00:00 UTC.
-    # We then search back from the stop of the activity and check to see if any activities are in the
-    # last x seconds (MAX_DURATION), if the zrange rev byscore finds activites from in reverse order so the
-    # first task is the closest task to the current score. In this a parameter ignore_score allows the request
-    # to ignore that time and skip to the next time but if nothing is found in the time range we can return nil.
+    # validate_time searches from the current activity @stop - 1 (because we allow overlap of stop with start)
+    # back through @start - MAX_DURATION. The method is trying to validate that this new activity does not
+    # overlap with anything else. The reason we search back past @start through MAX_DURATION is because we
+    # need to return all the activities that may start before us and verify that we don't overlap them.
+    # Activities are only inserted by @start time so we need to go back to verify we don't overlap existing @stop.
+    # Note: Score is the Seconds since the Unix Epoch: (%s) Number of seconds since 1970-01-01 00:00:00 UTC.
+    # zrange rev byscore finds activites from in reverse order so the first task is the closest task to the current score.
+    # In this case a parameter ignore_score allows the request to ignore that time and skip to the next time
+    # but if nothing is found in the time range we can return nil.
     #
     # @param [Integer] ignore_score - should be nil unless you want to ignore a time when doing an update
     def validate_time(ignore_score = nil)
-      max_score = @start - MAX_DURATION
-      array = Store.zrevrangebyscore(@primary_key, @stop, max_score)
+      array = Store.zrevrangebyscore(@primary_key, @stop - 1, @start - MAX_DURATION)
       array.each do |value|
         activity = JSON.parse(value, :allow_nan => true, :create_additions => true)
         if ignore_score == activity['start']
@@ -190,10 +193,14 @@ module OpenC3
         DateTime.strptime(start.to_s, '%s')
         DateTime.strptime(stop.to_s, '%s')
       rescue Date::Error
-        raise ActivityInputError.new "failed validation input must be seconds: #{start}, #{stop}"
+        raise ActivityInputError.new "start and stop must be seconds: #{start}, #{stop}"
+      end
+      now_i = Time.now.to_i
+      begin
+        duration = stop - start
+      rescue NoMethodError
+        raise ActivityInputError.new "start and stop must be seconds: #{start}, #{stop}"
       end
-      now_i = Time.now.to_i + 10
-      duration = stop - start
       if now_i >= start
         raise ActivityInputError.new "activity must be in the future, current_time: #{now_i} vs #{start}"
       elsif duration >= MAX_DURATION
@@ -210,47 +217,92 @@ module OpenC3
     end
 
     # Set the values of the instance, @start, @kind, @data, @events...
-    def set_input(start:, stop:, kind: nil, data: nil, events: nil, fulfillment: nil)
-      begin
-        DateTime.strptime(start.to_s, '%s')
-        DateTime.strptime(stop.to_s, '%s')
-      rescue ArgumentError
-        raise ActivityInputError.new "invalid input must be seconds: #{start}, #{stop}"
-      end
+    def set_input(start:, stop:, kind: nil, data: nil, events: nil, fulfillment: nil, recurring: nil)
+      validate_input(start: start, stop: stop, kind: kind, data: data)
       @start = start
       @stop = stop
-      @duration = @stop - @start
       @fulfillment = fulfillment.nil? ? false : fulfillment
       @kind = kind.nil? ? @kind : kind
       @data = data.nil? ? @data : data
       @events = events.nil? ? Array.new : events
+      @recurring = recurring.nil? ? @recurring : recurring
     end
 
     # Update the Redis hash at primary_key and set the score equal to the start Epoch time
     # the member is set to the JSON generated via calling as_json
     def create
-      validate_input(start: @start, stop: @stop, kind: @kind, data: @data)
-      collision = validate_time()
-      unless collision.nil?
-        raise ActivityOverlapError.new "no activities can overlap, collision: #{collision}"
-      end
+      if @recurring['end'] and @recurring['frequency'] and @recurring['span']
+        # First validate the initial recurring activity ... all others are just offsets
+        validate_input(start: @start, stop: @stop, kind: @kind, data: @data)
+
+        # Create a uuid for deleting related recurring in the future
+        @recurring['uuid'] = SecureRandom.uuid
+        @recurring['start'] = @start
+        duration = @stop - @start
+        recurrance = 0
+        case @recurring['span']
+        when 'minutes'
+          recurrance = @recurring['frequency'].to_i * 60
+        when 'hours'
+          recurrance = @recurring['frequency'].to_i * 3600
+        when 'days'
+          recurrance = @recurring['frequency'].to_i * 86400
+        end
 
-      @updated_at = Time.now.to_nsec_from_epoch
-      add_event(status: 'created')
-      Store.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
-      notify(kind: 'created')
+        # Get all the existing events in the recurring time range as well as those before
+        # the start of the recurring time range to ensure we don't start inside an existing event
+        existing = Store.zrevrangebyscore(@primary_key, @recurring['end'] - 1, @recurring['start'] - MAX_DURATION)
+        existing.map! {|value| JSON.parse(value, :allow_nan => true, :create_additions => true) }
+        last_stop = nil
+
+        # Update @updated_at and add an event assuming it all completes ok
+        @updated_at = Time.now.to_nsec_from_epoch
+        add_event(status: 'created')
+
+        Store.multi do |multi|
+          (@start..@recurring['end']).step(recurrance).each do |start_time|
+            @start = start_time
+            @stop = start_time + duration
+
+            if last_stop and @start < last_stop
+              @events.pop # Remove previously created event
+              raise ActivityOverlapError.new "Recurring activity overlap. Increase recurrance delta or decrease activity duration."
+            end
+            existing.each do |value|
+              if (@start >= value['start'] and @start < value['stop']) ||
+                (@stop > value['start'] and @stop <= value['stop'])
+                @events.pop # Remove previously created event
+                raise ActivityOverlapError.new "activity overlaps existing at #{value['start']}"
+              end
+            end
+            multi.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
+            last_stop = @stop
+          end
+        end
+        notify(kind: 'created')
+      else
+        validate_input(start: @start, stop: @stop, kind: @kind, data: @data)
+        collision = validate_time()
+        unless collision.nil?
+          raise ActivityOverlapError.new "activity overlaps existing at #{collision}"
+        end
+
+        @updated_at = Time.now.to_nsec_from_epoch
+        add_event(status: 'created')
+        Store.zadd(@primary_key, @start, JSON.generate(self.as_json(:allow_nan => true)))
+        notify(kind: 'created')
+      end
     end
 
     # Update the Redis hash at primary_key and remove the current activity at the current score
     # and update the score to the new score equal to the start Epoch time this uses a multi
-    # to execute both the remove and create. The member via the JSON generated via calling as_json
+    # to execute both the remove and create.
     def update(start:, stop:, kind:, data:)
       array = Store.zrangebyscore(@primary_key, @start, @start)
       if array.length == 0
         raise ActivityError.new "failed to find activity at: #{@start}"
       end
 
-      validate_input(start: start, stop: stop, kind: kind, data: data)
       old_start = @start
       set_input(start: start, stop: stop, kind: kind, data: data, events: @events)
       @updated_at = Time.now.to_nsec_from_epoch
@@ -299,12 +351,24 @@ module OpenC3
     end
 
     # destroy the activity from the redis database
-    def destroy
-      Store.zremrangebyscore(@primary_key, @start, @start)
+    def destroy(recurring: false)
+      # Delete all recurring activities
+      if recurring and @recurring['end'] and @recurring['uuid']
+        uuid = @recurring['uuid']
+        array = Store.zrangebyscore("#{scope}#{PRIMARY_KEY}__#{@name}", @recurring['start'], @recurring['end'])
+        array.each do |value|
+          model = ActivityModel.from_json(value, name: @name, scope: @scope)
+          if model.recurring['uuid'] == uuid
+            Store.zremrangebyscore(@primary_key, model.start, model.start)
+          end
+        end
+      else
+        Store.zremrangebyscore(@primary_key, @start, @start)
+      end
       notify(kind: 'deleted')
     end
 
-    # @return [] update the redis stream / timeline topic that something has changed
+    # update the redis stream / timeline topic that something has changed
     def notify(kind:, extra: nil)
       notification = {
         'data' => JSON.generate(as_json(:allow_nan => true)),
@@ -326,12 +390,12 @@ module OpenC3
         'name' => @name,
         'updated_at' => @updated_at,
         'fulfillment' => @fulfillment,
-        'duration' => @duration,
         'start' => @start,
         'stop' => @stop,
         'kind' => @kind,
         'events' => @events,
-        'data' => @data.as_json(*a)
+        'data' => @data.as_json(*a),
+        'recurring' => @recurring.as_json(*a)
       }
     end
   end

data/lib/openc3/models/gem_model.rb

@@ -36,7 +36,7 @@ module OpenC3
   # and destroy to allow interaction with gem files from the PluginModel and
   # the GemsController.
   class GemModel
-    include Api
+    extend Api
 
     def self.names
       if Dir.exist?("#{ENV['GEM_HOME']}/gems")

data/lib/openc3/models/plugin_model.rb

@@ -44,7 +44,7 @@ module OpenC3
   # microservices and tools. The PluginModel installs all these pieces as well
   # as destroys them all when the plugin is removed.
   class PluginModel < Model
-    include Api
+    extend Api
 
     PRIMARY_KEY = 'openc3_plugins'
     # Reserved VARIABLE names. See local_mode.rb: update_local_plugin()
@@ -198,8 +198,10 @@ module OpenC3
               pypi_url ||= 'https://pypi.org/simple'
             end
           end
-          Logger.info "Installing python packages from requirements.txt with pypi_url=#{pypi_url}"
-          puts `/openc3/bin/pipinstall --user -i #{pypi_url} -r #{File.join(gem_path, 'requirements.txt')}`
+          unless validate_only
+            Logger.info "Installing python packages from requirements.txt with pypi_url=#{pypi_url}"
+            puts `/openc3/bin/pipinstall --user --no-warn-script-location -i #{pypi_url} -r #{File.join(gem_path, 'requirements.txt')}`
+          end
           needs_dependencies = true
         end
 

data/lib/openc3/models/python_package_model.rb

@@ -18,6 +18,7 @@
 
 require 'fileutils'
 require 'openc3/utilities/process_manager'
+require 'openc3/api/api'
 require 'pathname'
 
 module OpenC3
@@ -26,6 +27,8 @@ module OpenC3
   # and destroy to allow interaction with python package files from the PluginModel and
   # the PackagesController.
   class PythonPackageModel
+    extend Api
+
     def self.names
       paths = Dir.glob("#{ENV['PYTHONUSERBASE']}/lib/*")
       results = []
@@ -71,16 +74,23 @@ module OpenC3
       package_filename = File.basename(package_file_path)
       begin
         pypi_url = get_setting('pypi_url', scope: scope)
-      rescue
-        # If Redis isn't running try the ENV, then simply pypi.org/simple
-        pypi_url = ENV['PYPI_URL']
         if pypi_url
           pypi_url += '/simple'
         end
-        pypi_url ||= 'https://pypi.org/simple'
+      rescue => e
+        Logger.error("Failed to retrieve pypi_url: #{e.formatted}")
+      ensure
+        if pypi_url.nil?
+          # If Redis isn't running try the ENV, then simply pypi.org/simple
+          pypi_url = ENV['PYPI_URL']
+          if pypi_url
+            pypi_url += '/simple'
+          end
+          pypi_url ||= 'https://pypi.org/simple'
+        end
       end
       Logger.info "Installing python package: #{name_or_path}"
-      result = OpenC3::ProcessManager.instance.spawn(["pip", "install", "--user", "-i", pypi_url, package_file_path], "package_install", package_filename, Time.now + 3600.0, scope: scope)
+      result = OpenC3::ProcessManager.instance.spawn(["/openc3/bin/pipinstall", "--user", "--no-warn-script-location", "-i", pypi_url, package_file_path], "package_install", package_filename, Time.now + 3600.0, scope: scope)
       return result.name
     end
 

data/lib/openc3/models/scope_model.rb

@@ -306,7 +306,7 @@ module OpenC3
       setting = SettingModel.get(name: 'rubygems_url')
       SettingModel.set({ name: 'rubygems_url', data: 'https://rubygems.org' }, scope: @scope) unless setting
       setting = SettingModel.get(name: 'pypi_url')
-      SettingModel.set({ name: 'pypi_url', data: 'https://pypi.org/simple' }, scope: @scope) unless setting
+      SettingModel.set({ name: 'pypi_url', data: 'https://pypi.org' }, scope: @scope) unless setting
     end
   end
 end

data/lib/openc3/models/target_model.rb

@@ -405,7 +405,7 @@ module OpenC3
         'ignored_items' => @ignored_items,
         'limits_groups' => @limits_groups,
         'cmd_tlm_files' => @cmd_tlm_files,
-        'cmd_unique_id_mode' => cmd_unique_id_mode,
+        'cmd_unique_id_mode' => @cmd_unique_id_mode,
         'tlm_unique_id_mode' => @tlm_unique_id_mode,
         'id' => @id,
         'updated_at' => @updated_at,

data/lib/openc3/packets/packet.rb

@@ -101,6 +101,9 @@ module OpenC3
     # @return [Array<Array<Target Name, Packet Name, Item Name>>] Related items
     attr_accessor :related_items
 
+    # @return [Boolean] Whether to ignore overlapping items
+    attr_accessor :ignore_overlap
+
     # Valid format types
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
 
@@ -140,6 +143,7 @@ module OpenC3
         @cmd_or_tlm = nil
         @template = nil
         @packet_time = nil
+        @ignore_overlap = false
       end
 
       # Sets the target name this packet is associated with. Unidentified packets
@@ -151,12 +155,10 @@ module OpenC3
           if !(String === target_name)
             raise(ArgumentError, "target_name must be a String but is a #{target_name.class}")
           end
-
           @target_name = target_name.upcase.freeze
         else
           @target_name = nil
         end
-        @target_name
       end
 
       # Sets the packet name. Unidentified packets will have packet name set to
@@ -168,12 +170,10 @@ module OpenC3
           if !(String === packet_name)
             raise(ArgumentError, "packet_name must be a String but is a #{packet_name.class}")
           end
-
           @packet_name = packet_name.upcase.freeze
         else
           @packet_name = nil
         end
-        @packet_name
       end
 
       # Sets the description of the packet
@@ -184,12 +184,10 @@ module OpenC3
           if !(String === description)
             raise(ArgumentError, "description must be a String but is a #{description.class}")
           end
-
           @description = description.to_utf8.freeze
         else
           @description = nil
         end
-        @description
       end
 
       # Sets the received time of the packet
@@ -200,13 +198,11 @@ module OpenC3
           if !(Time === received_time)
             raise(ArgumentError, "received_time must be a Time but is a #{received_time.class}")
           end
-
           @received_time = received_time.clone.freeze
         else
           @received_time = nil
         end
         @read_conversion_cache.clear if @read_conversion_cache
-        @received_time
       end
 
       # Sets the received count of the packet
@@ -217,10 +213,8 @@ module OpenC3
         if !(Integer === received_count)
           raise(ArgumentError, "received_count must be an Integer but is a #{received_count.class}")
         end
-
         @received_count = received_count
         @read_conversion_cache.clear if @read_conversion_cache
-        @received_count
       end
 
     end # if RUBY_ENGINE != 'ruby' or ENV['OPENC3_NO_EXT']
@@ -401,6 +395,10 @@ module OpenC3
     #
     # @return [Array<String>] Warning messages for big definition overlaps
     def check_bit_offsets
+      if @ignore_overlap
+        Logger.instance.info("#{@target_name} #{@packet_name} has IGNORE_OVERLAP so bit overlaps ignored")
+        return []
+      end
       expected_next_offset = nil
       previous_item = nil
       warnings = []
@@ -617,7 +615,7 @@ module OpenC3
 
           unless using_cached_value
             if item.array_size
-              value.map! do |val, index|
+              value.map! do |val, _index|
                 item.read_conversion.call(val, self, buffer)
               end
             else
@@ -646,7 +644,7 @@ module OpenC3
         # Convert from value to state if possible
         if item.states
           if Array === value
-            value = value.map do |val, index|
+            value = value.map do |val, _index|
               if item.states.key(val)
                 item.states.key(val)
               elsif item.states.values.include?(ANY_STATE)
@@ -667,7 +665,7 @@ module OpenC3
           end
         else
           if Array === value
-            value = value.map do |val, index|
+            value = value.map do |val, _index|
               apply_format_string_and_units(item, val, value_type)
             end
           else
@@ -693,7 +691,7 @@ module OpenC3
     # @param value_type [Symbol] Value type to read for every item
     # @param buffer [String] The binary buffer to read the items from
     # @return Hash of read names and values
-    def read_items(items, value_type = :RAW, buffer = @buffer, raw_value = nil)
+    def read_items(items, value_type = :RAW, buffer = @buffer, _raw_value = nil)
       buffer = allocate_buffer_if_needed() unless buffer
       if value_type == :RAW
         result = super(items, value_type, buffer)
@@ -735,11 +733,11 @@ module OpenC3
         end
         begin
           super(item, value, :RAW, buffer)
-        rescue ArgumentError => err
-          if item.states and String === value and err.message =~ /invalid value for/
+        rescue ArgumentError => e
+          if item.states and String === value and e.message =~ /invalid value for/
             raise "Unknown state #{value} for #{item.name}"
           else
-            raise err
+            raise e
           end
         end
       when :FORMATTED, :WITH_UNITS
@@ -998,7 +996,7 @@ module OpenC3
       end
       return unless @processors
 
-      @processors.each do |processor_name, processor|
+      @processors.each do |_processor_name, processor|
         processor.reset
       end
     end
@@ -1051,7 +1049,7 @@ module OpenC3
         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"
+        config << "  ACCESSOR #{@accessor.class} #{@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
@@ -1067,7 +1065,7 @@ module OpenC3
       end
 
       if @processors
-        @processors.each do |processor_name, processor|
+        @processors.each do |_processor_name, processor|
           config << processor.to_config
         end
       end
@@ -1106,6 +1104,9 @@ module OpenC3
           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
+      if @ignore_overlap
+        config << "  IGNORE_OVERLAP"
+      end
       config
     end
 
@@ -1128,7 +1129,7 @@ module OpenC3
 
       if @processors
         processors = []
-        @processors.each do |processor_name, processor|
+        @processors.each do |_processor_name, processor|
           processors << processor.as_json(*a)
         end
         config['processors'] = processors
@@ -1161,6 +1162,7 @@ module OpenC3
       if @related_items
         config['related_items'] = @related_items
       end
+      config['ignore_overlap'] = true if @ignore_overlap
 
       config
     end
@@ -1182,8 +1184,8 @@ module OpenC3
           else
             packet.accessor = accessor.new(packet)
           end
-        rescue => error
-          Logger.instance.error "#{packet.target_name} #{packet.packet_name} accessor of #{hash['accessor']} could not be found due to #{error}"
+        rescue => e
+          Logger.instance.error "#{packet.target_name} #{packet.packet_name} accessor of #{hash['accessor']} could not be found due to #{e}"
         end
       end
       packet.template = Base64.decode64(hash['template']) if hash['template']
@@ -1204,6 +1206,7 @@ module OpenC3
       if hash['related_items']
         packet.related_items = hash['related_items']
       end
+      packet.ignore_overlap = hash['ignore_overlap']
 
       packet
     end
@@ -1237,7 +1240,7 @@ module OpenC3
     def process(buffer = @buffer)
       return unless @processors
 
-      @processors.each do |processor_name, processor|
+      @processors.each do |_processor_name, processor|
         processor.call(self, buffer)
       end
     end

data/lib/openc3/packets/packet_config.rb

@@ -220,7 +220,7 @@ module OpenC3
               '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',\
-              'RESPONSE', 'ERROR_RESPONSE', 'SCREEN', 'RELATED_ITEM'
+              'RESPONSE', 'ERROR_RESPONSE', 'SCREEN', 'RELATED_ITEM', 'IGNORE_OVERLAP'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
 
             process_current_packet(parser, keyword, params)
@@ -509,24 +509,41 @@ module OpenC3
       when 'RESPONSE'
         usage = "#{keyword} <Target Name> <Packet Name>"
         parser.verify_num_parameters(2, 2, usage)
+        if @current_cmd_or_tlm == TELEMETRY
+          raise parser.error("#{keyword} only applies to command packets")
+        end
         @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)
+        if @current_cmd_or_tlm == TELEMETRY
+          raise parser.error("#{keyword} only applies to command packets")
+        end
         @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)
+        if @current_cmd_or_tlm == TELEMETRY
+          raise parser.error("#{keyword} only applies to command packets")
+        end
         @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)
+        if @current_cmd_or_tlm == TELEMETRY
+          raise parser.error("#{keyword} only applies to command packets")
+        end
         @current_packet.related_items ||= []
         @current_packet.related_items << [params[0].upcase, params[1].upcase, params[2].upcase]
 
+      when 'IGNORE_OVERLAP'
+        usage = "#{keyword}"
+        parser.verify_num_parameters(0, 0, usage)
+        @current_packet.ignore_overlap = true
+
       end
 
     end

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

@@ -173,6 +173,8 @@ module OpenC3
 
       index = append? ? 3 : 4
       data_type = get_data_type()
+      return [] if data_type == :ARRAY
+      return {} if data_type == :OBJECT
       if data_type == :STRING or data_type == :BLOCK
         # If the default value is 0x<data> (no quotes), it is treated as
         # binary data.  Otherwise, the default value is considered to be a string.
@@ -241,13 +243,13 @@ module OpenC3
     def type_usage
       keyword = @parser.keyword
       # Item type usage is simple so just return it
-      return "<TYPE: INT/UINT/FLOAT/STRING/BLOCK/DERIVED> " if keyword.include?("ITEM")
+      return "<TYPE: INT/UINT/FLOAT/STRING/BLOCK/DERIVED/ARRAY/OBJECT> " if keyword.include?("ITEM")
 
       # Build up the parameter type usage based on the keyword
       usage = "<TYPE: "
       # ARRAY types don't have min or max or default values
       if keyword.include?("ARRAY")
-        usage << "INT/UINT/FLOAT/STRING/BLOCK> "
+        usage << "INT/UINT/FLOAT/STRING/BLOCK/OBJECT> "
       else
         begin
           data_type = get_data_type()
@@ -255,14 +257,16 @@ module OpenC3
           # If the data type could not be determined set something
           data_type = :INT
         end
-        # STRING and BLOCK types do not have min or max values
+        # STRING, BLOCK, ARRAY, OBJECT types do not have min or max values
         if data_type == :STRING || data_type == :BLOCK
-          usage << "STRING/BLOCK> "
+          usage << "STRING/BLOCK/ARRAY/OBJECT> "
         else
           usage << "INT/UINT/FLOAT> <MIN VALUE> <MAX VALUE> "
         end
-        # ID Values do not have default values
-        usage << "<DEFAULT_VALUE> " unless keyword.include?("ID")
+        # ID Values do not have default values (or ARRAY/OBJECT)
+        unless keyword.include?("ID") or data_type == :ARRAY or data_type == :OBJECT
+          usage << "<DEFAULT_VALUE> "
+        end
       end
       usage
     end