cosmos 3.1.2 → 3.2.0

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

@@ -0,0 +1,123 @@
+# 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 => err
+      # 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)
+      warning = check_for_duplicate('Command', commands, packet)
+      warnings << warning if warning
+      commands[packet.target_name] ||= {}
+      packet
+    end
+
+    def create_telemetry(target_name, telemetry, latest_data, warnings)
+      packet = create_packet(target_name)
+      warning = check_for_duplicate('Telemetry', telemetry, packet)
+      warnings << warning if warning
+
+      # Add received time packet items
+      item = packet.define_item('RECEIVED_TIMESECONDS', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, '%0.6f', ReceivedTimeSecondsConversion.new)
+      item.description = 'COSMOS Received Time (UTC, Floating point, Unix epoch)'
+      item = packet.define_item('RECEIVED_TIMEFORMATTED', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, nil, ReceivedTimeFormattedConversion.new)
+      item.description = 'COSMOS Received Time (Local time zone, Formatted string)'
+      item = packet.define_item('RECEIVED_COUNT', 0, 0, :DERIVED, nil, packet.default_endianness, :ERROR, nil, ReceivedCountConversion.new)
+      item.description = 'COSMOS packet received count'
+
+      unless telemetry[packet.target_name]
+        telemetry[packet.target_name] = {}
+        latest_data[packet.target_name] = {}
+      end
+      packet
+    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 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
+
+  end
+end # module Cosmos

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

