cosmos 4.0.3 → 4.1.0

data/lib/cosmos/system/target.rb

@@ -126,7 +126,7 @@ module Cosmos
           begin
             # Require absolute path to file in target lib folder.  Prevents name
             # conflicts at the require step
-            Cosmos.require_file(File.join(@dir, 'lib', parameters[0]))
+            Cosmos.require_file(File.join(@dir, 'lib', parameters[0]), false)
           rescue LoadError
             begin
               # If we couldn't load at the target/lib level check everywhere

data/lib/cosmos/tools/cmd_sequence/cmd_sequence.rb

@@ -34,6 +34,7 @@ module Cosmos
           option_parser, options = create_default_options()
           options.width = 600
           options.height = 425
+          option_parser.separator "Command Sequence Specific Options:"
           option_parser.on("-o", "--output DIRECTORY", "Save files in the specified directory") do |arg|
             options.output_dir = File.expand_path(arg)
           end
@@ -59,6 +60,13 @@ module Cosmos
       end
       @filename = "Untitled"
       @run_thread = nil
+      @exporter = nil
+
+      begin
+        process_config(options.config_file) if options.config_file
+      rescue => error
+        ExceptionDialog.new(self, error, "Error parsing #{options.config_file}")
+      end
 
       initialize_actions()
       initialize_menus()
@@ -104,10 +112,10 @@ module Cosmos
       @file_save_as.statusTip = tr('Save the sequence')
       @file_save_as.connect(SIGNAL('triggered()')) { file_save(true) }
 
-      @export_action = Qt::Action.new(tr('&Export Sequence'), self)
-      @export_action.shortcut = Qt::KeySequence.new(tr('Ctrl+E'))
-      @export_action.statusTip = tr('Export the current sequence to a custom binary format')
-      @export_action.connect(SIGNAL('triggered()')) { export() }
+      @file_export = Qt::Action.new(tr('&Export Sequence'), self)
+      @file_export.shortcut = Qt::KeySequence.new(tr('Ctrl+E'))
+      @file_export.statusTip = tr('Export the current sequence to a custom binary format')
+      @file_export.connect(SIGNAL('triggered()')) { file_export() }
 
       @show_ignored = Qt::Action.new(tr('&Show Ignored Parameters'), self)
       @show_ignored.statusTip = tr('Show ignored parameters which are normally hidden')
@@ -163,6 +171,10 @@ module Cosmos
 
       file_menu.addAction(@file_save)
       file_menu.addAction(@file_save_as)
+      if @exporter
+        file_menu.addSeparator()
+        file_menu.addAction(@file_export)
+      end
       file_menu.addSeparator()
       file_menu.addAction(@exit_action)
 
@@ -252,6 +264,12 @@ module Cosmos
       splitter.setStretchFactor(1,0)
     end
 
+    # Export the sequence list into a custom binary format
+    def file_export
+      return if @sequence_list.empty? || @exporter.nil?
+      @exporter.export(@filename, @sequence_dir, @sequence_list)
+    end
+
     # Clears the sequence list
     def file_new
       return unless prompt_for_save_if_needed()
@@ -648,5 +666,27 @@ module Cosmos
         @output.ensureCursorVisible()
       end
     end
+
+    def process_config(filename)
+      parser = ConfigParser.new
+      parser.parse_file(filename) do |keyword, params|
+        case keyword
+
+        when 'EXPORTER'
+          usage = "#{keyword} <exporter class filename> <exporter specific options...>"
+          parser.verify_num_parameters(1, nil, usage)
+          exporter_class = Cosmos.require_class(params[0])
+          if params.length >= 2
+            @exporter = exporter_class.new(self, *params[1..-1])
+          else
+            @exporter = exporter_class.new(self)
+          end
+
+        # Unknown keyword
+        else
+          raise "Unhandled keyword: #{keyword}" if keyword
+        end
+      end
+    end
   end
 end

data/lib/cosmos/tools/cmd_sequence/sequence_item.rb

@@ -164,6 +164,10 @@ module Cosmos
       time
     end
 
+    def command
+      System.commands.build_cmd(@command.target_name, @command.packet_name, command_params(), false)
+    end
+
     # @return [String] Time and command string
     def save
       "COMMAND \"#{time}\" \"#{command_string}\""

data/lib/cosmos/tools/cmd_sequence/sequence_list.rb

@@ -95,6 +95,13 @@ module Cosmos
       @modified
     end
 
+    def empty?
+      empty = true
+      # The layout always has the header so count must be > 1
+      Qt.execute_in_main_thread { empty = false if layout.count > 1 }
+      empty
+    end
+
     # Yield each SequenceItem to enable the included Enumerable module
     def each
       total_items = 1

