adams-visiona 1.0.0

data/lib/cosmos/script/cmd_tlm_server.rb

@@ -0,0 +1,216 @@
+# 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
+
+  module Script
+    private
+
+    def get_interface_targets(interface_name)
+      return $cmd_tlm_server.get_interface_targets(interface_name)
+    end
+
+    def get_interface_names
+      return $cmd_tlm_server.get_interface_names
+    end
+
+    def connect_interface(interface_name, *params)
+      return $cmd_tlm_server.connect_interface(interface_name, *params)
+    end
+
+    def disconnect_interface(interface_name)
+      return $cmd_tlm_server.disconnect_interface(interface_name)
+    end
+
+    def interface_state(interface_name)
+      return $cmd_tlm_server.interface_state(interface_name)
+    end
+
+    def map_target_to_interface(target_name, interface_name)
+      return $cmd_tlm_server.map_target_to_interface(target_name, interface_name)
+    end
+
+    def get_router_names
+      return $cmd_tlm_server.get_router_names
+    end
+
+    def connect_router(router_name, *params)
+      return $cmd_tlm_server.connect_router(router_name, *params)
+    end
+
+    def disconnect_router(router_name)
+      return $cmd_tlm_server.disconnect_router(router_name)
+    end
+
+    def router_state(router_name)
+      return $cmd_tlm_server.router_state(router_name)
+    end
+
+    def get_target_info(target_name)
+      return $cmd_tlm_server.get_target_info(target_name)
+    end
+
+    def get_all_target_info
+      return $cmd_tlm_server.get_all_target_info
+    end
+
+    def get_target_ignored_parameters(target_name)
+      return $cmd_tlm_server.get_target_ignored_parameters(target_name)
+    end
+
+    def get_target_ignored_items(target_name)
+      return $cmd_tlm_server.get_target_ignored_items(target_name)
+    end
+
+    def get_interface_info(interface_name)
+      return $cmd_tlm_server.get_interface_info(interface_name)
+    end
+
+    def get_all_router_info
+      return $cmd_tlm_server.get_all_router_info
+    end
+
+    def get_all_interface_info
+      return $cmd_tlm_server.get_all_interface_info
+    end
+
+    def get_router_info(router_name)
+      return $cmd_tlm_server.get_router_info(router_name)
+    end
+
+    def get_all_cmd_info
+      return $cmd_tlm_server.get_all_cmd_info
+    end
+
+    def get_all_tlm_info
+      return $cmd_tlm_server.get_all_tlm_info
+    end
+
+    def get_cmd_cnt(target_name, command_name)
+      return $cmd_tlm_server.get_cmd_cnt(target_name, command_name)
+    end
+
+    def get_tlm_cnt(target_name, packet_name)
+      return $cmd_tlm_server.get_tlm_cnt(target_name, packet_name)
+    end
+
+    def get_packet_loggers
+      return $cmd_tlm_server.get_packet_loggers
+    end
+
+    def get_packet_logger_info(packet_logger_name)
+      return $cmd_tlm_server.get_packet_logger_info(packet_logger_name)
+    end
+
+    def get_all_packet_logger_info
+      return $cmd_tlm_server.get_all_packet_logger_info
+    end
+
+    def get_background_tasks
+      return $cmd_tlm_server.get_background_tasks
+    end
+
+    def start_background_task(task_name)
+      return $cmd_tlm_server.start_background_task(task_name)
+    end
+
+    def stop_background_task(task_name)
+      return $cmd_tlm_server.stop_background_task(task_name)
+    end
+
+    def get_server_status
+      return $cmd_tlm_server.get_server_status
+    end
+
+    def get_cmd_log_filename(packet_log_writer_name = 'DEFAULT')
+      return $cmd_tlm_server.get_cmd_log_filename(packet_log_writer_name)
+    end
+
+    def get_tlm_log_filename(packet_log_writer_name = 'DEFAULT')
+      return $cmd_tlm_server.get_tlm_log_filename(packet_log_writer_name)
+    end
+
+    def start_logging(packet_log_writer_name = 'ALL', label = nil)
+      return $cmd_tlm_server.start_logging(packet_log_writer_name, label)
+    end
+
+    def stop_logging(packet_log_writer_name = 'ALL')
+      return $cmd_tlm_server.stop_logging(packet_log_writer_name)
+    end
+
+    def start_cmd_log(packet_log_writer_name = 'ALL', label = nil)
+      return $cmd_tlm_server.start_cmd_log(packet_log_writer_name, label)
+    end
+
+    def start_tlm_log(packet_log_writer_name = 'ALL', label = nil)
+      return $cmd_tlm_server.start_tlm_log(packet_log_writer_name, label)
+    end
+
+    def stop_cmd_log(packet_log_writer_name = 'ALL')
+      return $cmd_tlm_server.stop_cmd_log(packet_log_writer_name)
+    end
+
+    def stop_tlm_log(packet_log_writer_name = 'ALL')
+      return $cmd_tlm_server.stop_tlm_log(packet_log_writer_name)
+    end
+
+    def start_raw_logging_interface(interface_name = 'ALL')
+      return $cmd_tlm_server.start_raw_logging_interface(interface_name)
+    end
+
+    def stop_raw_logging_interface(interface_name = 'ALL')
+      return $cmd_tlm_server.stop_raw_logging_interface(interface_name)
+    end
+
+    def start_raw_logging_router(router_name = 'ALL')
+      return $cmd_tlm_server.start_raw_logging_router(router_name)
+    end
+
+    def stop_raw_logging_router(router_name = 'ALL')
+      return $cmd_tlm_server.stop_raw_logging_router(router_name)
+    end
+
+    def get_server_message_log_filename
+      return $cmd_tlm_server.get_server_message_log_filename
+    end
+
+    def start_new_server_message_log
+      return $cmd_tlm_server.start_new_server_message_log
+    end
+
+    def subscribe_server_messages(queue_size = CmdTlmServer::DEFAULT_SERVER_MESSAGES_QUEUE_SIZE)
+      return $cmd_tlm_server.subscribe_server_messages(queue_size)
+    end
+
+    def unsubscribe_server_messages(id)
+      return $cmd_tlm_server.unsubscribe_server_messages(id)
+    end
+
+    def get_server_message(id, non_block = false)
+      return $cmd_tlm_server.get_server_message(id, non_block)
+    end
+
+    def cmd_tlm_reload
+      return $cmd_tlm_server.cmd_tlm_reload
+    end
+
+    def cmd_tlm_clear_counters
+      return $cmd_tlm_server.cmd_tlm_clear_counters
+    end
+
+    def get_output_logs_filenames(filter = '*tlm.bin')
+      return $cmd_tlm_server.get_output_logs_filenames(filter)
+    end    
+
+    def get_saved_config(configuration_name = nil)
+      return $cmd_tlm_server.get_saved_config(configuration_name)
+    end
+  end
+end

