openc3 6.9.2 → 6.10.0

data/lib/openc3/packets/packet.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2024, OpenC3, Inc.
+# All changes Copyright 2025, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -113,6 +113,12 @@ module OpenC3
     # @return [Boolean] If this packet is marked as restricted use
     attr_accessor :restricted
 
+    # @return [Boolean] If this packet is marked as a subpacket
+    attr_accessor :subpacket
+
+    # @return [Subpacketizer] Subpacketizer class (optional)
+    attr_accessor :subpacketizer
+
     # Valid format types
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
 
@@ -156,7 +162,9 @@ module OpenC3
         @virtual = false
         @restricted = false
         @validator = nil
-        @obfuscated_items = []
+        @subpacket = false
+        @subpacketizer = nil
+        @obfuscated_items = nil
       end
 
       # Sets the target name this packet is associated with. Unidentified packets
@@ -581,6 +589,25 @@ module OpenC3
       packet_define_item(item, format_string, read_conversion, write_conversion, id_value)
     end
 
+    # @param item [StructureItem] item to make a parent item for a structure
+    # @param structure [Structure] structure to associate with the parent item
+    def structurize_item(item, structure)
+      item.structure = structure
+      item.hidden = true
+      structure.sorted_items.each do |sorted_item|
+        next if RESERVED_ITEM_NAMES.include?(sorted_item.name)
+        cloned_item = sorted_item.clone
+        cloned_item.key = cloned_item.name
+        cloned_item.name = "#{item.name}.#{cloned_item.name}"
+        cloned_item.parent_item = item
+        cloned_item.bit_offset = item.bit_offset
+        if sorted_item.bit_size <= 0
+          cloned_item.bit_size = item.bit_size
+        end
+        define(cloned_item)
+      end
+    end
+
     # (see Structure#get_item)
     def get_item(name)
       return super(name)
@@ -872,7 +899,12 @@ module OpenC3
       @sorted_items.each do |item|
         next if RESERVED_ITEM_NAMES.include?(item.name)
 
-        unless item.default.nil?
+        if item.structure
+          unless skip_item_names and upcase_skip_item_names.include?(item.name)
+            item.structure.restore_defaults(item.structure.buffer(false), skip_item_names, use_template)
+            write_item(item, item.structure.buffer(false), :RAW, buffer)
+          end
+        elsif not item.default.nil? and not item.parent_item
           write_item(item, item.default, :CONVERTED, buffer) unless skip_item_names and upcase_skip_item_names.include?(item.name)
         end
       end
@@ -1087,6 +1119,9 @@ 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 @subpacketizer
+        config << "  SUBPACKETIZER #{@subpacketizer.class} #{@subpacketizer.args.map { |a| a.to_s.quote_if_necessary }.join(" ")}\n"
+      end
       if @accessor.class.to_s != 'OpenC3::BinaryAccessor'
         config << "  ACCESSOR #{@accessor.class} #{@accessor.args.map { |a| a.to_s.quote_if_necessary }.join(" ")}\n"
       end
@@ -1107,6 +1142,9 @@ module OpenC3
       elsif @hidden
         config << "  HIDDEN\n"
       end
+      if @subpacket
+        config << "  SUBPACKET\n"
+      end
       if @restricted
         config << "  RESTRICTED\n"
       end
@@ -1170,6 +1208,8 @@ module OpenC3
       config['disabled'] = true if @disabled
       config['hidden'] = true if @hidden
       config['virtual'] = true if @virtual
+      config['subpacket'] = true if @subpacket
+      config['subpacketizer'] = @subpacketizer.class.to_s if @subpacketizer
       config['restricted'] = true if @restricted
       config['accessor'] = @accessor.class.to_s
       config['accessor_args'] = @accessor.args
@@ -1218,60 +1258,6 @@ module OpenC3
       config
     end
 
