cosmos 3.1.2 → 3.2.0

data/lib/cosmos/packets/packet.rb

@@ -165,6 +165,53 @@ module Cosmos
       end
     end
 
+    # Review bit offset to look for overlapping definitions. This will allow
+    # gaps in the packet, but not allow the same bits to be used for multiple
+    # variables.
+    #
+    # @return [Array<String>] Warning messages for big definition overlaps
+    def check_bit_offsets
+      expected_next_offset = nil
+      previous_item = nil
+      warnings = []
+      @sorted_items.each do |item|
+        if expected_next_offset and item.bit_offset < expected_next_offset
+          msg = "Bit definition overlap at bit offset #{item.bit_offset} for packet #{@target_name} #{@packet_name} items #{item.name} and #{previous_item.name}"
+          Logger.instance.warn(msg)
+          warnings << msg
+        end
+        if item.array_size
+          if item.array_size > 0
+            expected_next_offset = item.bit_offset + item.array_size
+          else
+            expected_next_offset = item.array_size
+          end
+        else
+          expected_next_offset = nil
+          if item.bit_offset > 0
+            # Handle little-endian bit fields
+            byte_aligned = ((item.bit_offset % 8) == 0)
+            if item.endianness == :LITTLE_ENDIAN and (item.data_type == :INT or item.data_type == :UINT) and !(byte_aligned and (item.bit_size == 8 or item.bit_size == 16 or item.bit_size == 32 or item.bit_size == 64))
+              # Bit offset always refers to the most significant bit of a bitfield
+              bits_remaining_in_last_byte = 8 - (item.bit_offset % 8)
+              if item.bit_size > bits_remaining_in_last_byte
+                expected_next_offset = item.bit_offset + bits_remaining_in_last_byte
+              end
+            end
+          end
+          unless expected_next_offset
+            if item.bit_size > 0
+              expected_next_offset = item.bit_offset + item.bit_size
+            else
+              expected_next_offset = item.bit_size
+            end
+          end
+        end
+        previous_item = item
+      end
+      warnings
+    end
+
     # Id items are used by the identify? method to determine if a raw buffer of
     # data represents this packet.
     # @return [Array<PacketItem>] Packet item identifiers
@@ -218,11 +265,24 @@ module Cosmos
     # @param id_value [Object] Set to something other than nil to indicate that
     #   this item should be used to identify a buffer as this packet. The
     #   id_value should make sense according to the data_type.