data/lib/cosmos/script/commands.rb

@@ -0,0 +1,177 @@
+# 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
+  module Script
+    private
+
+    # Log any warnings about disabling checks and log the command itself
+    # NOTE: This is a helper method and should not be called directly
+    def _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+      if no_range
+        Logger.warn "Command #{target_name} #{cmd_name} being sent ignoring range checks"
+      end
+      if no_hazardous
+        Logger.warn "Command #{target_name} #{cmd_name} being sent ignoring hazardous warnings"
+      end
+      Logger.info System.commands.build_cmd_output_string(target_name, cmd_name, cmd_params, raw)
+    end
+
+    # Send the command and log the results
+    # NOTE: This is a helper method and should not be called directly
+    def _cmd(cmd, cmd_no_hazardous, *args)
+      raw = cmd.include?('raw')
+      no_range = cmd.include?('no_range') || cmd.include?('no_checks')
+      no_hazardous = cmd.include?('no_hazardous') || cmd.include?('no_checks')
+
+      begin
+        target_name, cmd_name, cmd_params = $cmd_tlm_server.method_missing(cmd, *args)
+        _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+      rescue HazardousError => e
+        ok_to_proceed = prompt_for_hazardous(e.target_name,
+                                             e.cmd_name,
+                                             e.hazardous_description)
+        if ok_to_proceed
+          target_name, cmd_name, cmd_params = $cmd_tlm_server.method_missing(cmd_no_hazardous, *args)
+          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+        else
+          retry unless prompt_for_script_abort()
+        end
+      end
+    end
+
+    # Send a command to the specified target
+    # Usage:
+    #   cmd(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd(*args)
+      _cmd('cmd', 'cmd_no_hazardous_check', *args)
+    end
+
+    # Send a command to the specified target without range checking parameters
+    # Usage:
+    #   cmd_no_range_check(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_no_range_check('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_no_range_check(*args)
+      _cmd('cmd_no_range_check', 'cmd_no_checks', *args)
+    end
+
+    # Send a command to the specified target without hazardous checks
+    # Usage:
+    #   cmd_no_hazardous_check(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_no_hazardous_check('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_no_hazardous_check(*args)
+      _cmd('cmd_no_hazardous_check', nil, *args)
+    end
+
+    # Send a command to the specified target without range checking or hazardous checks
+    # Usage:
+    #   cmd_no_checks(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_no_checks('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_no_checks(*args)
+      _cmd('cmd_no_checks', nil, *args)
+    end
+
+    # Send a command to the specified target without running conversions
+    # Usage:
+    #   cmd_raw(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_raw('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_raw(*args)
+      _cmd('cmd_raw', 'cmd_raw_no_hazardous_check', *args)
+    end
+
+    # Send a command to the specified target without range checking parameters or running conversions
+    # Usage:
+    #   cmd_raw_no_range_check(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_raw_no_range_check('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_raw_no_range_check(*args)
+      _cmd('cmd_raw_no_range_check', 'cmd_raw_no_checks', *args)
+    end
+
+    # Send a command to the specified target without hazardous checks or running conversions
+    # Usage:
+    #   cmd_raw_no_hazardous_check(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_raw_no_hazardous_check('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_raw_no_hazardous_check(*args)
+      _cmd('cmd_raw_no_hazardous_check', nil, *args)
+    end
+
+    # Send a command to the specified target without range checking or hazardous checks or running conversions
+    # Usage:
+    #   cmd_raw_no_checks(target_name, cmd_name, cmd_params = {})
+    # or
+    #   cmd_raw_no_checks('target_name cmd_name with cmd_param1 value1, cmd_param2 value2')
+    def cmd_raw_no_checks(*args)
+      _cmd('cmd_raw_no_checks', nil, *args)
+    end
+
+    # Sends raw data through an interface
+    def send_raw(interface_name, data)
+      return $cmd_tlm_server.send_raw(interface_name, data)
+    end
+
+    # Sends raw data through an interface from a file
+    def send_raw_file(interface_name, filename)
+      data = nil
+      File.open(filename, 'rb') {|file| data = file.read}
+      return $cmd_tlm_server.send_raw(interface_name, data)
+    end
+
+    # Returns all the target commands as an array of arrays listing the command
+    # name and description.
+    def get_cmd_list(target_name)
+      return $cmd_tlm_server.get_cmd_list(target_name)
+    end
+
+    # Returns all the parameters for given command as an array of arrays
+    # containing the parameter name, default value, states, description, units
+    # full name, units abbreviation, and whether it is required.
+    def get_cmd_param_list(target_name, cmd_name)
+      return $cmd_tlm_server.get_cmd_param_list(target_name, cmd_name)
+    end
+
+    # Returns whether a command is hazardous (true or false)
+    def get_cmd_hazardous(target_name, cmd_name, cmd_params = {})
+      return $cmd_tlm_server.get_cmd_hazardous(target_name, cmd_name, cmd_params)
+    end
+
+    # Returns a value from the specified command
+    def get_cmd_value(target_name, command_name, parameter_name, value_type = :CONVERTED)
+      return $cmd_tlm_server.get_cmd_value(target_name, command_name, parameter_name, value_type)
+    end
+
+    # Returns the time the most recent command was sent
+    def get_cmd_time(target_name = nil, command_name = nil)
+      results = $cmd_tlm_server.get_cmd_time(target_name, command_name)
+      if Array === results
+        if results[2] and results[3]
+          results[2] = Time.at(results[2], results[3]).sys
+        end
+        results.delete_at(3)
+      end
+      results
+    end
+
+    # Returns the buffer from the most recent specified command
+    def get_cmd_buffer(target_name, command_name)
+      return $cmd_tlm_server.get_cmd_buffer(target_name, command_name)
+    end
+
+  end # module Script
+
+end # module Cosmos
+