-    def self.from_json(hash)
-      endianness = hash['endianness'] ? hash['endianness'].intern : nil # Convert to symbol
-      packet = Packet.new(hash['target_name'], hash['packet_name'], endianness, hash['description'])
-      packet.short_buffer_allowed = hash['short_buffer_allowed']
-      packet.hazardous = hash['hazardous']
-      packet.hazardous_description = hash['hazardous_description']
-      packet.messages_disabled = hash['messages_disabled']
-      packet.disabled = hash['disabled']
-      packet.hidden = hash['hidden']
-      packet.virtual = hash['virtual']
-      packet.restricted = hash['restricted']
-      if hash['accessor']
-        begin
-          accessor = OpenC3::const_get(hash['accessor'])
-          if hash['accessor_args'] and hash['accessor_args'].length > 0
-            packet.accessor = accessor.new(packet, *hash['accessor_args'])
-          else
-            packet.accessor = accessor.new(packet)
-          end
-        rescue => e
-          Logger.instance.error "#{packet.target_name} #{packet.packet_name} accessor of #{hash['accessor']} could not be found due to #{e}"
-        end
-      end
-      if hash['validator']
-        begin
-          validator = OpenC3::const_get(hash['validator'])
-          packet.validator = validator.new(packet)
-        rescue => e
-          Logger.instance.error "#{packet.target_name} #{packet.packet_name} validator of #{hash['validator']} could not be found due to #{e}"
-        end
-      end
-      packet.template = Base64.decode64(hash['template']) if hash['template']
-      packet.meta = hash['meta']
-      # Can't convert processors
-      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.ignore_overlap = hash['ignore_overlap']
-
-      packet
-    end
-
     def decom
       # Read all the RAW at once because this could be optimized by the accessor
       json_hash = read_items(@sorted_items)
@@ -1285,12 +1271,16 @@ module OpenC3
 
       # Now read all other value types - no accessor required
       @sorted_items.each do |item|
-        given_raw = json_hash[item.name]
-        json_hash["#{item.name}__C"] = read_item(item, :CONVERTED, @buffer, given_raw) if item.states or (item.read_conversion and item.data_type != :DERIVED)
-        json_hash["#{item.name}__F"] = read_item(item, :FORMATTED, @buffer, given_raw) if item.format_string
-        json_hash["#{item.name}__U"] = read_item(item, :WITH_UNITS, @buffer, given_raw) if item.units
-        limits_state = item.limits.state
-        json_hash["#{item.name}__L"] = limits_state if limits_state
+        if item.hidden
+          json_hash.delete(item.name)
+        else
+          given_raw = json_hash[item.name]
+          json_hash["#{item.name}__C"] = read_item(item, :CONVERTED, @buffer, given_raw) if item.states or (item.read_conversion and item.data_type != :DERIVED)
+          json_hash["#{item.name}__F"] = read_item(item, :FORMATTED, @buffer, given_raw) if item.format_string
+          json_hash["#{item.name}__U"] = read_item(item, :WITH_UNITS, @buffer, given_raw) if item.units
+          limits_state = item.limits.state
+          json_hash["#{item.name}__L"] = limits_state if limits_state
+        end
       end
 
       json_hash
@@ -1306,6 +1296,14 @@ module OpenC3
       end
     end
 
+    def subpacketize
+      if @subpacketizer
+        return @subpacketizer.call(self)
+      else
+        return [self]
+      end
+    end
+
     def obfuscate()
       return unless @buffer
       return unless @obfuscated_items
@@ -1317,17 +1315,21 @@ module OpenC3
           current_value = read(item.name, :RAW)
 
           case current_value
+          when Hash
+            obfuscated_value = {}
           when Array
             # For arrays, create a new array of zeros with the same size
             case item.data_type
-              when :INT, :UINT
-                obfuscated_value = Array.new(current_value.size, 0)
-              when :FLOAT
-                obfuscated_value = Array.new(current_value.size, 0.0)
-              when :STRING, :BLOCK
-                obfuscated_value = Array.new(current_value.size) { |i|
-                  "\x00" * current_value[i].length if current_value[i]
-                }
+            when :INT, :UINT
+              obfuscated_value = Array.new(current_value.size, 0)
+            when :FLOAT
+              obfuscated_value = Array.new(current_value.size, 0.0)
+            when :STRING, :BLOCK
+              obfuscated_value = Array.new(current_value.size) { |i|
+                "\x00" * current_value[i].length if current_value[i]
+              }
+            when :BOOL, :ARRAY, :OBJECT, :ANY
+              obfuscated_value = []
             else
               obfuscated_value = Array.new(current_value.size, 0)
             end