data/lib/cosmos/tools/cmd_tlm_server/api.rb

@@ -10,6 +10,7 @@
 
 require 'cosmos/script/extract'
 require 'cosmos/script/api_shared'
+require 'cosmos/tools/tlm_viewer/tlm_viewer_config'
 
 module Cosmos
 
@@ -74,6 +75,9 @@ module Cosmos
         'subscribe_packet_data',
         'unsubscribe_packet_data',
         'get_packet_data',
+        'subscribe_server_messages',
+        'unsubscribe_server_messages',
+        'get_server_message',
         'get_interface_targets',
         'get_interface_names',
         'connect_interface',
@@ -84,12 +88,25 @@ module Cosmos
         'connect_router',
         'disconnect_router',
         'router_state',
+        'get_all_target_info',
         'get_target_info',
+        'get_target_ignored_parameters',
+        'get_target_ignored_items',
         'get_interface_info',
+        'get_all_interface_info',
         'get_router_info',
+        'get_all_router_info',
+        'get_all_cmd_info',
+        'get_all_tlm_info',
         'get_cmd_cnt',
         'get_tlm_cnt',
+        'get_packet_loggers',
         'get_packet_logger_info',
+        'get_all_packet_logger_info',
+        'get_background_tasks',
+        'start_background_task',
+        'stop_background_task',
+        'get_server_status',
         'get_cmd_log_filename',
         'get_tlm_log_filename',
         'start_logging',
@@ -103,7 +120,26 @@ module Cosmos
         'start_raw_logging_router',
         'stop_raw_logging_router',
         'get_server_message_log_filename',
-        'start_new_server_message_log']
+        'start_new_server_message_log',
+        'cmd_tlm_reload',
+        'cmd_tlm_clear_counters',
+        'get_output_logs_filenames',
+        'replay_select_file',
+        'replay_status',
+        'replay_set_playback_delay',
+        'replay_play',
+        'replay_reverse_play',
+        'replay_stop',
+        'replay_step_forward',
+        'replay_step_back',
+        'replay_move_start',
+        'replay_move_end',
+        'replay_move_index',
+        'get_screen_list',
+        'get_screen_definition',
+      ]
+      @tlm_viewer_config_filename = nil
+      @tlm_viewer_config = nil
     end
 
     ############################################################################
@@ -278,12 +314,12 @@ module Cosmos
       System.commands.params(target_name, command_name).each do |parameter|
         if parameter.format_string
           unless parameter.default.kind_of?(Array)
-            list << [parameter.name, sprintf(parameter.format_string, parameter.default), parameter.states, parameter.description, parameter.units_full, parameter.units, parameter.required]
+            list << [parameter.name, sprintf(parameter.format_string, parameter.default), parameter.states, parameter.description, parameter.units_full, parameter.units, parameter.required, parameter.data_type.to_s]
           else
-            list << [parameter.name, "[]", parameter.states, parameter.description, parameter.units_full, parameter.units, parameter.required]
+            list << [parameter.name, "[]", parameter.states, parameter.description, parameter.units_full, parameter.units, parameter.required, parameter.data_type.to_s]
           end
         else
-          list << [parameter.name, parameter.default, parameter.states, parameter.description, parameter.units_full, parameter.units, parameter.required]
+          list << [parameter.name, parameter.default, parameter.states, parameter.description, parameter.units_full, parameter.units, parameter.required, parameter.data_type.to_s]
         end
       end
       return list
@@ -536,7 +572,7 @@ module Cosmos
         # Update the packet with item_hash
         value_type = value_type.to_s.intern
         item_hash.each do |item_name, item_value|
-          packet.write(item_name, item_value, value_type)
+          packet.write(item_name.to_s, item_value, value_type)
         end
       end
 
@@ -581,10 +617,12 @@ module Cosmos
         # Write to routers
         if send_routers
           router = CmdTlmServer.instance.routers.all['PREIDENTIFIED_ROUTER']
-          begin
-            router.write(packet) if router.write_allowed? and router.connected?
-          rescue => err
-            Logger.error "Problem writing to router #{router.name} - #{err.class}:#{err.message}"
+          if router
+            begin
+              router.write(packet) if router.write_allowed? and router.connected?
+            rescue => err
+              Logger.error "Problem writing to router #{router.name} - #{err.class}:#{err.message}"
+            end
           end
         end
 