data/lib/cosmos/script/extract.rb

@@ -0,0 +1,141 @@
+# 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
+
+  module Extract
+    SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[(?:[^\\\[\]]|\\.)*\]) | \S+ }x #"
+
+    private
+
+    def add_cmd_parameter(keyword, value, packet, cmd_params)
+      quotes_removed = value.remove_quotes
+      begin
+        type = packet.items[keyword].data_type
+      rescue
+        type = nil
+      end
+      if value == quotes_removed
+        if (type == :STRING or type == :BLOCK) and value.upcase.start_with?("0X")
+          cmd_params[keyword] = value.hex_to_byte_string
+        else
+          cmd_params[keyword] = value.convert_to_value
+        end
+      else
+        cmd_params[keyword] = quotes_removed
+      end
+    end
+
+    def extract_fields_from_cmd_text(text)
+      split_string = text.split(/\s+with\s+/i, 2)
+      raise "ERROR: text must not be empty" if split_string.length == 0
+      raise "ERROR: 'with' must be followed by parameters : #{text}" if (split_string.length == 1 and text =~ /\s*with\s*/i) or (split_string.length == 2 and split_string[1].empty?)
+
+      # Extract target_name and cmd_name
+      first_half = split_string[0].split
+      raise "ERROR: Both Target Name and Command Name must be given : #{text}" if first_half.length < 2
+      raise "ERROR: Only Target Name and Command Name must be given before 'with' : #{text}" if first_half.length > 2
+      target_name = first_half[0]
+      cmd_name = first_half[1]
+      cmd_params = {}
+
+      begin
+        packet = System.commands.packet(target_name, cmd_name).clone
+      rescue
+        packet = nil
+      end
+
+      if split_string.length == 2
+        # Extract Command Parameters
+        second_half = split_string[1].scan(SCANNING_REGULAR_EXPRESSION)
+        keyword = nil
+        value = nil
+        comma = nil
+        second_half.each do |item|
+          unless keyword
+            keyword = item
+            next
+          end
+          unless value
+            if item[-1..-1] == ','
+              value = item[0..-2]
+              comma = true
+            else
+              value = item
+              next
+            end
+          end
+          unless comma
+            raise "Missing comma in command parameters: #{text}" if item != ','
+          end
+          add_cmd_parameter(keyword, value, packet, cmd_params)
+          keyword = nil
+          value = nil
+          comma = nil
+        end
+        if keyword
+          if value
+            add_cmd_parameter(keyword, value, packet, cmd_params)
+          else
+            raise "Missing value for last command parameter: #{text}"
+          end
+        end
+      end
+
+      return [target_name, cmd_name, cmd_params]
+    end
+
+    def extract_fields_from_tlm_text(text)
+      split_string = text.split
+      raise "ERROR: Telemetry Item must be specified as 'TargetName PacketName ItemName' : #{text}" if split_string.length != 3
+      target_name = split_string[0]
+      packet_name = split_string[1]
+      item_name = split_string[2]
+      return [target_name, packet_name, item_name]
+    end
+
+    def extract_fields_from_set_tlm_text(text)
+      error_msg = "ERROR: Set Telemetry Item must be specified as 'TargetName PacketName ItemName = Value' : #{text}"
+      # We have to handle these cases:
+      # set_tlm("TGT PKT ITEM='new item'")
+      # set_tlm("TGT PKT ITEM = 'new item'")
+      # set_tlm("TGT PKT ITEM= 'new item'")
+      # set_tlm("TGT PKT ITEM ='new item'")
+      split_string = text.split('=')
+      raise error_msg if split_string.length < 2 || split_string[1].strip.empty?
+      split_string = split_string[0].strip.split << split_string[1..-1].join('=').strip
+      raise error_msg if split_string.length != 4 # Ensure tgt,pkt,item,value
+      target_name = split_string[0]
+      packet_name = split_string[1]
+      item_name = split_string[2]
+      value = split_string[3].strip.convert_to_value
+      value = value.remove_quotes if String === value
+      return [target_name, packet_name, item_name, value]
+    end
+
+    def extract_fields_from_check_text(text)
+      split_string = text.split
+      raise "ERROR: Check improperly specified: #{text}" if split_string.length < 3
+      target_name = split_string[0]
+      packet_name = split_string[1]
+      item_name = split_string[2]
+      comparison_to_eval = nil
+      return [target_name, packet_name, item_name, comparison_to_eval] if split_string.length == 3
+      raise "ERROR: Check improperly specified: #{text}" if split_string.length < 4
+      split_string = text.split(/ /) # Split on regex spaces to preserve spaces in comparison
+      index = split_string.rindex(item_name)
+      comparison_to_eval = split_string[(index + 1)..(split_string.length - 1)].join(" ")
+      raise "ERROR: Use '==' instead of '=': #{text}" if split_string[3] == '='
+      return [target_name, packet_name, item_name, comparison_to_eval]
+    end
+
+  end # module Extract
+
+end # module Cosmos

