adams-visiona 1.0.0

data/lib/cosmos/packets/parsers/limits_parser.rb

@@ -0,0 +1,147 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+module Cosmos
+
+  class LimitsParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param packet [Packet] The current packet
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    # @param item [PacketItem] The packet item to create limits on
+    # @param warnings [Array<String>] Array of string warnings which will be
+    #   appended with any warnings found when parsing the limits
+    def self.parse(parser, packet, cmd_or_tlm, item, warnings)
+      raise parser.error("Items with STATE can't define LIMITS") if item.states
+      @parser = LimitsParser.new(parser)
+      @parser.verify_parameters(cmd_or_tlm)
+      @parser.create_limits(packet, item, warnings)
+    end
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def verify_parameters(cmd_or_tlm)
+      if cmd_or_tlm == PacketConfig::COMMAND
+        raise @parser.error("LIMITS only applies to telemetry items")
+      end
+      @usage = "LIMITS <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)
+    end
+
+    # @param packet [Packet] The packet the item should be added to
+    def create_limits(packet, item, warnings)
+      limits_set = get_limits_set()
+      initialize_limits_values(packet, item)
+      ensure_consistency_with_default(packet, item, warnings)
+
+      item.limits.values[limits_set] = get_values()
+      item.limits.enabled = get_enabled()
+      item.limits.persistence_setting = get_persistence()
+      item.limits.persistence_count = 0
+
+      packet.update_limits_items_cache(item)
+      limits_set
+    end
+
+    private
+
+    def initialize_limits_values(packet, item)
+      limits_set = get_limits_set()
+      # Values must be initialized with a :DEFAULT key
+      if !item.limits.values
+        if limits_set == :DEFAULT
+          item.limits.values = {:DEFAULT => []}
+        else
+          raise @parser.error("DEFAULT limits set must be defined for #{packet.target_name} #{packet.packet_name} #{item.name} before setting limits set #{limits_set}")
+        end
+      end
+    end
+
+    def ensure_consistency_with_default(packet, item, warnings)
+      # Nothing to do if we're already :DEFAULT
+      return if get_limits_set() == :DEFAULT
+
+      msg = "TELEMETRY Item #{packet.target_name} #{packet.packet_name} #{item.name} #{get_limits_set()} limits _TYPE_ setting conflict with DEFAULT"
+      # XOR our setting with the items current setting
+      # If it returns true then we have a mismatch and log the error
+      if (get_enabled() ^ item.limits.enabled)
+        warnings << msg.sub('_TYPE_', 'enable')
+        Logger.instance.warn warnings[-1]
+      end
+      if item.limits.persistence_setting != get_persistence()
+        warnings << msg.sub('_TYPE_', 'persistence')
+        Logger.instance.warn warnings[-1]
+      end
+    end
+
+    def get_limits_set
+      @parser.parameters[0].upcase.to_sym
+    end
+
+    def get_persistence
+      Integer(@parser.parameters[1])
+    rescue
+      raise @parser.error("Persistence must be an integer.", @usage)
+    end
+
+    def get_enabled
+      enabled = @parser.parameters[2].upcase
+      if enabled != 'ENABLED' and enabled != 'DISABLED'
+        raise @parser.error("Initial LIMITS state must be ENABLED or DISABLED.", @usage)
+      end
+      enabled == 'ENABLED' ? true : false
+    end
+
+    def get_values
+      values = get_red_yellow_values()
+      values += get_green_values(values[1], values[2])
+      values
+    end
+
+    def get_red_yellow_values
+      params = @parser.parameters
+      err = nil
+      red_low = Float(params[3]) rescue err = "red low"
+      yellow_low = Float(params[4]) rescue err = "yellow low"
+      yellow_high = Float(params[5]) rescue err = "yellow high"
+      red_high = Float(params[6]) rescue err = "red high"
+      raise @parser.error("Invalid #{err} limit value. Limits can be integers or floats.", @usage) if err
+
+      # 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
+      [red_low, yellow_low, yellow_high, red_high]
+    end
+
+    def get_green_values(yellow_low, yellow_high)
+      params = @parser.parameters
+      # Since our initial parameter check verifies between 7 and 9 we do a
+      # special check for 8 parameters which is an error
+      if params.length == 8
+        raise @parser.error("Must give both a green low and green high value.", @usage)
+      end
+      return [] unless params.length == 9
+
+      err = nil
+      green_low = Float(params[7]) rescue err = "green low"
+      green_high = Float(params[8]) rescue err = "green high"
+      raise @parser.error("Invalid #{err} limit value. Limits can be integers or floats.", @usage) if err
+
+      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
+      [green_low, green_high]
+    end
+
+  end
+end # module Cosmos

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