@@ -592,11 +630,13 @@ module Cosmos
           # Handle packet logging
           packet_log_writer_pair = CmdTlmServer.instance.packet_logging.all['DEFAULT']
 
-          # Optionally create new logs
-          packet_log_writer_pair.tlm_log_writer.start if create_new_logs
+          if packet_log_writer_pair
+            # Optionally create new logs
+            packet_log_writer_pair.tlm_log_writer.start if create_new_logs
 
-          # Optionally write to packet logs - Write errors are handled by the log writer
-          packet_log_writer_pair.tlm_log_writer.write(packet) if send_packet_log_writers
+            # Optionally write to packet logs - Write errors are handled by the log writer
+            packet_log_writer_pair.tlm_log_writer.write(packet) if send_packet_log_writers
+          end
         end
       end
 
@@ -656,17 +696,22 @@ module Cosmos
     private
 
     def _override(method, tgt_pkt_item)
+      target = System.targets[tgt_pkt_item[0]]
+      raise "Target '#{tgt_pkt_item[0]}' does not exist" unless target
       interface = System.targets[tgt_pkt_item[0]].interface
+      raise "Target '#{tgt_pkt_item[0]}' has no interface" unless interface
       found = false
-      interface.read_protocols.each do |protocol|
-        found = true if protocol.kind_of? OverrideProtocol
+      if interface.read_protocols
+        interface.read_protocols.each do |protocol|
+          found = true if protocol.kind_of? OverrideProtocol
+        end
       end
       if found
         # Test to see if this telemetry item exists
         System.telemetry.value(tgt_pkt_item[0], tgt_pkt_item[1], tgt_pkt_item[2], :RAW)
         interface.public_send("_#{method}", *tgt_pkt_item)
       else
-        raise "Interface #{interface.name} does not have override ability. Is 'PROTOCOL OverrideProtocol' under the interface definition?"
+        raise "Interface #{interface.name} does not have override ability. Is 'PROTOCOL READ_WRITE OverrideProtocol' under the interface definition?"
       end
       nil
     end
@@ -947,6 +992,21 @@ module Cosmos
       CmdTlmServer.get_packet_data(id, non_block)
     end
 
+    # @see CmdTlmServer.subscribe_server_messages
+    def subscribe_server_messages(queue_size = CmdTlmServer::DEFAULT_SERVER_MESSAGES_QUEUE_SIZE)
+      CmdTlmServer.subscribe_server_messages(queue_size)
+    end
+
+    # @see CmdTlmServer.unsubscribe_server_messages
+    def unsubscribe_server_messages(id)
+      CmdTlmServer.unsubscribe_server_messages(id)
+    end
+
+    # @see CmdTlmServer.get_server_message
+    def get_server_message(id, non_block = false)
+      CmdTlmServer.get_server_message(id, non_block)
+    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
@@ -1060,6 +1120,38 @@ module Cosmos
       return [target.cmd_cnt, target.tlm_cnt]
     end
 
+    # Get information about all targets
+    #
+    # @return [Array<Array<String, Numeric, Numeric>] Array of Arrays \[name, cmd_cnt, tlm_cnt]
+    def get_all_target_info
+      info = []
+      System.targets.sort.each do |target_name, target|
+        interface_name = target.interface ? target.interface.name : ''
+        info << [target_name, interface_name, target.cmd_cnt, target.tlm_cnt]
+      end
+      info
+    end
+
+    # Get the list of ignored command parameters for a target
+    #
+    # @param target_name [String] Target name
+    # @return [Array<String>] All of the ignored command parameters for a target.
+    def get_target_ignored_parameters(target_name)
+      target = System.targets[target_name.upcase]
+      raise "Unknown target: #{target_name}" unless target
+      return target.ignored_parameters
+    end
+
+    # Get the list of ignored telemetry items for a target
+    #
+    # @param target_name [String] Target name
+    # @return [Array<String>] All of the ignored telemetry items for a target.
+    def get_target_ignored_items(target_name)
+      target = System.targets[target_name.upcase]
+      raise "Unknown target: #{target_name}" unless target
+      return target.ignored_items
+    end
+
     # Get information about an interface
     #
     # @param interface_name [String] Interface name
@@ -1071,6 +1163,20 @@ module Cosmos
       CmdTlmServer.interfaces.get_info(interface_name)
     end
 
+    # Get information about all interfaces
+    #
+    # @return [Array<Array<String, Numeric, Numeric, Numeric, Numeric, Numeric,
+    #   Numeric, Numeric>>] Array of Arrays containing \[name, state, num clients,
+    #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
+    #   Telemetry count] for all interfaces
+    def get_all_interface_info
+      info = []
+      CmdTlmServer.interfaces.names.sort.each do |interface_name|
+        info << [interface_name].concat(CmdTlmServer.interfaces.get_info(interface_name))
+      end
+      info
+    end
+
     # Get information about a router
     #
     # @param router_name [String] Router name