@@ -1340,6 +1342,8 @@ module OpenC3
               obfuscated_value = 0
             when :FLOAT
               obfuscated_value = 0.0
+            when :BOOL
+              obfuscated_value = false
             else
               obfuscated_value = 0
             end

data/lib/openc3/packets/packet_config.rb

@@ -79,17 +79,29 @@ module OpenC3
     # that returns a hash keyed by an array of id values. The id values resolve to the packet
     # defined by that identification. Command version
     attr_reader :cmd_id_value_hash
+    attr_reader :cmd_subpacket_id_value_hash
+    attr_reader :cmd_id_signature
+    attr_reader :cmd_subpacket_id_signature
+    attr_reader :cmd_unique_id_mode
+    attr_reader :cmd_subpacket_unique_id_mode
 
     # @return [Hash<String>=>Hash<Array>=>Packet] Hash keyed by target name
     # that returns a hash keyed by an array of id values. The id values resolve to the packet
     # defined by that identification. Telemetry version
     attr_reader :tlm_id_value_hash
+    attr_reader :tlm_subpacket_id_value_hash
+    attr_reader :tlm_id_signature
+    attr_reader :tlm_subpacket_id_signature
+    attr_reader :tlm_unique_id_mode
+    attr_reader :tlm_subpacket_unique_id_mode
 
     # @return [String] Language of current target (ruby or python)
     attr_reader :language
 
     COMMAND = "Command"
     TELEMETRY = "Telemetry"
+    # Note: DERIVED is not a valid converted type. Also TIME is currently only a converted type
+    CONVERTED_DATA_TYPES = [:INT, :UINT, :FLOAT, :STRING, :BLOCK, :BOOL, :OBJECT, :ARRAY, :ANY, :TIME]
 
     def initialize
       @name = nil
@@ -102,7 +114,17 @@ module OpenC3
       @latest_data = {}
       @warnings = []
       @cmd_id_value_hash = {}
+      @cmd_subpacket_id_value_hash = {}
+      @cmd_id_signature = {}
+      @cmd_subpacket_id_signature = {}
+      @cmd_unique_id_mode = {}
+      @cmd_subpacket_unique_id_mode = {}
       @tlm_id_value_hash = {}
+      @tlm_subpacket_id_value_hash = {}
+      @tlm_id_signature = {}
+      @tlm_subpacket_id_signature = {}
+      @tlm_unique_id_mode = {}
+      @tlm_subpacket_unique_id_mode = {}
 
       # Create unknown packets
       @commands['UNKNOWN'] = {}
@@ -222,7 +244,8 @@ 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', 'VIRTUAL', 'RESTRICTED', 'ACCESSOR', 'TEMPLATE', 'TEMPLATE_FILE',\
-              'RESPONSE', 'ERROR_RESPONSE', 'SCREEN', 'RELATED_ITEM', 'IGNORE_OVERLAP', 'VALIDATOR'
+              'RESPONSE', 'ERROR_RESPONSE', 'SCREEN', 'RELATED_ITEM', 'IGNORE_OVERLAP', 'VALIDATOR', 'SUBPACKET', 'SUBPACKETIZER',\
+              'STRUCTURE', 'APPEND_STRUCTURE'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
 
             process_current_packet(parser, keyword, params)
@@ -321,18 +344,20 @@ module OpenC3
           PacketParser.check_item_data_types(@current_packet)
           @commands[@current_packet.target_name][@current_packet.packet_name] = @current_packet
           unless @current_packet.virtual
-            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(@current_packet, hash)
+            if @current_packet.subpacket
+              build_id_metadata(@current_packet, @cmd_subpacket_id_value_hash, @cmd_subpacket_id_signature, @cmd_subpacket_unique_id_mode)
+            else
+              build_id_metadata(@current_packet, @cmd_id_value_hash, @cmd_id_signature, @cmd_unique_id_mode)
+            end
           end
         else
           @telemetry[@current_packet.target_name][@current_packet.packet_name] = @current_packet
           unless @current_packet.virtual