@@ -0,0 +1,52 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+module Cosmos
+
+  class LimitsResponseParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param item [Packet] The current item
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def self.parse(parser, item, cmd_or_tlm)
+      @parser = LimitsResponseParser.new(parser)
+      @parser.verify_parameters(cmd_or_tlm)
+      @parser.create_limits_response(item)
+    end
+
+    # @param parser [ConfigParser] Configuration parser
+    def initialize(parser)
+      @parser = parser
+    end
+
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def verify_parameters(cmd_or_tlm)
+      if cmd_or_tlm == PacketConfig::COMMAND
+        raise @parser.error("LIMITS_RESPONSE only applies to telemetry items")
+      end
+      @usage = "LIMITS_RESPONSE <RESPONSE CLASS FILENAME> <RESPONSE SPECIFIC OPTIONS>"
+      @parser.verify_num_parameters(1, nil, @usage)
+    end
+
+    # @param item [PacketItem] The item the limits response should be added to
+    def create_limits_response(item)
+      # require should be performed in target.txt
+      klass = @parser.parameters[0].filename_to_class_name.to_class
+      raise @parser.error("#{@parser.parameters[0].filename_to_class_name} class not found. Did you require the file in target.txt?", @usage) unless klass
+      if @parser.parameters[1]
+        item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])
+      else
+        item.limits.response = klass.new
+      end
+    rescue Exception => err
+      raise @parser.error(err, @usage)
+    end
+
+  end
+end # module Cosmos

data/lib/cosmos/packets/parsers/macro_parser.rb