@@ -1082,6 +1188,20 @@ module Cosmos
       CmdTlmServer.routers.get_info(router_name)
     end
 
+    # Get information about all routers
+    #
+    # @return [Array<Array<String, Numeric, Numeric, Numeric, Numeric, Numeric,
+    #   Numeric, Numeric>>] Array of Arrays containing \[name, state, num clients,
+    #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
+    #   Telemetry count] for all routers
+    def get_all_router_info
+      info = []
+      CmdTlmServer.routers.names.sort.each do |router_name|
+        info << [router_name].concat(CmdTlmServer.routers.get_info(router_name))
+      end
+      info
+    end
+
     # Get the transmit count for a command packet
     #
     # @param target_name [String] Target name of the command
@@ -1089,7 +1209,7 @@ module Cosmos
     # @return [Numeric] Transmit count for the command
     def get_cmd_cnt(target_name, command_name)
       packet = System.commands.packet(target_name, command_name)
-      return packet.received_count
+      packet.received_count
     end
 
     # Get the receive count for a telemetry packet
@@ -1099,7 +1219,41 @@ module Cosmos
     # @return [Numeric] Receive count for the telemetry packet
     def get_tlm_cnt(target_name, packet_name)
       packet = System.telemetry.packet(target_name, packet_name)
-      return packet.received_count
+      packet.received_count
+    end
+
+    # Get information on all command packets
+    #
+    # @return [Numeric] Transmit count for the command
+    def get_all_cmd_info
+      info = []
+      System.commands.all.sort.each do |target_name, packets|
+        packets.sort.each do |packet_name, packet|
+          info << [target_name, packet_name, packet.received_count]
+        end
+      end
+      info
+    end
+
+    # Get information on all telemetry packets
+    #
+    # @return [Numeric] Receive count for the telemetry packet
+    def get_all_tlm_info
+      info = []
+      System.telemetry.all.sort.each do |target_name, packets|
+        packets.sort.each do |packet_name, packet|
+          info << [target_name, packet_name, packet.received_count]
+        end
+      end
+      info
+    end
+
+    # Get the list of packet loggers.
+    #
+    # @param packet_logger_name [String] Name of the packet logger
+    # @return [<Array<String>] Array containing the names of all packet loggers
+    def get_packet_loggers
+      return CmdTlmServer.packet_logging.all.keys
     end
 
     # Get information about a packet logger.
@@ -1122,6 +1276,75 @@ module Cosmos
       return [interfaces] + logger_info
     end
 
+    def get_all_packet_logger_info
+      info = []
+      CmdTlmServer.packet_logging.all.keys.sort.each do |packet_logger_name|
+        packet_log_writer_pair = CmdTlmServer.packet_logging.all[packet_logger_name.upcase]
+        interfaces = []
+        CmdTlmServer.interfaces.all.each do |interface_name, interface|
+          if interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
+            interfaces << interface.name
+          end
+        end
+        info << [packet_logger_name, interfaces].concat(CmdTlmServer.packet_logging.get_info(packet_logger_name))
+      end
+      info
+    end
+
+    # Get background task information
+    #
+    # @return [Array<Array<String, String, String>>] Array of Arrays containing
+    #   the background task name, thread status, and task status
+    def get_background_tasks
+      result = []
+      CmdTlmServer.background_tasks.all.each do |task|
+        if task.thread
+          thread_status = task.thread.status
+          thread_status = 'complete' if thread_status == false
+        else
+          thread_status = 'no thread'
+        end
+        result << [task.name, thread_status, task.status]
+      end
+      result
+    end
+
+    # Start a background task
+    def start_background_task(task_name)
+      CmdTlmServer.background_tasks.all.each_with_index do |task, index|
+        if task.name == task_name
+          CmdTlmServer.background_tasks.start(index)
+          break
+        end
+      end
+    end
+
+    # Stop a background task
+    def stop_background_task(task_name)
+      CmdTlmServer.background_tasks.all.each_with_index do |task, index|
+        if task.name == task_name
+          CmdTlmServer.background_tasks.stop(index)
+          break
+        end
+      end
+    end
+
+    # Get JSON DRB information
+    #
+    # @return [String, Integer, Integer, Integer, Float, Integer] Server
+    #   status including Limits Set, API Port, JSON DRB num clients,
+    #   JSON DRB request count, JSON DRB average request time, and the total
+    #   number of Ruby threads in the server/
+    def get_server_status
+      [ System.limits_set.to_s,
+        CmdTlmServer.mode == :CMD_TLM_SERVER ? System.ports['CTS_API'] : System.ports['REPLAY_API'],
+        CmdTlmServer.json_drb.num_clients,
+        CmdTlmServer.json_drb.request_count,
+        CmdTlmServer.json_drb.average_request_time,
+        Thread.list.length
+      ]
+    end
+
     # @param packet_log_writer_name [String] The name of the packet log writer which
     #   is writing the command packet log
     # @return [String] The command packet log filename