-            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(@current_packet, hash)
+            if @current_packet.subpacket
+              build_id_metadata(@current_packet, @tlm_subpacket_id_value_hash, @tlm_subpacket_id_signature, @tlm_subpacket_unique_id_mode)
+            else
+              build_id_metadata(@current_packet, @tlm_id_value_hash, @tlm_id_signature, @tlm_unique_id_mode)
+            end
           end
         end
         @current_packet = nil
@@ -345,10 +370,11 @@ module OpenC3
         @commands[packet.target_name][packet.packet_name] = packet
 
         if affect_ids and not packet.virtual
-          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)
+          if packet.subpacket
+            build_id_metadata(packet, @cmd_subpacket_id_value_hash, @cmd_subpacket_id_signature, @cmd_subpacket_unique_id_mode)
+          else
+            build_id_metadata(packet, @cmd_id_value_hash, @cmd_id_signature, @cmd_unique_id_mode)
+          end
         end
       else
         @telemetry[packet.target_name][packet.packet_name] = packet
@@ -362,10 +388,11 @@ module OpenC3
         end
 
         if affect_ids and not packet.virtual
-          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)
+          if packet.subpacket
+            build_id_metadata(packet, @tlm_subpacket_id_value_hash, @tlm_subpacket_id_signature, @tlm_subpacket_unique_id_mode)
+          else
+            build_id_metadata(packet, @tlm_id_value_hash, @tlm_id_signature, @tlm_unique_id_mode)
+          end
         end
       end
     end
@@ -398,15 +425,32 @@ module OpenC3
 
     protected
 
-    def update_id_value_hash(packet, hash)
+    def build_id_metadata(packet, id_value_hash, id_signature_hash, unique_id_mode_hash)
+      target_id_value_hash = id_value_hash[packet.target_name]
+      target_id_value_hash = {} unless target_id_value_hash
+      id_value_hash[packet.target_name] = target_id_value_hash
+      update_id_value_hash(packet, target_id_value_hash, id_signature_hash, unique_id_mode_hash)
+    end
+
+    def update_id_value_hash(packet, target_id_value_hash, id_signature_hash, unique_id_mode_hash)
       if packet.id_items.length > 0
         key = []
+        id_signature = ""
         packet.id_items.each do |item|
           key << item.id_value
+          id_signature << "__#{item.key}__#{item.bit_offset}__#{item.bit_size}__#{item.data_type}"
+        end
+        target_id_value_hash[key] = packet
+        target_id_signature = id_signature_hash[packet.target_name]
+        if target_id_signature
+          if id_signature != target_id_signature
+            unique_id_mode_hash[packet.target_name] = true
+          end
+        else
+          id_signature_hash[packet.target_name] = id_signature
         end
-        hash[key] = packet
       else
-        hash['CATCHALL'.freeze] = packet
+        target_id_value_hash['CATCHALL'.freeze] = packet
       end
     end
 
@@ -445,7 +489,7 @@ module OpenC3
       # Start a new telemetry item in the current packet
       when 'ITEM', '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'
+          'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER', 'STRUCTURE', 'APPEND_STRUCTURE'
         start_item(parser)
 
       # Allow this packet to be received with less data than the defined length
@@ -494,7 +538,11 @@ module OpenC3
       when 'HIDDEN'
         usage = "#{keyword}"
         parser.verify_num_parameters(0, 0, usage)
-        @current_packet.hidden = true
+        if @current_item
+          @current_item.hidden = true
+        else
+          @current_packet.hidden = true
+        end
 
       when 'DISABLED'
         usage = "#{keyword}"
@@ -509,12 +557,17 @@ module OpenC3
         @current_packet.disabled = true
         @current_packet.virtual = true
 
+      when 'SUBPACKET'
+        usage = "#{keyword}"
+        parser.verify_num_parameters(0, 0, usage)
+        @current_packet.subpacket = true
+
       when 'RESTRICTED'
         usage = "#{keyword}"
         parser.verify_num_parameters(0, 0, usage)
         @current_packet.restricted = true
 