@@ -0,0 +1,121 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'ostruct'
+
+module Cosmos
+  # Parses a macro definition in a command or telemetry configuration file.
+  # Note: Using ERB to define multiple items is now the preferred solution.
+  class MacroParser
+    @macro = nil
+
+    # Adds a new item to the Macro
+    def self.new_item
+      return unless @macro
+      @macro.new_item
+    end
+
+    # Starts a new Macro
+    #
+    # @param parser [ConfigParser] Configuration Parser
+    def self.start(parser)
+      if @macro
+        @macro = nil
+        raise parser.error("First close the previous MACRO_APPEND_START with a MACRO_APPEND_END")
+      else
+        @macro = MacroParser.new(parser)
+      end
+    end
+
+    # Ends the Macro and adds all the items to the packet
+    #
+    # @param parser [ConfigParser] Configuration Parser
+    # @param packet [Packet] Packet to add the macro items to
+    def self.end(parser, packet)
+      raise parser.error("First start a macro with MACRO_APPEND_START") unless @macro
+      @macro.complete(packet)
+    ensure
+      # Ensure this class instance variable gets cleared so we can process the
+      # next call to start
+      @macro = nil
+    end
+
+    # @param parser [ConfigParser] Configuration Parser
+    def initialize(parser)
+      @parser = parser
+      @usage = '#{keyword} <FIRST INDEX> <LAST INDEX> [NAME FORMAT]'
+      parser.verify_num_parameters(2, 3, @usage)
+      @macro = OpenStruct.new(:started => true, :list => [])
+      first_index = parser.parameters[0].to_i
+      last_index  = parser.parameters[1].to_i
+      if first_index < last_index
+        @macro.indices = (first_index..last_index).to_a
+      else
+        @macro.indices = (last_index..first_index).to_a.reverse
+      end
+      @macro.format = parser.parameters[2] ? parser.parameters[2] : '%s%d'
+      @macro.format_order = get_format_order()
+    end
+
+    def new_item
+      if @parser.keyword.include?('APPEND')
+        @macro.list << @parser.parameters[0].upcase
+      end
+    end
+
+    def complete(packet)
+      @parser.verify_num_parameters(0, 0, @parser.keyword)
+      raise @parser.error("Missing MACRO_APPEND_START before this config.line.", @parser.keyword) unless @macro
+      raise @parser.error("No items appended in MACRO_APPEND list", @parser.keyword) if @macro.list.empty?
+
+      create_new_packet_items(packet)
+    end
+
+    private
+
+    def format_item_name(name, index)
+      if @macro.format_order == 'sd'
+        sprintf(@macro.format, name, index)
+      else
+        sprintf(@macro.format, index, name)
+      end
+    end
+
+    def create_new_packet_items(packet)
+      first_index = @macro.indices[0]
+      items = {}
+
+      @macro.indices.each do |index|
+        @macro.list.each do |name|
+          # The first index we just rename the item(s)
+          if index == first_index
+            new_name = format_item_name(name, first_index)
+            items[name] = packet.rename_item(name, new_name)
+          else # Subsequent indexes we clone the first item(s) and append them
+            new_item = items[name].clone
+            new_item.name = format_item_name(name, index)
+            packet.append(new_item)
+          end
+        end
+      end
+    end
+
+    def get_format_order()
+      string_index = @macro.format.index(/%\d*s/)
+      num_index = @macro.format.index(/%\d*d/)
+      raise parser.error("Invalid NAME FORMAT (#{@macro.format}) for MACRO_APPEND_START", @usage) unless string_index && num_index
+      if string_index < num_index
+        @macro.format_order = 'sd'
+      else
+        @macro.format_order = 'ds'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,252 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/packets/packet_item'
+
+module Cosmos
+  # Parses a packet item definition and creates a new PacketItem
+  class PacketItemParser
+    # This number is a little arbitrary but there are definitely issues at
+    # 1 million and you really shouldn't be doing anything this big anyway
+    BIG_ARRAY_SIZE = 100_000
+
+    # @param parser [ConfigParser] Configuration parser
+    # @param packet [Packet] The packet the item should be added to
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    # @param warnings [Array<String>] Array of warning strings from PacketConfig
+    def self.parse(parser, packet, cmd_or_tlm, warnings)
+      parser = PacketItemParser.new(parser, warnings)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_packet_item(packet, cmd_or_tlm)
+    end
+
+    # @param parser [ConfigParser] Configuration parser
+    # @param warnings [Array<String>] Array of warning strings from PacketConfig
+    def initialize(parser, warnings)
+      @parser = parser
+      @warnings = warnings
+      @usage = get_usage()
+    end
+
+    def verify_parameters(cmd_or_tlm)
+      if @parser.keyword.include?('ITEM') && cmd_or_tlm == PacketConfig::COMMAND
+        raise @parser.error("ITEM types are only valid with TELEMETRY", @usage)
+      elsif @parser.keyword.include?('PARAMETER') && cmd_or_tlm == PacketConfig::TELEMETRY
+        raise @parser.error("PARAMETER types are only valid with COMMAND", @usage)
+      end
+      # The usage is formatted with brackets <XXX> around each option so
+      # count the number of open brackets to determine the number of options
+      max_options = @usage.count("<")
+      # The last two options (description and endianness) are optional
+      @parser.verify_num_parameters(max_options-2, max_options, @usage)
+    end
+
+    def create_packet_item(packet, cmd_or_tlm)
+      item_name = @parser.parameters[0].upcase
+      if packet.items[item_name]
+        msg = "#{packet.target_name} #{packet.packet_name} #{item_name} redefined."
+        Logger.instance.warn msg
+        @warnings << msg
+      end
+      item = PacketItem.new(item_name,
+                            get_bit_offset(),
+                            get_bit_size(),
+                            get_data_type(),
+                            get_endianness(packet),
+                            get_array_size(),
+                            :ERROR) # overflow
+      if cmd_or_tlm == PacketConfig::COMMAND
+        item.range = get_range()
+        item.default = get_default()
+      end
+      item.id_value = get_id_value()
+      item.description = get_description()
+      if append?
+        item = packet.append(item)
+      else
+        item = packet.define(item)
+      end
+      item
+    rescue => err
+      raise @parser.error(err, @usage)
+    end
+
+    private
+
+    def append?
+      @parser.keyword.include?("APPEND")
+    end
+
+    def get_data_type
+      index = append? ? 2 : 3
+      @parser.parameters[index].upcase.to_sym
+    end
+
+    def get_bit_offset
+      return 0 if append?
+      Integer(@parser.parameters[1])
+    rescue => err # In case Integer fails
+      raise @parser.error(err, @usage)
+    end
+
+    def get_bit_size
+      index = append? ? 1 : 2
+      Integer(@parser.parameters[index])
+    rescue => err
+      raise @parser.error(err, @usage)
+    end
+
+    def get_array_size
+      return nil unless (@parser.keyword.include?('ARRAY'))
+      index = append? ? 3 : 4
+      array_bit_size = Integer(@parser.parameters[index])
+      items = array_bit_size / get_bit_size()
+      if items >= BIG_ARRAY_SIZE
+        warning = "Performance Issue!\n"\
+          "In #{@parser.filename}:#{@parser.line_number} your definition of:\n"\
+          "#{@parser.line}\n"\
+          "creates an array with #{items} elements. Consider creating a BLOCK if this is binary data."
+        Logger.warn(warning)
+        @warnings << warning
+      end
+      array_bit_size
+    rescue => err
+      raise @parser.error(err, @usage)
+    end
+
+    def get_endianness(packet)
+      params = @parser.parameters
+      max_options = @usage.count("<")
+      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 #{endianness}. Must be BIG_ENDIAN or LITTLE_ENDIAN.", @usage)
+        end
+      else
+        endianness = packet.default_endianness
+      end
+      endianness
+    end
+
+    def get_range
+      return nil if @parser.keyword.include?('ARRAY')
+      data_type = get_data_type()
+      return nil if data_type == :STRING or data_type == :BLOCK
+
+      index = append? ? 3 : 4
+      min = ConfigParser.handle_defined_constants(
+        @parser.parameters[index].convert_to_value, get_data_type(), get_bit_size())
+      max = ConfigParser.handle_defined_constants(
+        @parser.parameters[index+1].convert_to_value, get_data_type(), get_bit_size())
+      min..max
+    end
+
+    def get_default
+      return [] if @parser.keyword.include?('ARRAY')
+
+      index = append? ? 3 : 4
+      data_type = get_data_type()
+      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.
+        if (@parser.parameters[index].upcase.start_with?("0X")         and
+            !@parser.line.include?("\"#{@parser.parameters[index]}\"") and
+            !@parser.line.include?("\'#{@parser.parameters[index]}\'"))
+          return @parser.parameters[index].hex_to_byte_string
+        else
+          return @parser.parameters[index]
+        end
+      else
+        return ConfigParser.handle_defined_constants(
+          @parser.parameters[index+2].convert_to_value, get_data_type(), get_bit_size())
+      end
+    end
+
+    def get_id_value
+      return nil unless @parser.keyword.include?('ID_')
+      data_type = get_data_type
+      if @parser.keyword.include?('ITEM')
+        index = append? ? 3 : 4
+      else # PARAMETER
+        index = append? ? 5 : 6
+        # STRING and BLOCK PARAMETERS don't have min and max values
+        index -= 2 if data_type == :STRING || data_type == :BLOCK
+      end
+      if data_type == :DERIVED
+        raise @parser.error("DERIVED data type not allowed for Identifier")
+      end
+      @parser.parameters[index]
+    end
+
+    def get_description
+      max_options = @usage.count("<")
+      @parser.parameters[max_options-2] if @parser.parameters[max_options-2]
+    end
+
+    # There are many different usages of the ITEM and PARAMETER keywords so
+    # parse the keyword and parameters to generate the correct usage information.
+    def get_usage
+      usage = "#{@parser.keyword} <ITEM NAME> "
+      usage << "<BIT OFFSET> " unless @parser.keyword.include?("APPEND")
+      usage << bit_size_usage()
+      usage << type_usage()
+      usage << "<TOTAL ARRAY BIT SIZE> " if @parser.keyword.include?("ARRAY")
+      usage << id_usage()
+      usage << "<DESCRIPTION (Optional)> <ENDIANNESS (Optional)>"
+      usage
+    end
+
+    def bit_size_usage
+      if @parser.keyword.include?("ARRAY")
+        "<ARRAY ITEM BIT SIZE> "
+      else
+        "<BIT SIZE> "
+      end
+    end
+
+    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")
+
+      # 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> "
+      else
+        begin
+          data_type = get_data_type()
+        rescue
+          # 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
+        if data_type == :STRING || data_type == :BLOCK
+          usage << "STRING/BLOCK> "
+        else
+          usage << "INT/UINT/FLOAT> <MIN VALUE> <MAX VALUE> "
+        end
+        # ID Values do not have default values
+        usage << "<DEFAULT_VALUE> " unless keyword.include?("ID")
+      end
+      usage
+    end
+
+    def id_usage
+      return '' unless @parser.keyword.include?("ID")
+      if @parser.keyword.include?("PARAMETER")
+        "<DEFAULT AND ID VALUE> "
+      else
+        "<ID VALUE> "
+      end
+    end
+  end
+end

