cosmos 3.3.3 → 3.4.0

data/lib/cosmos/script/telemetry.rb

@@ -0,0 +1,174 @@
+# 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
+
+    # Poll for the converted value of a telemetry item
+    # Usage:
+    #   tlm(target_name, packet_name, item_name)
+    # or
+    #   tlm('target_name packet_name item_name')
+    def tlm(*args)
+      return $cmd_tlm_server.tlm(*args)
+    end
+
+    # Poll for the raw value of a telemetry item
+    # Usage:
+    #   tlm_raw(target_name, packet_name, item_name)
+    # or
+    #   tlm_raw('target_name packet_name item_name')
+    def tlm_raw(*args)
+      return $cmd_tlm_server.tlm_raw(*args)
+    end
+
+    # Poll for the formatted value of a telemetry item
+    # Usage:
+    #   tlm_formatted(target_name, packet_name, item_name)
+    # or
+    #   tlm_formatted('target_name packet_name item_name')
+    def tlm_formatted(*args)
+      return $cmd_tlm_server.tlm_formatted(*args)
+    end
+
+    # Poll for the formatted with units value of a telemetry item
+    # Usage:
+    #   tlm_with_units(target_name, packet_name, item_name)
+    # or
+    #   tlm_with_units('target_name packet_name item_name')
+    def tlm_with_units(*args)
+      return $cmd_tlm_server.tlm_with_units(*args)
+    end
+
+    def tlm_variable(*args)
+      return $cmd_tlm_server.tlm_variable(*args)
+    end
+
+    # Set a telemetry point to a given value. Note this will be over written in
+    # a live system by incoming new telemetry.
+    # Usage:
+    #   set_tlm(target_name, packet_name, item_name, value)
+    # or
+    #   set_tlm("target_name packet_name item_name = value")
+    def set_tlm(*args)
+      return $cmd_tlm_server.set_tlm(*args)
+    end
+
+    # Set the raw value of a telemetry point to a given value. Note this will
+    # be over written in a live system by incoming new telemetry.
+    # Usage:
+    #   set_tlm(target_name, packet_name, item_name, value)
+    # or
+    #   set_tlm("target_name packet_name item_name = value")
+    def set_tlm_raw(*args)
+      return $cmd_tlm_server.set_tlm_raw(*args)
+    end
+
+    # Gets all the values from the given packet returned in a two dimensional
+    # array containing the item_name, value, and limits state.
+    # Usage:
+    #   values = get_tlm_packet(target_name, packet_name, <:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS>)
+    def get_tlm_packet(target_name, packet_name, value_types = :CONVERTED)
+      result = $cmd_tlm_server.get_tlm_packet(target_name, packet_name, value_types)
+      result.each do |entry|
+        entry[2] = entry[2].to_s.intern if entry[2]
+      end
+      result
+    end
+
+    # Gets all the values from the given packet returned in an
+    # array consisting of an Array of item values, an array of item limits state
+    # given as symbols such as :RED, :YELLOW, :STALE, an array of arrays including
+    # the limits setting such as red low, yellow low, yellow high, red high and
+    # optionally green low and high, and the overall limits state of the system.
+    # Usage:
+    #   values = get_tlm_values([[target_name, packet_name, item_name], ...], <:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS>)
+    def get_tlm_values(items, value_types = :CONVERTED)
+      result = $cmd_tlm_server.get_tlm_values(items, value_types)
+      result[1].length.times do |index|
+        result[1][index] = result[1][index].to_s.intern if result[1][index]
+      end
+      result[3] = result[3].to_s.intern
+      result
+    end
+
+    # Gets the packets for a given target name. Returns an array of arrays
+    # consisting of packet names and packet descriptions.
+    def get_tlm_list(target_name)
+      return $cmd_tlm_server.get_tlm_list(target_name)
+    end
+
+    # Gets all the telemetry mnemonics for a given target and packet. Returns an
+    # array of arrays consisting of item names, item states, and item descriptions.
+    def get_tlm_item_list(target_name, packet_name)
+      return $cmd_tlm_server.get_tlm_item_list(target_name, packet_name)
+    end
+
+    # Gets the list of all defined targets.
+    def get_target_list
+      return $cmd_tlm_server.get_target_list
+    end
+
+    def get_tlm_details(items)
+      $cmd_tlm_server.get_tlm_details(items)
+    end
+
+    # Subscribe to one or more telemetry packets. The queue ID is returned for
+    # use in get_packet_data and unsubscribe_packet_data.
+    # Usage:
+    #   id = subscribe_packet_data([[target_name,packet_name], ...], <queue_size>)
+    def subscribe_packet_data(packets, queue_size = CmdTlmServer::DEFAULT_PACKET_DATA_QUEUE_SIZE)
+      result = $cmd_tlm_server.subscribe_packet_data(packets, queue_size)
+      result
+    end
+
+    # Unsubscribe to telemetry packets. Pass the queue ID which was returned by
+    # the subscribe_packet_data method.
+    # Usage:
+    #   unsubscribe_packet_data(id)
+    def unsubscribe_packet_data(id)
+      result = $cmd_tlm_server.unsubscribe_packet_data(id)
+      result
+    end
+
+    # DEPRECATED
+    def get_packet_data(id, non_block = false)
+      results = $cmd_tlm_server.get_packet_data(id, non_block)
+      if Array === results and results[3] and results[4]
+        results[3] = Time.at(results[3], results[4])
+        results.delete_at(4)
+      end
+      results
+    end
+
+    # Get a packet which was previously subscribed to by
+    # subscribe_packet_data. This method can block waiting for new packets or
+    # not based on the second parameter. It returns a single Cosmos::Packet instance
+    # and will return nil when no more packets are buffered (assuming non_block
+    # is false).
+    # Usage:
+    #   get_packet(id, <true or false to block>)
+    def get_packet(id, non_block = false)
+      packet = nil
+      buffer, target_name, packet_name, received_time, received_count = get_packet_data(id, non_block)
+      if buffer
+        packet = System.telemetry.packet(target_name, packet_name).clone
+        packet.buffer = buffer
+        packet.received_time = received_time
+        packet.received_count = received_count
+      end
+      packet
+    end
+
+  end
+end
+