+    # @return [PacketItem] The new packet item
     def define_item(name, bit_offset, bit_size, data_type, array_size = nil, endianness = @default_endianness, overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
       item = super(name, bit_offset, bit_size, data_type, array_size, endianness, overflow)
       packet_define_item(item, format_string, read_conversion, write_conversion, id_value)
     end
 
+    # Add an item to the packet by adding it to the items hash. It also
+    # resizes the buffer to accomodate the new item.
+    #
+    # @param item [PacketItem] Item to add to the packet
+    # @return [PacketItem] The same packet item
+    def define(item)
+      item = super(item)
+      update_id_items(item)
+      update_limits_items_cache()
+      item
+    end
+
     # Define an item at the end of the packet. This creates a new instance of the
     # item_class as given in the constructor and adds it to the items hash. It
     # also resizes the buffer to accomodate the new item.
@@ -237,6 +297,7 @@ module Cosmos
     # @param read_conversion (see #define_item)
     # @param write_conversion (see #define_item)
     # @param id_value (see #define_item)
+    # @return (see #define_item)
     def append_item(name, bit_size, data_type, array_size = nil, endianness = @default_endianness, overflow = :ERROR, format_string = nil, read_conversion = nil, write_conversion = nil, id_value = nil)
       item = super(name, bit_size, data_type, array_size, endianness, overflow)
       packet_define_item(item, format_string, read_conversion, write_conversion, id_value)
@@ -569,6 +630,7 @@ module Cosmos
     def clone
       packet = super()
       if packet.instance_variable_get("@processors")
+        packet.instance_variable_set("@processors", packet.processors.clone)
         packet.processors.each do |processor_name, processor|
           packet.processors[processor_name] = processor.clone
         end
@@ -703,12 +765,19 @@ module Cosmos
       # Change id_value to the correct type
       if id_value
         item.id_value = id_value
+        update_id_items(item)
+      end
+      item
+    end
+
+    def update_id_items(item)
+      if item.id_value
         @id_items ||= []
         @id_items << item
       end
-
       item
     end
+
   end # class Packet
 
 end # module Cosmos

data/lib/cosmos/packets/packet_config.rb

@@ -10,9 +10,16 @@
 
 require 'cosmos/config/config_parser'
 require 'cosmos/packets/packet'
+require 'cosmos/packets/parsers/packet_parser'
+require 'cosmos/packets/parsers/packet_item_parser'
+require 'cosmos/packets/parsers/macro_parser'
+require 'cosmos/packets/parsers/limits_parser'
+require 'cosmos/packets/parsers/limits_response_parser'
+require 'cosmos/packets/parsers/state_parser'
+require 'cosmos/packets/parsers/format_string_parser'
+require 'cosmos/packets/parsers/processor_parser'
 require 'cosmos/conversions'
 require 'cosmos/processors'
-require 'ostruct'
 
 module Cosmos
 
@@ -49,6 +56,9 @@ module Cosmos
     #   packet is not.
     attr_reader :latest_data
 
+    COMMAND = "Command"
+    TELEMETRY = "Telemetry"
+
     def initialize
       @name = nil
       @telemetry = {}
@@ -69,8 +79,6 @@ module Cosmos
       @telemetry['UNKNOWN']['UNKNOWN'] = Packet.new('UNKNOWN', 'UNKNOWN', :BIG_ENDIAN)
 
       # Used during packet processing
-      @current_target_name = nil
-      @current_packet_name = nil
       @current_cmd_or_tlm = nil
       @current_packet = nil
       @current_item = nil
@@ -86,20 +94,13 @@ module Cosmos
     #
     # @param filename [String] The name of the configuration file
     # @param target_name [String] The target name
-    def process_file(filename, target_name)
+    def process_file(filename, process_target_name)
       @converted_type = nil
       @converted_bit_size = nil
       @proc_text = ''
       @building_generic_conversion = false
-      @macro_append = OpenStruct.new
-      @macro_append.building = false
-      @macro_append.list = []
-      @macro_append.indices = []
-      @macro_append.format = ''
-      @macro_append.format_order = ''
-
-      target_name = target_name.upcase
 
+      process_target_name = process_target_name.upcase
       parser = ConfigParser.new("https://github.com/BallAerospace/COSMOS/wiki/Command-and-Telemetry-Configuration")
       parser.parse_file(filename) do |keyword, params|
 
@@ -127,28 +128,35 @@ module Cosmos
           case keyword
 
           # Start a new packet
-          when 'COMMAND', 'TELEMETRY'
-            process_packet(parser, keyword, params, target_name)
+          when 'COMMAND'
+            finish_packet()
+            @current_packet = PacketParser.parse_command(parser, process_target_name, @commands, @warnings)
+            @current_cmd_or_tlm = COMMAND
+
+          when 'TELEMETRY'
+            finish_packet()
+            @current_packet = PacketParser.parse_telemetry(parser, process_target_name, @telemetry, @latest_data, @warnings)
+            @current_cmd_or_tlm = TELEMETRY
 
           # Select an existing packet for editing
           when 'SELECT_COMMAND', 'SELECT_TELEMETRY'
             usage = "#{keyword} <TARGET NAME> <PACKET NAME>"
             finish_packet()
             parser.verify_num_parameters(2, 2, usage)
-            @current_target_name = target_name
-            @current_target_name = params[0].upcase if target_name == 'SYSTEM'
-            @current_packet_name = params[1].upcase
+            target_name = process_target_name
+            target_name = params[0].upcase if target_name == 'SYSTEM'
+            packet_name = params[1].upcase
 
             @current_packet = nil
             if keyword.include?('COMMAND')
-              @current_cmd_or_tlm = 'Command'
-              if @commands[@current_target_name]
-                @current_packet = @commands[@current_target_name][@current_packet_name]
+              @current_cmd_or_tlm = COMMAND
+              if @commands[target_name]
+                @current_packet = @commands[target_name][packet_name]
               end
             else
-              @current_cmd_or_tlm = 'Telemetry'
-              if @telemetry[@current_target_name]
-                @current_packet = @telemetry[@current_target_name][@current_packet_name]
+              @current_cmd_or_tlm = TELEMETRY
+              if @telemetry[target_name]
+                @current_packet = @telemetry[target_name][packet_name]
               end
             end
             raise parser.error("Packet not found", usage) unless @current_packet
@@ -199,10 +207,10 @@ module Cosmos
 
       # Select an item in the current telemetry packet for editing
       when 'SELECT_PARAMETER', 'SELECT_ITEM'
-        if (@current_cmd_or_tlm == 'Command') && (keyword.split('_')[1] == 'ITEM')
+        if (@current_cmd_or_tlm == COMMAND) && (keyword.split('_')[1] == 'ITEM')
           raise parser.error("SELECT_ITEM only applies to telemetry packets")
         end
-        if (@current_cmd_or_tlm == 'Telemetry') && (keyword.split('_')[1] == 'PARAMETER')
+        if (@current_cmd_or_tlm == TELEMETRY) && (keyword.split('_')[1] == 'PARAMETER')
           raise parser.error("SELECT_PARAMETER only applies to command packets")
         end
         usage = "#{keyword} <#{keyword.split('_')[1]} NAME>"
@@ -211,22 +219,23 @@ module Cosmos
         begin
           @current_item = @current_packet.get_item(params[0])
         rescue # Rescue the default execption to provide a nicer error message
-          raise parser.error("#{params[0]} not found in #{@current_cmd_or_tlm.downcase} packet #{@current_target_name} #{@current_packet_name}", usage)
+          raise parser.error("#{params[0]} not found in #{@current_cmd_or_tlm.downcase} packet #{@current_packet.target_name} #{@current_packet.packet_name}", usage)
         end
 
       # 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'
-        start_item(parser, keyword, params)
+        start_item(parser)
 
       # Start the creation of a macro-expanded list of items
       # This simulates an array of structures of multiple items in the packet by repeating
       # each item in the list multiple times with a different "index" added to the name.
       when 'MACRO_APPEND_START'
-        process_macro_append_start(parser, keyword, params)
+        MacroParser.start(parser)
 
       # End the creation of a macro-expanded list of items
       when 'MACRO_APPEND_END'
-        process_macro_append_end(parser, keyword) # no params for END
+        finish_item()
+        MacroParser.end(parser, @current_packet)
 
       # Allow this packet to be received with less data than the defined length
       # without generating a warning.
@@ -242,7 +251,7 @@ module Cosmos
 
       # Define a processor class that will be called once when a packet is received
       when 'PROCESSOR'
-        process_processor(parser, keyword, params)
+        ProcessorParser.parse(parser, @current_packet, @current_cmd_or_tlm)
 
       when 'DISABLE_MESSAGES'
         usage = "#{keyword}"
@@ -285,7 +294,7 @@ module Cosmos
 
       # Add a state to the current telemety item
       when 'STATE'
-        process_state(parser, keyword, params)
+        StateParser.parse(parser, @current_packet, @current_cmd_or_tlm, @current_item, @warnings)
 
       # Apply a conversion to the current item after it is read to or
       # written from the packet
@@ -349,16 +358,17 @@ module Cosmos
 
       # Define a set of limits for the current telemetry item
       when 'LIMITS'
-        process_limits(parser, keyword, params)
+        @limits_sets << LimitsParser.parse(parser, @current_packet, @current_cmd_or_tlm, @current_item, @warnings)
+        @limits_sets.uniq!
 
       # Define a response class that will be called when the limits state of the
       # current item changes.
       when 'LIMITS_RESPONSE'
-        process_limits_response(parser, keyword, params)
+        LimitsResponseParser.parse(parser, @current_item, @current_cmd_or_tlm)
 
       # Define a printf style formatting string for the current telemetry item
       when 'FORMAT_STRING'
-        process_format_string(parser, keyword, params)
+        FormatStringParser.parse(parser, @current_item)
 
       # Define the units of the current telemetry item
       when 'UNITS'
@@ -378,7 +388,7 @@ module Cosmos
       when 'REQUIRED'
         usage = "REQUIRED"
         parser.verify_num_parameters(0, 0, usage)
-        if @current_cmd_or_tlm == 'Command'
+        if @current_cmd_or_tlm == COMMAND
           @current_item.required = true
         else
           raise parser.error("#{keyword} only applies to command parameters")
@@ -386,7 +396,7 @@ module Cosmos
 
       # Update the mimimum value for the current command parameter
       when 'MINIMUM_VALUE'
-        if @current_cmd_or_tlm == 'Telemetry'
+        if @current_cmd_or_tlm == TELEMETRY
           raise parser.error("#{keyword} only applies to command parameters")
         end
         usage = "MINIMUM_VALUE <MINIMUM VALUE>"
@@ -397,7 +407,7 @@ module Cosmos
 
       # Update the maximum value for the current command parameter
       when 'MAXIMUM_VALUE'
-        if @current_cmd_or_tlm == 'Telemetry'
+        if @current_cmd_or_tlm == TELEMETRY
           raise parser.error("#{keyword} only applies to command parameters")
         end
         usage = "MAXIMUM_VALUE <MAXIMUM VALUE>"
@@ -408,7 +418,7 @@ module Cosmos
 
       # Update the default value for the current command parameter
       when 'DEFAULT_VALUE'
-        if @current_cmd_or_tlm == 'Telemetry'
+        if @current_cmd_or_tlm == TELEMETRY
           raise parser.error("#{keyword} only applies to command parameters")
         end
         usage = "DEFAULT_VALUE <DEFAULT VALUE>"
@@ -430,597 +440,35 @@ module Cosmos
       end
     end
 
-    ####################################################
-    # The following methods process a particular keyword
-
-    def process_macro_append_start(parser, keyword, params)
-      @macro_append.building = true
-
-      usage = '#{keyword} <FIRST INDEX> <LAST INDEX> [NAME FORMAT]'
-      parser.verify_num_parameters(2, 3, usage)
-
-      # Store the params
-      first_index = params[0].to_i
-      last_index  = params[1].to_i
-      @macro_append.indices = [first_index, last_index].sort
-      @macro_append.indices = (@macro_append.indices[0]..@macro_append.indices[1]).to_a
-      @macro_append.indices.reverse! if first_index > last_index
-      @macro_append.format  = params[2] ? params[2] : '%s%d'
-      spos = @macro_append.format.index(/%\d*s/)
-      dpos = @macro_append.format.index(/%\d*d/)
-      raise parser.error("Invalid NAME FORMAT (#{@macro_append.format}) for MACRO_APPEND_START", usage) unless spos and dpos
-      if spos < dpos
-        @macro_append.format_order = 'sd'
-      else
-        @macro_append.format_order = 'ds'
-      end
-    end
-
-    def process_macro_append_end(parser, keyword)
-      update_cache = false
-      finish_item()
-      parser.verify_num_parameters(0, 0, keyword)
-      raise parser.error("Missing MACRO_APPEND_START before this config.line.", keyword) unless @macro_append.building
-      raise parser.error("No items appended in MACRO_APPEND list", keyword) unless @macro_append.list.length > 0
-
-      # Get first index, remove from array
-      first = @macro_append.indices.shift
-
-      # Rename the items in the list using the first index
-      items = @current_packet.items
-      @macro_append.list.each do |name|
-        item = items[name]
-        items.delete name
-        if @macro_append.format_order == 'sd'
-          first_name = sprintf(@macro_append.format, name, first)
-        else
-          first_name = sprintf(@macro_append.format, first, name)
-        end
-        item.name = first_name
-        items[first_name] = item
-      end
-
-      # Append multiple copies of the items in the list
-      @macro_append.indices.each do |index|
-        @macro_append.list.each do |name|
-          if @macro_append.format_order == 'sd'
-            first_name = sprintf(@macro_append.format, name, first)
-            this_name = sprintf(@macro_append.format, name, index)
-          else
-            first_name = sprintf(@macro_append.format, first, name)
-            this_name = sprintf(@macro_append.format, index, name)
-          end
-          first_item = items[first_name]
-          format_string = nil
-          format_string = first_item.format_string if first_item.format_string
-          this_item = @current_packet.append_item(this_name,
-                                                  first_item.bit_size,
-                                                  first_item.data_type,
-                                                  first_item.array_size,
-                                                  first_item.endianness,
-                                                  first_item.overflow,
-                                                  format_string,
-                                                  first_item.read_conversion,
-                                                  first_item.write_conversion,
-                                                  first_item.id_value)
-          this_item.states = first_item.states if first_item.states
-          this_item.description = first_item.description if first_item.description
-          this_item.units_full = first_item.units_full if first_item.units_full
-          this_item.units = first_item.units if first_item.units
-          this_item.default = first_item.default
-          this_item.range = first_item.range if first_item.range
-          this_item.required = first_item.required
-          this_item.hazardous = first_item.hazardous
-          if first_item.state_colors
-            this_item.state_colors = first_item.state_colors
-            update_cache = true
-          end
-          if first_item.limits
-            this_item.limits = first_item.limits
-            update_cache = true
-          end
-        end
-      end
-      @current_packet.update_limits_items_cache if update_cache
-
-      @macro_append.building = false
-      @macro_append.indices = []
-      @macro_append.list = []
-    end
-
-    def process_state(parser, keyword, params)
-      if @current_cmd_or_tlm == 'Command'
-        usage = "#{keyword} <STATE NAME> <STATE VALUE> <HAZARDOUS (Optional)> <Hazardous Description (Optional)>"
-        parser.verify_num_parameters(2, 4, usage)
-      else
-        usage = "#{keyword} <STATE NAME> <STATE VALUE> <COLOR: GREEN/YELLOW/RED (Optional)>"
-        parser.verify_num_parameters(2, 3, usage)
-      end
-      @current_item.states ||= {}
-      if @current_item.states[params[0].upcase]
-        msg = "Duplicate state defined on line #{parser.line_number}: #{parser.line}"
-        Logger.instance.warn(msg)
-        @warnings << msg
-      end
-      if @current_item.data_type == :STRING or @current_item.data_type == :BLOCK
-        @current_item.states[params[0].upcase] = params[1]
-      else
-        @current_item.states[params[0].upcase] = params[1].convert_to_value
-      end
-      if params[2]
-        if @current_cmd_or_tlm == 'Command'
-          if params[2].upcase == 'HAZARDOUS'
-            @current_item.hazardous ||= {}
-            if params[3]
-              @current_item.hazardous[params[0].upcase] = params[3]
-            else
-              @current_item.hazardous[params[0].upcase] = ""
-            end
-          else
-            raise parser.error("HAZARDOUS expected as third parameter for this line.", usage)
-          end
-        else
-          if params[2]
-            color = params[2].upcase.to_sym
-            unless PacketItem::STATE_COLORS.include? color
-              raise parser.error("Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}.", usage)
-            end
-            @current_item.limits ||= Limits.new
-            @current_item.limits.enabled = true
-            @current_item.state_colors ||= {}
-            @current_item.state_colors[params[0].upcase] = color
-            @current_packet.update_limits_items_cache
-          end
-        end
-      end
-    end
-
-    def process_limits(parser, keyword, params)
-      if @current_cmd_or_tlm == 'Command'
-        raise parser.error("#{keyword} only applies to telemetry items")
-      end
-      usage = "#{keyword} <LIMITS SET> <PERSISTENCE> <ENABLED/DISABLED> <RED LOW LIMIT> <YELLOW LOW LIMIT> <YELLOW HIGH LIMIT> <RED HIGH LIMIT> <GREEN LOW LIMIT (Optional)> <GREEN HIGH LIMIT (Optional)>"
-      parser.verify_num_parameters(7, 9, usage)
-
-      begin
-        persistence = Integer(params[1])
-        red_low = Float(params[3])
-        yellow_low = Float(params[4])
-        yellow_high = Float(params[5])
-        red_high = Float(params[6])
-      rescue
-        raise parser.error("Invalid persistence or limits values. Ensure persistence is an integer. Limits can be integers or floats.", usage)
-      end
-
-      enabled = params[2].upcase
-      if enabled != 'ENABLED' and enabled != 'DISABLED'
-        raise parser.error("Initial state must be ENABLED or DISABLED.", usage)
-      end
-
-      # Verify valid limits are specified
-      if (red_low > yellow_low) or (yellow_low >= yellow_high) or (yellow_high > red_high)
-        raise parser.error("Invalid limits specified. Ensure yellow limits are within red limits.", usage)
-      end
-      if params.length != 7
-        begin
-          green_low = Float(params[7])
-          green_high = Float(params[8])
-        rescue
-          raise parser.error("Invalid green limits values. Limits can be integers or floats.", usage)
-        end
-
-        if (yellow_low > green_low) or (green_low >= green_high) or (green_high > yellow_high)
-          raise parser.error("Invalid limits specified. Ensure green limits are within yellow limits.", usage)
-        end
-      end
-
-      limits_set = params[0].upcase.to_sym
-      @limits_sets << limits_set
-      @limits_sets.uniq!
-      # Initialize the limits values. Values must be initialized with a :DEFAULT key
-      if !@current_item.limits.values
-        if limits_set == :DEFAULT
-          @current_item.limits.values = {:DEFAULT => []}
-        else
-          raise parser.error("DEFAULT limits must be defined for #{@current_packet.target_name} #{@current_packet.packet_name} #{@current_item.name} before setting limits set #{limits_set}")
-        end
-      end
-      if limits_set != :DEFAULT
-        msg = nil
-        if (enabled == 'ENABLED' and @current_item.limits.enabled != true) or (enabled != 'ENABLED' and @current_item.limits.enabled != false)
-          msg = "#{@current_cmd_or_tlm} Item #{@current_target_name} #{@current_packet_name} #{@current_item.name} #{limits_set} limits enable setting conflict with DEFAULT"
-        end
-        if @current_item.limits.persistence_setting != persistence
-          msg = "#{@current_cmd_or_tlm} Item #{@current_target_name} #{@current_packet_name} #{@current_item.name} #{limits_set} limits persistence setting conflict with DEFAULT"
-        end
-        if msg
-          Logger.instance.warn msg
-          @warnings << msg
-        end
-      end
-      @current_item.limits.enabled = true if enabled == 'ENABLED'
-      values = @current_item.limits.values
-      if params.length == 7
-        values[limits_set] = [red_low, yellow_low, yellow_high, red_high]
-      else
-        values[limits_set] = [red_low, yellow_low, yellow_high, red_high, green_low, green_high]
-      end
-      @current_item.limits.values = values
-      @current_item.limits.persistence_setting = persistence
-      @current_item.limits.persistence_count   = 0
-      @current_packet.update_limits_items_cache
-    end
-
-    def process_limits_response(parser, keyword, params)
-      if @current_cmd_or_tlm == 'Command'
-        raise parser.error("#{keyword} only applies to telemetry items")
-      end
-      usage = "#{keyword} <RESPONSE CLASS FILENAME> <RESPONSE SPECIFIC OPTIONS>"
-      parser.verify_num_parameters(1, nil, usage)
-
-      begin
-        # require should be performed in target.txt
-        klass = params[0].filename_to_class_name.to_class
-        raise parser.error("#{params[0].filename_to_class_name} class not found. Did you require the file in target.txt?", usage) unless klass
-        if params[1]
-          @current_item.limits.response = klass.new(*params[1..(params.length - 1)])
-        else
-          @current_item.limits.response = klass.new
-        end
-      rescue Exception => err
-        raise parser.error(err, usage)
-      end
-    end
-
-    def process_processor(parser, keyword, params)
-      if @current_cmd_or_tlm == 'Command'
-        raise parser.error("#{keyword} only applies to telemetry packets")
-      end
-      usage = "#{keyword} <PROCESSOR NAME> <PROCESSOR CLASS FILENAME> <PROCESSOR SPECIFIC OPTIONS>"
-      parser.verify_num_parameters(2, nil, usage)
-
-      begin
-        # require should be performed in target.txt
-        klass = params[1].filename_to_class_name.to_class
-        raise parser.error("#{params[1].filename_to_class_name} class not found. Did you require the file in target.txt?", usage) unless klass
-        if params[2]
-          processor = klass.new(*params[2..(params.length - 1)])
-        else
-          processor = klass.new
-        end
-        raise ArgumentError, "processor must be a Cosmos::Processor but is a #{processor.class}" unless Cosmos::Processor === processor
-        processor.name = params[0]
-        @current_packet.processors[params[0].to_s.upcase] = processor
-      rescue Exception => err
-        raise parser.error(err, usage)
-      end
-    end
-
-    def process_format_string(parser, keyword, params)
-      usage = "#{keyword} <PRINTF STYLE STRING>"
-      parser.verify_num_parameters(1, 1, usage)
-      @current_item.format_string = params[0]
-      unless @current_item.read_conversion
-        # Check format string as long as a read conversion has not been defined
-        begin
-          case @current_item.data_type
-          when :INT, :UINT
-            sprintf(@current_item.format_string, 0)
-          when :FLOAT
-            sprintf(@current_item.format_string, 0.0)
-          when :STRING, :BLOCK
-            sprintf(@current_item.format_string, 'Hello')
-          else
-            # Nothing to do
-          end
-        rescue Exception
-          raise parser.error("Invalid #{keyword} specified for type #{@current_item.data_type}: #{params[0]}", usage)
-        end
-      end
-    end
-
-    def process_packet(parser, keyword, params, target_name)
-      finish_packet()
-
-      usage = "#{keyword} <TARGET NAME> <PACKET NAME> <ENDIANNESS: BIG_ENDIAN/LITTLE_ENDIAN> <DESCRIPTION (Optional)>"
-      parser.verify_num_parameters(3, 4, usage)
-      target_name = params[0].to_s.upcase if target_name == 'SYSTEM'
-      packet_name = params[1].to_s.upcase
-      endianness = params[2].to_s.upcase.intern
-      description = params[3].to_s
-      if endianness != :BIG_ENDIAN and endianness != :LITTLE_ENDIAN
-        raise parser.error("Invalid endianness #{params[2]}. Must be BIG_ENDIAN or LITTLE_ENDIAN.", usage)
-      end
-
-      @current_target_name = target_name
-      @current_packet_name = packet_name
-      @current_cmd_or_tlm = keyword.capitalize
-
-      # Be sure there is not already a packet by this name
-      if @current_cmd_or_tlm == 'Command'
-        if @commands[@current_target_name]
-          if @commands[@current_target_name][@current_packet_name]
-            msg = "#{@current_cmd_or_tlm} Packet #{@current_target_name} #{@current_packet_name} redefined."
-            Logger.instance.warn msg
-            @warnings << msg
-          end
-        end
-      else
-        if @telemetry[@current_target_name]
-          if @telemetry[@current_target_name][@current_packet_name]
-            msg = "#{@current_cmd_or_tlm} Packet #{@current_target_name} #{@current_packet_name} redefined."
-            Logger.instance.warn msg
-            @warnings << msg
-          end
-        end
-      end
-
-      @current_packet = Packet.new(@current_target_name, @current_packet_name, endianness, description)
-
-      # Add received time packet items
-      if @current_cmd_or_tlm == 'Telemetry'
-        item = @current_packet.define_item('RECEIVED_TIMESECONDS', 0, 0, :DERIVED, nil, @current_packet.default_endianness, :ERROR, '%0.6f', ReceivedTimeSecondsConversion.new)
-        item.description = 'COSMOS Received Time (UTC, Floating point, Unix epoch)'
-        item = @current_packet.define_item('RECEIVED_TIMEFORMATTED', 0, 0, :DERIVED, nil, @current_packet.default_endianness, :ERROR, nil, ReceivedTimeFormattedConversion.new)
-        item.description = 'COSMOS Received Time (Local time zone, Formatted string)'
-        item = @current_packet.define_item('RECEIVED_COUNT', 0, 0, :DERIVED, nil, @current_packet.default_endianness, :ERROR, nil, ReceivedCountConversion.new)
-        item.description = 'COSMOS packet received count'
-
-        unless @telemetry[@current_target_name]
-          @telemetry[@current_target_name] = {}
-          @latest_data[@current_target_name] = {}
-        end
-      else
-        @commands[@current_target_name] ||= {}
-      end
-    end
-
     # Add current packet into hash if it exists
     def finish_packet
       finish_item()
       if @current_packet
-        # Review bit offset to look for overlapping definitions
-        # This will allow gaps in the packet, but not allow the same bits to be
-        # used for multiple variables.
-        expected_next_offset = nil
-        previous_item = nil
-        @current_packet.sorted_items.each do |item|
-          if expected_next_offset and item.bit_offset < expected_next_offset
-            msg = "Bit definition overlap at bit offset #{item.bit_offset} for #{@current_cmd_or_tlm} packet #{@current_target_name} #{@current_packet_name} items #{item.name} and #{previous_item.name}"
-            Logger.instance.warn(msg)
-            @warnings << msg
-          end
-          if item.array_size
-            if item.array_size > 0
-              expected_next_offset = item.bit_offset + item.array_size
-            else
-              expected_next_offset = item.array_size
-            end
-          else
-            expected_next_offset = nil
-            if item.bit_offset > 0
-              # Handle little-endian bit fields
-              byte_aligned = ((item.bit_offset % 8) == 0)
-              if item.endianness == :LITTLE_ENDIAN and (item.data_type == :INT or item.data_type == :UINT) and !(byte_aligned and (item.bit_size == 8 or item.bit_size == 16 or item.bit_size == 32 or item.bit_size == 64))
-                # Bitoffset always refers to the most significant bit of a bitfield
-                bits_remaining_in_last_byte = 8 - (item.bit_offset % 8)
-                if item.bit_size > bits_remaining_in_last_byte
-                  expected_next_offset = item.bit_offset + bits_remaining_in_last_byte
-                end
-              end
-            end
-            unless expected_next_offset
-              if item.bit_size > 0
-                expected_next_offset = item.bit_offset + item.bit_size
-              else
-                expected_next_offset = item.bit_size
-              end
-            end
-          end
-          previous_item = item
-
-          # Check command default and range data types if no write conversion is present
-          item.check_default_and_range_data_types if @current_cmd_or_tlm == 'Command'
-        end
+        @warnings += @current_packet.check_bit_offsets
 
-        # commit packet to memory
-        if @current_cmd_or_tlm == 'Command'
-          @commands[@current_target_name][@current_packet_name] = @current_packet
+        if @current_cmd_or_tlm == COMMAND
+          PacketParser.check_item_data_types(@current_packet)
+          @commands[@current_packet.target_name][@current_packet.packet_name] = @current_packet
         else
-          @telemetry[@current_target_name][@current_packet_name] = @current_packet
+          @telemetry[@current_packet.target_name][@current_packet.packet_name] = @current_packet
         end
         @current_packet = nil
         @current_item = nil
       end
     end
 
-    # There are many different usages of the ITEM keword so parse the keyword
-    # and parameters to generate the correct usage information.
-    def generate_item_usage(keyword, params)
-      usage = "#{keyword} <ITEM NAME> "
-      usage << "<BIT OFFSET> " unless keyword.include?("APPEND")
-      if keyword.include?("ARRAY")
-        usage << "<ARRAY ITEM BIT SIZE> "
-      else
-        usage << "<BIT SIZE> "
-      end
-      if keyword.include?("PARAMETER")
-        if keyword.include?("ARRAY")
-          usage << "<TYPE: INT/UINT/FLOAT/STRING/BLOCK> "
-        else
-          if keyword.include?("APPEND")
-            data_type = params[2].upcase.to_sym
-          else
-            data_type = params[3].upcase.to_sym
-          end
-          if data_type == :STRING or data_type == :BLOCK
-            if keyword.include?("ID")
-              usage << "<TYPE: STRING/BLOCK> "
-            else
-              usage << "<TYPE: STRING/BLOCK> <DEFAULT VALUE>"
-            end
-          else
-            if keyword.include?("ID")
-              usage << "<TYPE: INT/UINT/FLOAT> <MIN VALUE> <MAX VALUE> "
-            else
-              usage << "<TYPE: INT/UINT/FLOAT/DERIVED> <MIN VALUE> <MAX VALUE> <DEFAULT VALUE>"
-            end
-          end
-        end
-      else
-        usage << "<TYPE: INT/UINT/FLOAT/STRING/BLOCK/DERIVED> "
-      end
-      usage << "<TOTAL ARRAY BIT SIZE> " if keyword.include?("ARRAY")
-      if keyword.include?("ID")
-        if keyword.include?("PARAMETER")
-          usage << "<DEFAULT AND ID VALUE> "
-        else
-          usage << "<ID VALUE> "
-        end
-      end
-      usage << "<DESCRIPTION (Optional)> <ENDIANNESS (Optional)>"
-      return usage
-    end
-
-    def start_item(parser, keyword, params)
+    def start_item(parser)
       finish_item()
-
-      usage = generate_item_usage(keyword, params)
-      max_options = usage.count("<")
-      parser.verify_num_parameters(max_options-2, max_options, usage)
-      begin
-        if params[max_options-1]
-          endianness = params[max_options-1].to_s.upcase.intern
-          if endianness != :BIG_ENDIAN and endianness != :LITTLE_ENDIAN
-            raise parser.error("Invalid endianness #{params[2]}. Must be BIG_ENDIAN or LITTLE_ENDIAN.", usage)
-          end
-        else
-          endianness = @current_packet.default_endianness
-        end
-
-        case keyword
-        when /ITEM/
-          raise parser.error("ITEM types are only valid with TELEMETRY", usage) if @current_cmd_or_tlm == 'Command'
-          # If this is an APPEND we don't have a bit offset so the index
-          # into the parameters changes
-          index = (keyword =~ /APPEND/) ? 3 : 4
-          id_value = (keyword =~ /ID_ITEM/) ? params[index] : nil
-          array_size = (keyword =~ /ARRAY_ITEM/) ? Integer(params[index]) : nil
-          case keyword
-          when 'ITEM',  'ID_ITEM', 'ARRAY_ITEM'
-            @current_item = @current_packet.define_item(params[0], # name
-                                               Integer(params[1]), # bit offset
-                                               Integer(params[2]), # bit size
-                                               params[3].upcase.to_sym, # data_type
-                                               array_size, # array size
-                                               endianness, # endianness
-                                               :ERROR, # overflow
-                                               nil, # format string
-                                               nil, # read conversion
-                                               nil, # write conversion
-                                               id_value) # id value
-          when 'APPEND_ITEM', 'APPEND_ID_ITEM', 'APPEND_ARRAY_ITEM'
-            @current_item = @current_packet.append_item(params[0], # name
-                                               Integer(params[1]), # bit size
-                                               params[2].upcase.to_sym, # data_type
-                                               array_size, # array size
-                                               endianness, # endianness
-                                               :ERROR, # overflow
-                                               nil, # format string
-                                               nil, # read conversion
-                                               nil, # write conversion
-                                               id_value) # id value
-          end
-        when 'PARAMETER',  'ID_PARAMETER', 'ARRAY_PARAMETER'
-          raise parser.error("PARAMETER types are only valid with COMMAND", usage) if @current_cmd_or_tlm == 'Telemetry'
-          data_type = params[3].upcase.to_sym
-          id_value = nil
-          if keyword == 'ID_PARAMETER'
-            if data_type == :DERIVED
-              raise "DERIVED data type not allowed"
-            elsif data_type == :STRING or data_type == :BLOCK
-              id_value = params[4]
-            else
-              id_value = params[6]
-            end
-          end
-          array_size = (keyword == 'ARRAY_PARAMETER') ? Integer(params[4]) : nil
-          @current_item = @current_packet.define_item(params[0], # name
-                                             Integer(params[1]), # bit offset
-                                             Integer(params[2]), # bit size
-                                             data_type, # data_type
-                                             array_size, # array size
-                                             endianness, # endianness
-                                             :ERROR, # overflow
-                                             nil, # format string
-                                             nil, # read conversion
-                                             nil, # write conversion
-                                             id_value) # id value
-          if keyword == 'ARRAY_PARAMETER'
-            @current_item.default = []
-          else
-            if data_type == :STRING or data_type == :BLOCK
-              @current_item.default = params[4]
-            else
-              @current_item.range =
-                (ConfigParser.handle_defined_constants(params[4].convert_to_value))..(ConfigParser.handle_defined_constants(params[5].convert_to_value))
-              @current_item.default = ConfigParser.handle_defined_constants(params[6].convert_to_value)
-            end
-          end
-        when 'APPEND_PARAMETER',  'APPEND_ID_PARAMETER', 'APPEND_ARRAY_PARAMETER'
-          raise parser.error("PARAMETER types are only valid with COMMAND", usage) if @current_cmd_or_tlm == 'Telemetry'
-          data_type = params[2].upcase.to_sym
-          id_value = nil
-          if keyword == 'APPEND_ID_PARAMETER'
-            if data_type == :DERIVED
-              raise "DERIVED data type not allowed"
-            elsif data_type == :STRING or data_type == :BLOCK
-              id_value = params[3]
-            else
-              id_value = params[5]
-            end
-          end
-          array_size = (keyword == 'APPEND_ARRAY_PARAMETER') ? Integer(params[3]) : nil
-          @current_item = @current_packet.append_item(params[0], # name
-                                             Integer(params[1]), # bit size
-                                             data_type, # data_type
-                                             array_size, # array size
-                                             endianness, # endianness
-                                             :ERROR, # overflow
-                                             nil, # format string
-                                             nil, # read conversion
-                                             nil, # write conversion
-                                             id_value) # id value
-          if keyword == 'APPEND_ARRAY_PARAMETER'
-            @current_item.default = []
-          else
-            if data_type == :STRING or data_type == :BLOCK
-              @current_item.default = params[3]
-            else
-              @current_item.range =
-                (ConfigParser.handle_defined_constants(params[3].convert_to_value))..(ConfigParser.handle_defined_constants(params[4].convert_to_value))
-              @current_item.default = ConfigParser.handle_defined_constants(params[5].convert_to_value)
-            end
-          end
-        end
-        @current_item.description = params[max_options-2] if params[max_options-2]
-
-        if keyword.include?('APPEND') && @macro_append.building
-          @macro_append.list << params[0].upcase
-        end
-
-      # Rescue the item processing since they could also throw configuration errors
-      rescue => err
-        raise parser.error(err, usage)
-      end
+      @current_item = PacketItemParser.parse(parser, @current_packet, @current_cmd_or_tlm)
+      MacroParser.new_item()
     end
 
-    # Finish updating item in packet
+    # Finish updating packet item
     def finish_item
       if @current_item
         @current_packet.set_item(@current_item)
-        if @current_cmd_or_tlm == 'Telemetry'
-          target_latest_data = @latest_data[@current_target_name]
+        if @current_cmd_or_tlm == TELEMETRY
+          target_latest_data = @latest_data[@current_packet.target_name]
           target_latest_data[@current_item.name] ||= []
           latest_data_packets = target_latest_data[@current_item.name]
           latest_data_packets << @current_packet unless latest_data_packets.include?(@current_packet)