@@ -1230,15 +1453,119 @@ module Cosmos
 
     # @return [String] The server message log filename
     def get_server_message_log_filename
-      CmdTlmServer.message_log.filename
+      if CmdTlmServer.message_log
+        CmdTlmServer.message_log.filename
+      else
+        nil
+      end
     end
 
     # Starts a new server message log
     def start_new_server_message_log
-      CmdTlmServer.message_log.start
+      CmdTlmServer.message_log.start if CmdTlmServer.message_log
       nil
     end
 
+    # Reload the default configuration
+    def cmd_tlm_reload
+      Thread.new do
+        CmdTlmServer.instance.reload
+      end
+      nil
+    end
+
+    # Clear server counters
+    def cmd_tlm_clear_counters
+      CmdTlmServer.clear_counters
+    end
+
+    # Get the list of filenames in the outputs logs folder
+    def get_output_logs_filenames(filter = '*tlm.bin')
+      raise "Filter must not contain slashes" if filter.index('/') or filter.index('\\')
+      Dir.glob(File.join(System.paths['LOGS'], '**', filter))
+    end
+
+    # Select and start analyzing a file for replay
+    #
+    # filename [String] filename relative to output logs folder or absolute filename
+    def replay_select_file(filename, packet_log_reader = "DEFAULT")
+      CmdTlmServer.replay_backend.select_file(filename, packet_log_reader)
+    end
+
+    # Get current replay status
+    #
+    # status, delay, filename, file_start, file_current, file_end, file_index, file_max_index
+    def replay_status
+      CmdTlmServer.replay_backend.status
+    end
+
+    # Set the replay delay
+    #
+    # @param delay [Float] delay between packets in seconds 0.0 to 1.0, nil = REALTIME
+    def replay_set_playback_delay(delay)
+      CmdTlmServer.replay_backend.set_playback_delay(delay)
+    end
+
+    # Replay start playing forward
+    def replay_play
+      CmdTlmServer.replay_backend.play
+    end
+
+    # Replay start playing backward
+    def replay_reverse_play
+      CmdTlmServer.replay_backend.reverse_play
+    end
+
+    # Replay stop
+    def replay_stop
+      CmdTlmServer.replay_backend.stop
+    end
+
+    # Replay step forward one packet
+    def replay_step_forward
+      CmdTlmServer.replay_backend.step_forward
+    end
+
+    # Replay step backward one packet
+    def replay_step_back
+      CmdTlmServer.replay_backend.step_back
+    end
+
+    # Replay move to start of file
+    def replay_move_start
+      CmdTlmServer.replay_backend.move_start
+    end
+
+    # Replay move to end of file
+    def replay_move_end
+      CmdTlmServer.replay_backend.move_end
+    end
+
+    # Replay move to index
+    #
+    # @param index [Integer] packet index into file
+    def replay_move_index(index)
+      CmdTlmServer.replay_backend.move_index(index)
+    end
+
+    # Get the organized list of available telemetry screens
+    def get_screen_list(config_filename = nil, force_refresh = false)
+      if force_refresh or !@tlm_viewer_config or @tlm_viewer_config_filename != config_filename
+        @tlm_viewer_config = TlmViewerConfig.new(config_filename, true)
+        @tlm_viewer_config_filename = config_filename
+      end
+      return @tlm_viewer_config.columns
+    end
+
+    # Get a specific screen definition
+    def get_screen_definition(screen_full_name, config_filename = nil, force_refresh = false)
+      get_screen_list(config_filename, force_refresh) if force_refresh or !@tlm_viewer_config
+      screen_info = @tlm_viewer_config.screen_infos[screen_full_name.upcase]
+      raise "Unknown screen: #{screen_full_name.upcase}" unless screen_info
+      screen_definition = File.read(screen_info.filename)
+      return screen_definition
+    end
+
     private
 
     def cmd_implementation(range_check, hazardous_check, raw, method_name, *args)