data/lib/cosmos/script/tools.rb

@@ -0,0 +1,138 @@
+# 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
+
+    #######################################
+    # Methods accessing tlm_viewer
+    #######################################
+
+    def display(display_name, x_pos = nil, y_pos = nil)
+      run_tlm_viewer(display_name, "displayed") do |tlm_viewer|
+        tlm_viewer.display(display_name, x_pos, y_pos)
+      end
+    end
+
+    def clear(display_name)
+      run_tlm_viewer(display_name, "cleared") do |tlm_viewer|
+        tlm_viewer.clear(display_name)
+      end
+    end
+
+    def run_tlm_viewer(display_name, action)
+      tlm_viewer = JsonDRbObject.new "localhost", System.ports['TLMVIEWER_API']
+      begin
+        yield tlm_viewer
+        tlm_viewer.disconnect
+      rescue DRb::DRbConnError
+        # No Listening Tlm Viewer - So Start One
+        start_tlm_viewer
+        begin
+          yield tlm_viewer
+          tlm_viewer.disconnect
+        rescue DRb::DRbConnError
+          raise "Unable to Successfully Start Listening Telemetry Viewer: #{display_name} could not be #{action}"
+        rescue Errno::ENOENT
+          raise "Display Screen File: #{display_name}.txt does not exist"
+        end
+      rescue Errno::ENOENT
+        raise "Display Screen File: #{display_name}.txt does not exist"
+      end
+    end
+
+    def start_tlm_viewer
+      system_file = File.basename(System.initial_filename)
+      mac_app = File.join(Cosmos::USERPATH, 'tools', 'mac', 'TlmViewer.app')
+
+      if Kernel.is_mac? && File.exist?(mac_app)
+        Cosmos.run_process("open '#{mac_app}' --args --system #{system_file}")
+      else
+        cmd = 'ruby'
+        cmd << 'w' if Kernel.is_windows? # Windows uses rubyw to avoid creating a DOS shell
+        Cosmos.run_process("#{cmd} '#{File.join(Cosmos::USERPATH, 'tools', 'TlmViewer')}' --system #{system_file}")
+      end
+      sleep(5)
+    end
+
+    #######################################
+    # Methods accessing script runner
+    #######################################
+
+    def _ensure_script_runner_frame
+      yield if defined? ScriptRunnerFrame && ScriptRunnerFrame.instance
+    end
+
+    def set_line_delay(delay)
+      _ensure_script_runner_frame { ScriptRunnerFrame.line_delay = delay if delay >= 0.0 }
+    end
+
+    def get_line_delay
+      _ensure_script_runner_frame { ScriptRunnerFrame.line_delay }
+    end
+
+    def get_scriptrunner_message_log_filename
+      filename = nil
+      _ensure_script_runner_frame do
+        filename = ScriptRunnerFrame.instance.message_log.filename if ScriptRunnerFrame.instance.message_log
+      end
+      return filename
+    end
+
+    def start_new_scriptrunner_message_log
+      # A new log will be created at the next message
+      _ensure_script_runner_frame { ScriptRunnerFrame.instance.stop_message_log }
+    end
+
+    def disable_instrumentation
+      if defined? ScriptRunnerFrame && ScriptRunnerFrame.instance
+        ScriptRunnerFrame.instance.use_instrumentation = false
+        begin
+          yield
+        ensure
+          ScriptRunnerFrame.instance.use_instrumentation = true
+        end
+      else
+        yield
+      end
+    end
+
+    def set_stdout_max_lines(max_lines)
+      _ensure_script_runner_frame { ScriptRunnerFrame.instance.stdout_max_lines = max_lines }
+    end
+
+    #######################################
+    # Methods for debugging
+    #######################################
+
+    def insert_return(*params)
+      _ensure_script_runner_frame do
+        ScriptRunnerFrame.instance.inline_return = true
+        ScriptRunnerFrame.instance.inline_return_params = params
+      end
+    end
+
+    def step_mode
+      _ensure_script_runner_frame { ScriptRunnerFrame.step_mode = true }
+    end
+
+    def run_mode
+      _ensure_script_runner_frame { ScriptRunnerFrame.step_mode = false }
+    end
+
+    def show_backtrace(value = true)
+      _ensure_script_runner_frame { ScriptRunnerFrame.show_backtrace = value }
+    end
+
+  end # module Script
+
+end # module Cosmos