-      when 'ACCESSOR', 'VALIDATOR'
+      when 'ACCESSOR', 'VALIDATOR', 'SUBPACKETIZER'
         usage = "#{keyword} <Class name> <Optional parameters> ..."
         parser.verify_num_parameters(1, nil, usage)
         begin
@@ -663,7 +716,7 @@ module OpenC3
         @converted_bit_size = nil
         if params[0]
           @converted_type = params[0].upcase.intern
-          raise parser.error("Invalid converted_type: #{@converted_type}.") unless [:INT, :UINT, :FLOAT, :STRING, :BLOCK, :TIME].include? @converted_type
+          raise parser.error("Invalid converted_type: #{@converted_type}.") unless CONVERTED_DATA_TYPES.include? @converted_type
         end
         @converted_bit_size = Integer(params[1]) if params[1]
         if @converted_type.nil? or @converted_bit_size.nil?
@@ -745,10 +798,6 @@ module OpenC3
 
       # Update the default value for the current command parameter
       when 'DEFAULT_VALUE'
-        if @current_cmd_or_tlm == TELEMETRY
-          raise parser.error("#{keyword} only applies to command parameters")
-        end
-
         usage = "DEFAULT_VALUE <DEFAULT VALUE>"
         parser.verify_num_parameters(1, 1, usage)
         if (@current_item.data_type == :STRING) ||
@@ -788,7 +837,7 @@ module OpenC3
 
     def start_item(parser)
       finish_item()
-      @current_item = PacketItemParser.parse(parser, @current_packet, @current_cmd_or_tlm, @warnings)
+      @current_item = PacketItemParser.parse(parser, self, @current_packet, @current_cmd_or_tlm, @warnings)
     end
 
     # Finish updating packet item

data/lib/openc3/packets/packet_item.rb

@@ -233,6 +233,12 @@ module OpenC3
             raise ArgumentError, "#{@name}: default must be a String but is a #{@default.class}" unless String === @default
 
             @default = @default.clone.freeze
+          when :ARRAY
+            raise ArgumentError, "#{@name}: default must be an Array but is a #{@default.class}" unless Array === @default
+          when :OBJECT
+            raise ArgumentError, "#{@name}: default must be an Hash but is a #{@default.class}" unless Hash === @default
+          when :BOOL
+            raise ArgumentError, "#{@name}: default must be true/false but is a #{@default.class}" unless TrueClass === @default or FalseClass === @default
           end
         end
       end
@@ -323,37 +329,6 @@ module OpenC3
     end
     alias dup clone
 
-    def to_hash
-      hash = super()
-      hash['format_string'] = self.format_string
-      if self.read_conversion
-        hash['read_conversion'] = self.read_conversion.to_s
-      else
-        hash['read_conversion'] = nil
-      end
-      if self.write_conversion
-        hash['write_conversion'] = self.write_conversion.to_s
-      else
-        hash['write_conversion'] = nil
-      end
-      hash['id_value'] = self.id_value
-      hash['states'] = self.states
-      hash['description'] = self.description
-      hash['units_full'] = self.units_full
-      hash['units'] = self.units
-      hash['default'] = self.default
-      hash['range'] = self.range
-      hash['required'] = self.required
-      hash['hazardous'] = self.hazardous
-      hash['messages_disabled'] = self.messages_disabled
-      hash['state_colors'] = self.state_colors
-      hash['limits'] = self.limits.to_hash
-      hash['meta'] = nil
-      hash['meta'] = @meta if @meta
-      hash['obfuscate'] = self.obfuscate
-      hash
-    end
-
     def calculate_range
       first = range.first
       last = range.last
@@ -453,12 +428,7 @@ module OpenC3
     end
 
     def as_json(*a)
-      config = {}
-      config['name'] = self.name
-      config['bit_offset'] = self.bit_offset
-      config['bit_size'] = self.bit_size
-      config['data_type'] = self.data_type.to_s
-      config['array_size'] = self.array_size if self.array_size
+      config = super(*a)
       config['description'] = self.description
       config['id_value'] = self.id_value.as_json(*a) if self.id_value
       if @default