data/lib/cosmos/packets/parsers/packet_parser.rb

@@ -0,0 +1,124 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/packets/packet'
+
+module Cosmos
+
+  class PacketParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param target_name [String] The name of the target to create the packet
+    #   under. If the target name is 'SYSTEM' the keyword parameter will be
+    #   used instead of this parameter.
+    # @param commands [Hash] Hash of the currently defined commands
+    # @param warnings [Array<String>] Any warning strings generated while
+    #   parsing this command will be appened to this array
+    def self.parse_command(parser, target_name, commands, warnings)
+      parser = PacketParser.new(parser)
+      parser.verify_parameters()
+      parser.create_command(target_name, commands, warnings)
+    end
+
+    # @param parser [ConfigParser] Configuration parser
+    # @param target_name [String] The name of the target to create the packet
+    #   under. If the target name is 'SYSTEM' the keyword parameter will be
+    #   used instead of this parameter.
+    # @param telemetry [Hash] Hash of the currently defined telemetry packets
+    # @param latest_data [Hash<String=>Hash<String=>Array(Packet)>>] Hash of hashes keyed
+    #   first by the target name and then by the item name. This results in an
+    #   array of packets containing that target and item. This structure is
+    #   used to perform lookups when the packet and item are known but the
+    #   packet is not.
+    # @param warnings [Array<String>] Any warning strings generated while
+    #   parsing this command will be appened to this array
+    def self.parse_telemetry(parser, target_name, telemetry, latest_data, warnings)
+      parser = PacketParser.new(parser)
+      parser.verify_parameters()
+      parser.create_telemetry(target_name, telemetry, latest_data, warnings)
+    end
+
+    # @param packet [Packet] Packet to check all default and range items for
+    #   appropriate data types. Only applicable to COMMAND packets.
+    def self.check_item_data_types(packet)
+      packet.sorted_items.each do |item|
+        item.check_default_and_range_data_types()
+      end
+    rescue
+      # Add the target name and packet name to the error message so the user
+      # can debug where the error occurred
+      raise $!, "#{packet.target_name} #{packet.packet_name} #{$!}", $!.backtrace
+    end
+
+    # @param parser [ConfigParser] Configuration parser
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def verify_parameters
+      @usage = "#{@parser.keyword} <TARGET NAME> <PACKET NAME> <ENDIANNESS: BIG_ENDIAN/LITTLE_ENDIAN> <DESCRIPTION (Optional)>"
+      @parser.verify_num_parameters(3, 4, @usage)
+    end
+
+    def create_command(target_name, commands, warnings)
+      packet = create_packet(target_name)
+      PacketParser.finish_create_command(packet, commands, warnings)
+    end
+
+    def create_telemetry(target_name, telemetry, latest_data, warnings)
+      packet = create_packet(target_name)
+      PacketParser.finish_create_telemetry(packet, telemetry, latest_data, warnings)
+    end
+
+    #private
+
+    def create_packet(target_name)
+      params = @parser.parameters
+      target_name = params[0].to_s.upcase if target_name == 'SYSTEM'
+      packet_name = params[1].to_s.upcase
+      endianness = params[2].to_s.upcase.to_sym
+      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
+      Packet.new(target_name, packet_name, endianness, description)
+    end
+
+    def self.check_for_duplicate(type, list, packet)
+      msg = nil
+      if list[packet.target_name]
+        if list[packet.target_name][packet.packet_name]
+          msg = "#{type} Packet #{packet.target_name} #{packet.packet_name} redefined."
+          Logger.instance.warn msg
+        end
+      end
+      msg
+    end
+
+    def self.finish_create_command(packet, commands, warnings)
+      warning = PacketParser.check_for_duplicate('Command', commands, packet)
+      warnings << warning if warning
+      commands[packet.target_name] ||= {}
+      packet
+    end
+
+    def self.finish_create_telemetry(packet, telemetry, latest_data, warnings)
+      warning = PacketParser.check_for_duplicate('Telemetry', telemetry, packet)
+      warnings << warning if warning
+      packet.define_reserved_items()
+
+      unless telemetry[packet.target_name]
+        telemetry[packet.target_name] = {}
+        latest_data[packet.target_name] = {}
+      end
+      packet
+    end
+
+  end
+end