data/lib/cosmos/streams/stream_protocol.rb

@@ -109,7 +109,11 @@ module Cosmos
     # @return [Boolean] Whether the stream attribute has been set and is
     #   connected
     def connected?
-      @stream && @stream.connected?
+      if @stream
+        @stream.connected?
+      else
+        false
+      end
     end
 
     # Disconnects from the underlying {Stream} by calling {Stream#disconnect}.
@@ -133,7 +137,6 @@ module Cosmos
     def read
       # Loop until we have a packet to give
       loop do
-        # Handle a sync pattern if present
         result = handle_sync_pattern()
         return nil unless result
 
@@ -267,20 +270,20 @@ module Cosmos
 
     protected
 
+    # @return [Boolean] Whether we successfully found a sync pattern
     def handle_sync_pattern
-      # Handle a sync pattern
       if @sync_pattern
         loop do
           # Make sure we have some data to look for a sync word in
           read_minimum_size(@sync_pattern.length)
-          return nil if @data.length <= 0
+          return false if @data.length <= 0
 
-          # Find the sync pattern
+          # Find the beginning of the sync pattern
           sync_index = @data.index(@sync_pattern.getbyte(0).chr)
           if sync_index
             # Make sure we have enough data for the whole sync pattern past this index
             read_minimum_size(sync_index + @sync_pattern.length)
-            return nil if @data.length <= 0
+            return false if @data.length <= 0
 
             # Check for the rest of the sync pattern
             found = true

data/lib/cosmos/system/target.rb

@@ -80,7 +80,17 @@ module Cosmos
     # @param target_filename [String] Configuration file for the target. Normally
     #   target.txt
     def initialize(target_name, substitute_name = nil, path = nil, target_filename = nil)