@@ -468,14 +438,12 @@ module OpenC3
         config['minimum'] = self.range.first.as_json(*a)
         config['maximum'] = self.range.last.as_json(*a)
       end
-      config['endianness'] = self.endianness.to_s
       config['required'] = self.required
       config['format_string'] = self.format_string if self.format_string
       if self.units
         config['units'] = self.units
         config['units_full'] = self.units_full
       end
-      config['overflow'] = self.overflow.to_s
       if @states
         states = {}
         config['states'] = states
@@ -518,74 +486,10 @@ module OpenC3
       end
 
       config['meta'] = @meta if @meta
-      config['variable_bit_size'] = @variable_bit_size if @variable_bit_size
       config['obfuscate'] = self.obfuscate
       config
     end
 
-    def self.from_json(hash)
-      # Convert strings to symbols
-      endianness = hash['endianness'] ? hash['endianness'].intern : nil
-      data_type = hash['data_type'] ? hash['data_type'].intern : nil
-      overflow = hash['overflow'] ? hash['overflow'].intern : nil
-      item = PacketItem.new(hash['name'], hash['bit_offset'], hash['bit_size'],
-        data_type, endianness, hash['array_size'], overflow)
-      item.description = hash['description']
-      item.id_value = hash['id_value']
-      item.default = hash['default']
-      item.range = (hash['minimum']..hash['maximum']) if hash['minimum'] && hash['maximum']
-      item.required = hash['required']
-      item.format_string = hash['format_string']
-      item.units = hash['units']
-      item.units_full = hash['units_full']
-      if hash['states']
-        item.states = {}
-        item.hazardous = {}
-        item.messages_disabled = {}
-        item.state_colors = {}
-        hash['states'].each do |state_name, state|
-          item.states[state_name] = state['value']
-          item.hazardous[state_name] = state['hazardous']
-          item.messages_disabled[state_name] = state['messages_disabled']
-          item.state_colors[state_name] = state['color'].to_sym if state['color']
-        end
-      end
-      # Recreate OpenC3 built-in conversions
-      if hash['read_conversion']
-        begin
-          item.read_conversion = OpenC3::const_get(hash['read_conversion']['class']).new(*hash['read_conversion']['params'])
-        rescue => error
-          Logger.instance.error "#{item.name} read_conversion of #{hash['read_conversion']} could not be instantiated due to #{error}"
-        end
-      end
-      if hash['write_conversion']
-        begin
-          item.write_conversion = OpenC3::const_get(hash['write_conversion']['class']).new(*hash['write_conversion']['params'])
-        rescue => error
-          Logger.instance.error "#{item.name} write_conversion of #{hash['write_conversion']} could not be instantiated due to #{error}"
-        end
-      end
-
-      item.limits = PacketItemLimits.new
-      if hash['limits']
-        # Delete the keys so the only ones left are limits sets
-        persistence_setting = hash['limits'].delete('persistence_setting')
-        item.limits.persistence_setting = persistence_setting if persistence_setting
-        hash['limits'].delete('response') # Can't round trip response
-        item.limits.enabled = true if hash['limits'].delete('enabled')
-        values = {}
-        hash['limits'].each do |set, items|
-          values[set.to_sym] = [items['red_low'], items['yellow_low'], items['yellow_high'], items['red_high']]
-          values[set.to_sym].concat([items['green_low'], items['green_high']]) if items['green_low'] && items['green_high']
-        end
-        item.limits.values = values if values.length > 0
-      end
-      item.meta = hash['meta']
-      item.obfuscate = hash['obfuscate']
-      item.variable_bit_size = hash['variable_bit_size']
-      item
-    end
-
     protected
 
     def parameter_config
@@ -621,6 +525,10 @@ module OpenC3
         Float(value)
       when :STRING, :BLOCK
         value.to_s.freeze
+      when :BOOL
+        ConfigParser.handle_true_false(value)
+      else
+        return value
       end
     rescue
       raise ArgumentError, "#{@name}: Invalid value: #{value} for data type: #{data_type}"