@@ -0,0 +1,63 @@
+# 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/processors'
+
+module Cosmos
+
+  class ProcessorParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param packet [Packet] The current packet
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def self.parse(parser, packet, cmd_or_tlm)
+      @parser = ProcessorParser.new(parser)
+      @parser.verify_parameters(cmd_or_tlm)
+      @parser.create_processor(packet)
+    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("PROCESSOR only applies to telemetry packets")
+      end
+      @usage = "PROCESSOR <PROCESSOR NAME> <PROCESSOR CLASS FILENAME> <PROCESSOR SPECIFIC OPTIONS>"
+      @parser.verify_num_parameters(2, nil, @usage)
+    end
+
+    # @param packet [Packet] The packet the processor should be added to
+    def create_processor(packet)
+      # require should be performed in target.txt
+      klass = @parser.parameters[1].filename_to_class_name.to_class
+      raise @parser.error("#{@parser.parameters[1].filename_to_class_name} class not found. Did you require the file in target.txt?", @usage) unless klass
+      if @parser.parameters[2]
+        processor = klass.new(*@parser.parameters[2..(@parser.parameters.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 = get_processor_name()
+      packet.processors[processor.name] = processor
+    rescue Exception => err
+      raise @parser.error(err, @usage)
+    end
+
+    private
+
+    def get_processor_name
+      @parser.parameters[0].to_s.upcase
+    end
+
+  end
+end # module Cosmos

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

@@ -0,0 +1,116 @@
+# 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
+
+  class StateParser
+    # @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 states 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)
+      @parser = StateParser.new(parser)
+      @parser.verify_parameters(cmd_or_tlm)
+      @parser.create_state(packet, cmd_or_tlm, item, warnings)
+    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)
+      @usage = "STATE <STATE NAME> <STATE VALUE> "
+      if cmd_or_tlm == PacketConfig::COMMAND
+        @usage << "<HAZARDOUS (Optional)> <Hazardous Description (Optional)>"
+        @parser.verify_num_parameters(2, 4, @usage)
+      else
+        @usage << "<COLOR: GREEN/YELLOW/RED (Optional)>"
+        @parser.verify_num_parameters(2, 3, @usage)
+      end
+    end
+
+    # @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 states on
+    # @param warnings [Array<String>] Array of string warnings which will be
+    #   appended with any warnings found when parsing the limits
+    def create_state(packet, cmd_or_tlm, item, warnings)
+      item.states ||= {}
+
+      state_name = get_state_name()
+      check_for_duplicate_states(item, warnings)
+      item.states[state_name] = get_state_value(item.data_type)
+      parse_additional_parameters(packet, cmd_or_tlm, item)
+    end
+
+    private
+
+    def get_state_name
+      @parser.parameters[0].upcase
+    end
+
+    def get_state_value(data_type)
+      if data_type == :STRING || data_type == :BLOCK
+        @parser.parameters[1]
+      else
+        @parser.parameters[1].convert_to_value
+      end
+    end
+
+    def check_for_duplicate_states(item, warnings)
+      if item.states[get_state_name()]
+        msg = "Duplicate state defined on line #{@parser.line_number}: #{@parser.line}"
+        Logger.instance.warn(msg)
+        warnings << msg
+      end
+    end
+
+    def parse_additional_parameters(packet, cmd_or_tlm, item)
+      return unless @parser.parameters.length > 2
+
+      if cmd_or_tlm == PacketConfig::COMMAND
+        get_hazardous(item)
+      else
+        get_state_colors(item)
+        packet.update_limits_items_cache
+      end
+    end
+
+    def get_hazardous(item)
+      if @parser.parameters[2].upcase == 'HAZARDOUS'
+        item.hazardous ||= {}
+        if @parser.parameters[3]
+          item.hazardous[get_state_name()] = @parser.parameters[3]
+        else
+          item.hazardous[get_state_name()] = ""
+        end
+      else
+        raise @parser.error("HAZARDOUS expected as third parameter for this line.", @usage)
+      end
+    end
+
+    def get_state_colors(item)
+      color = @parser.parameters[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
+      item.limits.enabled = true
+      item.state_colors ||= {}
+      item.state_colors[get_state_name()] = color
+    end
+
+  end
+end # module Cosmos

data/lib/cosmos/packets/structure.rb

@@ -66,6 +66,20 @@ module Cosmos
       @sorted_items.length > 0
     end
 
+    # Rename an existing item
+    #
+    # @param item_name [String] Name of the currently defined item
+    # @param new_item_name [String] New name for the item
+    def rename_item(item_name, new_item_name)
+      item = get_item(item_name)
+      item.name = new_item_name
+      @items.delete(item_name)
+      @items[new_item_name] = item
+      # Since @sorted_items contains the actual item reference it is
+      # updated when we set the item.name
+      item
+    end
+
     # Define an item in the structure. 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.
@@ -89,12 +103,20 @@ module Cosmos
 
       # Create the item
       item = @item_class.new(name_upcase, bit_offset, bit_size, data_type, endianness, array_size, overflow)
+      define(item)
+    end
 
+    # Adds the given item to the items hash. It also resizes the buffer to
+    # accomodate the new item.
+    #
+    # @param item [StructureItem] The structure item to add
+    # @return [StrutureItem] The struture item defined
+    def define(item)
       # Handle Overwriting Existing Item
-      if @items[name_upcase]
+      if @items[item.name]
         item_index = nil
         @sorted_items.each_with_index do |sorted_item, index|
-          if sorted_item.name == name_upcase
+          if sorted_item.name == item.name
             item_index = index
             break
           end
@@ -117,9 +139,9 @@ module Cosmos
       end
 
       # Add to the overall hash of defined items
-      @items[name_upcase] = item
+      @items[item.name] = item
       # Update fixed size knowledge
-      @fixed_size = false if ((data_type != :DERIVED and bit_size <= 0) or (array_size and array_size <= 0))
+      @fixed_size = false if ((item.data_type != :DERIVED and item.bit_size <= 0) or (item.array_size and item.array_size <= 0))
 
       # Recalculate the overall defined length of the structure
       update_needed = false
@@ -178,6 +200,17 @@ module Cosmos
       return define_item(name, @defined_length_bits, bit_size, data_type, array_size, endianness, overflow)
     end
 
+    # Adds an item at the end of the structure. It adds the item to the items
+    # hash and resizes the buffer to accomodate the new item.
+    #
+    # @param item (see #define)
+    # @return (see #define)
+    def append(item)
+      raise ArgumentError, "Can't append an item after a variably sized item" if !@fixed_size
+      item.bit_offset = @defined_length_bits
+      return define(item)
+    end
+
     # @param name [String] Name of the item to look up in the items Hash
     # @return [StructureItem] StructureItem or one of its subclasses
     def get_item(name)
@@ -329,6 +362,28 @@ module Cosmos
       end
     end
 
+    # Make a light weight clone of this structure. This only creates a new buffer
+    # of data. The defined structure items are the same.
+    #
+    # @return [Structure] A copy of the current structure with a new underlying
+    #   buffer of data
+    def clone
+      structure = super()
+      # Use instance_variable_set since we have overriden buffer= to do
+      # additional work that isn't neccessary here
+      structure.instance_variable_set("@buffer", @buffer.clone) if @buffer
+      return structure
+    end
+    alias dup clone
+
+    # Enable the ability to read and write item values as if they were methods
+    # to the class
+    def enable_method_missing
+      extend(MethodMissing)
+    end
+
+    protected
+
     # Take the structure mutex to ensure the buffer does not change while you perform activities
     def synchronize
       @mutex ||= Mutex.new
@@ -365,24 +420,6 @@ module Cosmos
       end
     end
 
-    # Make a light weight clone of this structure. This only creates a new buffer
-    # of data. The defined structure items are the same.
-    #
-    # @return [Structure] A copy of the current structure with a new underlying
-    #   buffer of data
-    def clone
-      structure = super()
-      @buffer = @buffer.clone if @buffer # Deep Copy @buffer
-      return structure
-    end
-    alias dup clone
-
-    def enable_method_missing
-      extend(MethodMissing)
-    end
-
-    protected
-
     module MethodMissing
       # Method missing provides reading/writing item values as if they were methods to the class
       def method_missing(name, value = nil)

data/lib/cosmos/packets/structure_item.rb

@@ -89,7 +89,7 @@ module Cosmos
       raise ArgumentError, "name must be a String but is a #{name.class}" unless String === name
       raise ArgumentError, "name must contain at least one character" if name.empty?
 
-      @name = name.clone.freeze
+      @name = name.upcase.clone.freeze
       verify_overall() if @structure_item_constructed
     end
 

data/lib/cosmos/script/script.rb

@@ -438,7 +438,7 @@ module Cosmos
       script_runner.script_set_status(message) if script_runner
     end
 
-    def ask_string(question, allow_blank = false)
+    def ask_string(question, allow_blank = false, password = false)
       answer = ''
       while answer.empty?
         print question + " "
@@ -449,8 +449,8 @@ module Cosmos
       return answer
     end
 
-    def ask(question, allow_blank = false)
-      string = ask_string(question, allow_blank)
+    def ask(question, allow_blank = false, password = false)
+      string = ask_string(question, allow_blank, password)
       value = string.convert_to_value
       return value
     end
@@ -1504,8 +1504,7 @@ module Cosmos
     end
 
     def shutdown_cmd_tlm
-      script_disconnect()
-      $cmd_tlm_server = nil
+      $cmd_tlm_server.shutdown if $cmd_tlm_server && !$cmd_tlm_disconnect
     end
 
   end # module Script