-      path = File.join(USERPATH,'config','targets') unless path
+      @requires = []
+      @ignored_parameters = []
+      @ignored_items = []
+      @cmd_tlm_files = []
+      @auto_screen_substitute = false
+      @interface = nil
+      @routers = []
+      @cmd_cnt = 0
+      @tlm_cnt = 0
+
+      # Determine the target name using substitution if given
       @original_name = target_name.clone.upcase.freeze
       if substitute_name
         @substitute = true
@@ -89,38 +99,14 @@ module Cosmos
         @substitute = false
         @name = @original_name
       end
-      @requires = []
-      @ignored_parameters = []
-      @ignored_items = []
-      @auto_screen_substitute = false
-
-      @dir = File.join(path, @original_name)
-      lib_dir = File.join(@dir, 'lib')
-      Cosmos.add_to_search_path(lib_dir, false) if File.exist?(lib_dir)
-
-      @cmd_tlm_files = []
-      @filename = File.join(@dir, target_filename || 'target.txt')
-      if File.exist?(@filename)
-        process_file(@filename)
-      else
-        raise "Target file #{target_filename} for target #{@name} does not exist" if target_filename
-      end
 
+      @dir = get_target_dir(path, @original_name)
+      # Parse the target.txt file if it exists
+      @filename = process_target_config_file(@dir, @name, target_filename)
+      # If target.txt didn't specify specific cmd/tlm files then add everything
       if @cmd_tlm_files.empty?
-        if Dir.exist?(File.join(@dir, 'cmd_tlm'))
-          Dir.foreach(File.join(@dir, 'cmd_tlm')) do |dir_filename|
-            if dir_filename[0] != '.'
-              @cmd_tlm_files << File.join(@dir, 'cmd_tlm', dir_filename)
-            end
-          end
-        end
-        @cmd_tlm_files.sort!
+        @cmd_tlm_files = add_all_cmd_tlm(@dir)
       end
-
-      @interface = nil
-      @routers = []
-      @cmd_cnt = 0
-      @tlm_cnt = 0
     end
 
     # Parses the target configuration file
@@ -141,15 +127,11 @@ module Cosmos
           end
           @requires << parameters[0]
 
-        when 'IGNORE_PARAMETER'
-          usage = "#{keyword} <PARAMETER NAME>"
+        when 'IGNORE_PARAMETER', 'IGNORE_ITEM'
+          usage = "#{keyword} <#{keyword.split('_')[1]} NAME>"
           parser.verify_num_parameters(1, 1, usage)
-          @ignored_parameters << parameters[0].upcase
-
-        when 'IGNORE_ITEM'
-          usage = "#{keyword} <ITEM NAME>"
-          parser.verify_num_parameters(1, 1, usage)
-          @ignored_items << parameters[0].upcase
+          @ignored_parameters << parameters[0].upcase if keyword.include?("PARAMETER")
+          @ignored_items << parameters[0].upcase if keyword.include?("ITEM")
 
         when 'COMMANDS', 'TELEMETRY'
           usage = "#{keyword} <FILENAME>"
@@ -170,6 +152,41 @@ module Cosmos
       end
     end
 
+    protected
+
+    # Get the target directory and add the target's lib folder to the
+    # search path if it exists
+    def get_target_dir(path, name)
+      path = File.join(USERPATH,'config','targets') unless path
+      dir = File.join(path, name)
+      lib_dir = File.join(dir, 'lib')
+      Cosmos.add_to_search_path(lib_dir, false) if File.exist?(lib_dir)
+      dir
+    end
+
+    # Process the target's configuration file if it exists
+    def process_target_config_file(dir, name, target_filename)
+      filename = File.join(dir, target_filename || 'target.txt')
+      if File.exist?(filename)
+        process_file(filename)
+      else
+        raise "Target file #{target_filename} for target #{name} does not exist" if target_filename
+      end
+      filename
+    end
+
+    # Automatically add all command and telemetry definitions to the list
+    def add_all_cmd_tlm(dir)
+      cmd_tlm_files = []
+      if Dir.exist?(File.join(dir, 'cmd_tlm'))
+        # Only grab *.txt files in the root of the cmd_tlm folder
+        Dir[File.join(dir, 'cmd_tlm', '*.txt')].each do |filename|
+          cmd_tlm_files << filename
+        end
+      end
+      cmd_tlm_files.sort!
+    end
+
   end # class Target
 
 end # module Cosmos