data/lib/cosmos/script/limits.rb

@@ -0,0 +1,120 @@
+# 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
+
+  module Script
+    private
+
+    def get_out_of_limits
+      result = $cmd_tlm_server.get_out_of_limits
+      result.each do |entry|
+        entry[3] = entry[3].to_s.intern if entry[3]
+      end
+      result
+    end
+
+    def get_overall_limits_state(ignored_items = nil)
+      return $cmd_tlm_server.get_overall_limits_state(ignored_items).to_s.intern
+    end
+
+    def limits_enabled?(*args)
+      return $cmd_tlm_server.limits_enabled?(*args)
+    end
+
+    def enable_limits(*args)
+      return $cmd_tlm_server.enable_limits(*args)
+    end
+
+    def disable_limits(*args)
+      return $cmd_tlm_server.disable_limits(*args)
+    end
+
+    def get_stale(with_limits_only = false, target_name = nil)
+      return $cmd_tlm_server.get_stale(with_limits_only, target_name)
+    end
+
+    def get_limits(target_name, packet_name, item_name, limits_set = nil)
+      results = $cmd_tlm_server.get_limits(target_name, packet_name, item_name, limits_set)
+      results[0] = results[0].to_s.intern if results[0]
+      return results
+    end
+
+    def set_limits(target_name, packet_name, item_name, red_low, yellow_low, yellow_high, red_high, green_low = nil, green_high = nil, limits_set = :CUSTOM, persistence = nil, enabled = true)
+      results = $cmd_tlm_server.set_limits(target_name, packet_name, item_name, red_low, yellow_low, yellow_high, red_high, green_low, green_high, limits_set, persistence, enabled)
+      results[0] = results[0].to_s.intern if results[0]
+      return results
+    end
+
+    def get_limits_groups
+      return $cmd_tlm_server.get_limits_groups
+    end
+
+    def enable_limits_group(group_name)
+      return $cmd_tlm_server.enable_limits_group(group_name)
+    end
+
+    def disable_limits_group(group_name)
+      return $cmd_tlm_server.disable_limits_group(group_name)
+    end
+
+    def get_limits_sets
+      result = $cmd_tlm_server.get_limits_sets
+      result.each_with_index do |limits_set, index|
+        result[index] = limits_set.to_s.intern
+      end
+      return result
+    end
+
+    def set_limits_set(limits_set)
+      return $cmd_tlm_server.set_limits_set(limits_set)
+    end
+
+    def get_limits_set
+      result = $cmd_tlm_server.get_limits_set
+      # Limits sets are always represented as symbols
+      result.to_s.intern
+    end
+
+    def subscribe_limits_events(queue_size = CmdTlmServer::DEFAULT_LIMITS_EVENT_QUEUE_SIZE)
+      return $cmd_tlm_server.subscribe_limits_events(queue_size)
+    end
+
+    def unsubscribe_limits_events(id)
+      return $cmd_tlm_server.unsubscribe_limits_events(id)
+    end
+
+    def get_limits_event(id, non_block = false)
+      result = $cmd_tlm_server.get_limits_event(id, non_block)
+      if result
+        result[0] = result[0].to_s.intern
+        if result[0] == :LIMITS_CHANGE
+          result[1][3] = result[1][3].to_s.intern if result[1][3]
+          result[1][4] = result[1][4].to_s.intern if result[1][4]
+          if result[1][5] and result[1][6]
+            result[1][5] = Time.at(result[1][5], result[1][6]).sys
+            result[1].delete_at(6)
+          end
+        elsif result[0] == :LIMITS_SETTINGS
+          result[1][3] = result[1][3].to_s.intern if result[1][3]
+        elsif result[0] == :STALE_PACKET
+          # Nothing extra to do
+        elsif result[0] == :STALE_PACKET_RCVD
+          # Nothing extra to do
+        else
+          result[1] = result[1].to_s.intern
+        end
+      end
+      result
+    end
+
+  end
+end
+