cosmos 3.6.2 → 3.6.3

data/lib/cosmos/gui/utilities/script_module_gui.rb

@@ -53,12 +53,9 @@ class Qt::MessageBox
 end
 
 class Qt::InputDialog
-  def self.getText(parent, title, label,
-                   mode = Qt::LineEdit::Normal,
-                   text = '', ok = 0, flags = 0,
-                   inputMethodHints = Qt::ImhNone)
+  def self.getText(*args)
     Cosmos.play_wav_file(Cosmos.data_path('input.wav')) if Cosmos::System.sound
-    super(parent, title, label, mode, text, ok, flags, inputMethodHints)
+    super(*args)
   end
 end
 

data/lib/cosmos/interfaces/linc_interface.rb

@@ -15,10 +15,10 @@ module Cosmos
 
   # Interface for connecting to Ball Aerospace LINC Labview targets
   class LincInterface < TcpipClientInterface
-    # The maximum number of handshake responses we can wait for at a time.
+    # The maximum number of asynchronous commands we can wait for at a time.
     # We don't ever expect to get close to this but we need to limit it
     # to ensure the Array doesn't grow out of control.
-    MAX_CONCURRENT_HANDSHAKES = 100
+    MAX_CONCURRENT_HANDSHAKES = 1000
 
     def initialize(
       hostname,
@@ -47,9 +47,8 @@ module Cosmos
 
       # Other instance variables
       @ignored_error_codes = []
-      @handshakes = []
+      @handshake_cmds = []
       @handshakes_mutex = Mutex.new
-      @handshakes_resource = ConditionVariable.new
 
       # Call this once now because the first time is slow
       UUIDTools::UUID.random_create.raw
@@ -83,7 +82,7 @@ module Cosmos
       end
 
       @handshakes_mutex.synchronize do
-        @handshakes = []
+        @handshake_cmds = []
       end
 
       # Actually connect
@@ -91,16 +90,41 @@ module Cosmos
     end
 
     def write(packet)
-      ######################################
-      # Commands handled in the COSMOS interface not the LINC target
-      ######################################
+      return if linc_interface_command(packet)
+      raise "Interface not connected" unless connected?()
 
+      # Add a GUID to the GUID field if its defined
+      # A GUID means it's an asychronous packet type.
+      if @fieldname_guid
+        guid = get_guid(packet)
+      else
+        # If @fieldname_guid is not defined (syncronous) we don't care what the
+        # GUID is because we're not trying to match it up with anything.
+        # As soon as we get a response we free the command.
+        guid = 0
+      end
+
+      # Fix the length field to handle the cases where a variable length packet
+      # is defined. COSMOS does not do this automatically.
+      update_length_field(packet) if @fieldname_cmd_length
+
+      # Always take the mutex (even if we aren't handshaking)
+      # We do not want any incoming telemetry to be missed because
+      # it could be the handshake to this command.
+      @handshakes_mutex.synchronize do
+        super(packet) # Send the command
+        wait_for_response(packet, guid) if @handshake_enabled
+      end
+    end
+
+    def linc_interface_command(packet)
+      result = false
       if @error_ignore_command and @error_ignore_command.identify?(packet.buffer(false))
         linc_cmd = @error_ignore_command.clone
         linc_cmd.buffer = packet.buffer
         code = linc_cmd.read('CODE')
         @ignored_error_codes << code unless @ignored_error_codes.include? code
-        return
+        result = true
       end
 
       if @error_handle_command and @error_handle_command.identify?(packet.buffer(false))
@@ -108,125 +132,100 @@ module Cosmos
         linc_cmd.buffer = packet.buffer
         code = linc_cmd.read('CODE')
         @ignored_error_codes.delete(code) if @ignored_error_codes.include? code
-        return
+        result = true
       end
 
       if @handshake_enable_command and @handshake_enable_command.identify?(packet.buffer(false))
         @handshake_enabled = true
-        return
+        result = true
       end
 
       if @handshake_disable_command and @handshake_disable_command.identify?(packet.buffer(false))
         @handshake_enabled = false
-        return
+        result = true
       end
+      return result
+    end
 
-      # Verify we are connected to the LINC target
-      if connected?()
-        # Add a GUID to the GUID field if its defined
-        if @fieldname_guid
-          if not packet.read(@fieldname_guid) =~ /[\x01-\xFF]/
-            # The GUID has not been set already (it has all \x00 values), so make a new one.
-            # This enables a router GUI to make the GUIDs so it can process handshakes too.
-            my_guid = UUIDTools::UUID.random_create.raw
-            packet.write(@fieldname_guid, my_guid, :RAW)
-          else
-            my_guid = packet.read(@fieldname_guid)
-          end
-        end
+    def get_guid(packet)
+      if not packet.read(@fieldname_guid) =~ /[\x01-\xFF]/
+        # The GUID has not been set already (it has all \x00 values), so make a new one.
+        # This enables a router GUI to make the GUIDs so it can process handshakes too.
+        guid = UUIDTools::UUID.random_create.raw
+        packet.write(@fieldname_guid, guid, :RAW)
+      else
+        guid = packet.read(@fieldname_guid)
+      end
+      return guid
+    end
 
-        # Fix the length field to handle the cases where a variable length packet
-        # is defined. COSMOS does not do this automatically.
-        if @fieldname_cmd_length
-          my_length = packet.length - @length_value_offset
-          packet.write(@fieldname_cmd_length, my_length, :RAW)
-        end
+    def update_length_field(packet)
+      length = packet.length - @length_value_offset
+      packet.write(@fieldname_cmd_length, length, :RAW)
+    end
+
+    def wait_for_response(packet, guid)
+      # Check the number of commands waiting for handshakes.  This is just for sanity
+      # If the number of commands waiting for handshakes is very large then it can't be real
+      # So raise an error.  Something has gone horribly wrong.
+      if @handshake_cmds.length > MAX_CONCURRENT_HANDSHAKES
+        len = @handshake_cmds.length
+        @handshake_cmds = []
+        raise "The number of commands waiting for handshakes to #{len}. Clearing all commands!"
+      end
+
+      # Create a handshake command object and add it to the list of commands waiting
+      handshake_cmd = LincHandshakeCommand.new(@handshakes_mutex, guid)
+      @handshake_cmds.push(handshake_cmd)
+
+      # wait for that handshake. This releases the mutex so that the telemetry and other commands can start running again.
+      timed_out = handshake_cmd.wait_for_handshake(@response_timeout)
+      # We now have the mutex again.  This interface is blocked for the rest of the command handling,
+      # which should be quick because it's just checking variables and logging.
+      # We want to hold the mutex during that so that the commands get logged in order of handshake from here.
+
+      if timed_out
+        # Clean this command out of the array of items that require handshakes.
+        @handshake_cmds.delete_if {|hsc| hsc == handshake_cmd}
+        raise "Timeout waiting for handshake from #{System.commands.format(packet, System.targets[@target_names[0]].ignored_parameters)}"
+      end
 
-        # Always take the mutex (even if we aren't handshaking)
-        @handshakes_mutex.synchronize do
-
-          # Send the command
-          super(packet)
-
-          # Wait for the response if handshaking
-          if @handshake_enabled
-            begin
-              my_handshake = nil
-
-              # The time after which we will give up waiting for a response
-              deadline = Time.now + @response_timeout
-
-              # Loop until we find our response
-              while my_handshake.nil?
-                # How long should we wait in this loop. We could get notified
-                # multiple times for handshakes that aren't ours so we need to
-                # recalculate the wait time each time.
-                to_wait = deadline - Time.now
-
-                # If there is no more time to wait then this is a timeout so we break
-                # out of the loop looking for handshakes
-                if to_wait <= 0
-                  raise "Timeout waiting for handshake from #{System.commands.format(packet, System.targets[@target_names[0]].ignored_parameters)}"
-                end
-
-                # Wait until the telemetry side signals that there is a new handshake to check or timeout.
-                # This releases the mutex until the telemetry side signals us
-                @handshakes_resource.wait(@handshakes_mutex, to_wait)
-                # We now have the mutex again
-
-                # Loop if we have timed out so we can handle the timeout with common code
-                next if (deadline - Time.now) <= 0
-
-                if @fieldname_guid
-                  # A GUID means it's an asychronous packet type.
-                  # So look at the list of incoming handshakes and pick off (deleting)
-                  # the handshake from the list if it's for this command.
-                  #
-                  # The mutex is required because the telemetry task
-                  # could enqueue a response between the index lookup and the slice
-                  # function which would remove the wrong response. FAIL!
-                  my_handshake_index = @handshakes.index {|hs| hs.get_cmd_guid(@fieldname_guid) == my_guid}
-                  my_handshake = @handshakes.slice!(my_handshake_index) if my_handshake_index
-                else
-                  # This is the synchronous version
-                  my_handshake = @handshakes.pop
-                end
-              end # while my_handshake.nil?
-
-              # Handle handshake warnings and errors
-              if my_handshake.handshake.read('STATUS') == "OK" and my_handshake.handshake.read('CODE') != 0
-                unless @ignored_error_codes.include? my_handshake.handshake.read('CODE')
-                  Logger.warn "Warning sending command (#{my_handshake.handshake.read('CODE')}): #{my_handshake.error_source}"
-                end
-              elsif my_handshake.handshake.read('STATUS') == "ERROR"
-                unless @ignored_error_codes.include? my_handshake.handshake.read('CODE')
-                  raise "Error sending command (#{my_handshake.handshake.read('CODE')}): #{my_handshake.error_source}"
-                end
-              end
-            rescue Exception => err
-              # If anything goes wrong after successfully writing the packet to the LINC target
-              # ensure that the packet gets updated in the CVT and logged to the packet log writer.
-              # COSMOS normally only does this if write returns successfully
-              if packet.identified?
-                command = System.commands.packet(packet.target_name, packet.packet_name)
-              else
-                command = System.commands.packet('UNKNOWN', 'UNKNOWN')
-              end
-              command.buffer = packet.buffer
-
-              @packet_log_writer_pairs.each do |packet_log_writer_pair|
-                packet_log_writer_pair.cmd_log_writer.write(packet)
-              end
-
-              raise err
-            end
-          end # if @handshake_enabled
-        end # @handshakes_mutex.synchronize
+      process_handshake_results(handshake_cmd)
+
+    rescue Exception => err
+      # If anything goes wrong after successfully writing the packet to the LINC target
+      # ensure that the packet gets updated in the CVT and logged to the packet log writer.
+      # COSMOS normally only does this if write returns successfully
+      if packet.identified?
+        command = System.commands.packet(packet.target_name, packet.packet_name)
       else
-        raise "Interface not connected"
-      end # if connected
+        command = System.commands.packet('UNKNOWN', 'UNKNOWN')
+      end
+      command.buffer = packet.buffer
+
+      @packet_log_writer_pairs.each do |packet_log_writer_pair|
+        packet_log_writer_pair.cmd_log_writer.write(packet)
+      end
 
-    end # def write
+      raise err
+    end
+
+    def process_handshake_results(handshake_cmd)
+      status = handshake_cmd.handshake.handshake.read('STATUS')
+      code = handshake_cmd.handshake.handshake.read('CODE')
+      source = handshake_cmd.handshake.error_source
+
+      # Handle handshake warnings and errors
+      if status == "OK" and code != 0
+        unless @ignored_error_codes.include? code
+          Logger.warn "Warning sending command (#{code}): #{source}"
+        end
+      elsif status == "ERROR"
+        unless @ignored_error_codes.include? code
+          raise "Error sending command (#{code}): #{source}"
+        end
+      end
+    end
 
     def read
       packet = super()
@@ -234,40 +233,13 @@ module Cosmos
         if @handshake_packet.identify?(packet.buffer(false))
           handshake_packet = @handshake_packet.clone
           handshake_packet.buffer = packet.buffer
-          my_handshake = LincHandshake.new(handshake_packet, @target_names[0])
+          linc_handshake = LincHandshake.new(handshake_packet, @target_names[0])
 
+          # Check for a local handshake
           if handshake_packet.read('origin') == "LCL"
-            # Update the current value table for this command
-            command = System.commands.packet(my_handshake.identified_command.target_name, my_handshake.identified_command.packet_name)
-            command.received_time = my_handshake.identified_command.received_time
-            command.buffer = my_handshake.identified_command.buffer
-            command.received_count += 1
-
-            # Put a log of the command onto the server for the user to see
-            Logger.info("External Command: " + System.commands.format(my_handshake.identified_command, System.targets[@target_names[0]].ignored_parameters))
-
-            # Log the command to the command log(s)
-            @packet_log_writer_pairs.each do |packet_log_writer_pair|
-              packet_log_writer_pair.cmd_log_writer.write(my_handshake.identified_command)
-            end
+            handle_local_handshake(linc_handshake)
           else
-            # This is a remote packet (sent from here).
-            # Add to the array of handshake packet responses (only if handshakes are enabled).
-            # The mutex is required by the command task due to the way it
-            # first looks up the handshake before removing it.
-            if @handshake_enabled
-              @handshakes_mutex.synchronize do
-                @handshakes.push(my_handshake)
-                if @handshakes.length > MAX_CONCURRENT_HANDSHAKES
-                  len = @handshakes.length
-                  @handshakes = []
-                  raise "The handshakes response array has grown to #{len}. Clearing all handshakes!"
-                end
-                # Tell all waiting commands to take a look
-                @handshakes_resource.broadcast
-              end # @handshakes_mutex.synchronize
-            end # if @handshake_enabled
-
+            handle_remote_handshake(linc_handshake) if @handshake_enabled
           end # if handshake_packet.read('origin') == "LCL"
         end # @handshake_packet.identify?(packet.buffer(false))
       end # if packet
@@ -275,9 +247,98 @@ module Cosmos
       return packet
     end
 
+    def handle_local_handshake(linc_handshake)
+      # Update the current value table for this command
+      command = System.commands.packet(linc_handshake.identified_command.target_name, linc_handshake.identified_command.packet_name)
+      command.received_time = linc_handshake.identified_command.received_time
+      command.buffer = linc_handshake.identified_command.buffer
+      command.received_count += 1
+
+      # Put a log of the command onto the server for the user to see
+      Logger.info("External Command: " + System.commands.format(linc_handshake.identified_command, System.targets[@target_names[0]].ignored_parameters))
+
+      # Log the command to the command log(s)
+      @packet_log_writer_pairs.each do |packet_log_writer_pair|
+        packet_log_writer_pair.cmd_log_writer.write(linc_handshake.identified_command)
+      end
+    end
+
+    def handle_remote_handshake(linc_handshake)
+      # This is a remote packet (sent from here).
+      # Add to the array of handshake packet responses
+      # The mutex is required by the command task due to the way it
+      # first looks up the handshake before removing it.
+      @handshakes_mutex.synchronize do
+        if @fieldname_guid
+          # A GUID means it's an asychronous packet type.
+          # So look at the list of incoming handshakes and pick off (deleting)
+          # the handshake from the list if it's for this command.
+          #
+          # The mutex is required because the telemetry task
+          # could enqueue a response between the index lookup and the slice
+          # function which would remove the wrong response. FAIL!
+
+          # Loop through all waiting commands to see if this handshake belongs to them
+          this_handshake_guid = linc_handshake.get_cmd_guid(@fieldname_guid)
+          handshake_cmd_index = @handshake_cmds.index {|hsc| hsc.get_cmd_guid == this_handshake_guid}
+
+          # If command was waiting (ie the loop above found one), then remove it from waiters and signal it
+          if handshake_cmd_index
+            handshake_cmd = @handshake_cmds.slice!(handshake_cmd_index)
+            handshake_cmd.got_your_handshake(linc_handshake)
+          else
+            # No command match found!  Either it gave up and timed out or this wasn't originated from here.
+            # Ignore this typically.  This case here for clarity.
+          end
+
+        else
+          # Synchronous version: just pop the array (pull the command off) and send it the handshake
+          handshake_cmd = @handshakes_cmds.pop
+          handshake_cmd.got_your_handshake(linc_handshake)
+        end # of handshaking type check
+      end # @handshakes_mutex.synchronize
+    end
+
   end # class LincInterface
 
-  # The LincHandshake class is used only by the LincInterface.  It processes the handshake and
+  # The LincHandshakeCommand class is used only by the LincInterface.
+  # It is the command with other required items that is passed to the telemetry
+  # thread so it can match it with the handshake.
+  class LincHandshakeCommand
+    attr_accessor :handshake
+
+    def initialize(handshakes_mutex,cmd_guid)
+      @cmd_guid = cmd_guid
+      @handshakes_mutex = handshakes_mutex
+      @resource = ConditionVariable.new
+      @handshake = nil
+    end
+
+    def wait_for_handshake(response_timeout)
+      timed_out = false
+
+      @resource.wait(@handshakes_mutex,response_timeout)
+      if @handshake
+        timed_out = false
+      else
+        Logger.warn "No handshake - must be timeout."
+        timed_out = true
+      end
+
+      return timed_out
+    end
+
+    def got_your_handshake(handshake)
+      @handshake = handshake
+      @resource.signal
+    end
+
+    def get_cmd_guid
+      return @cmd_guid
+    end
+  end # class LincHandshakeCommand
+
+  # The LincHandshake class is used only by the LincInterface. It processes the handshake and
   # helps with finding the information regarding the internal command.
   class LincHandshake
     attr_accessor :handshake
@@ -354,7 +415,6 @@ module Cosmos
     def get_cmd_guid(fieldname_guid)
       return @identified_command.read(fieldname_guid)
     end
-
   end  # class LincHandshake
 
 end # module Cosmos

data/lib/cosmos/io/win32_serial_driver.rb

@@ -29,7 +29,7 @@ module Cosmos
       # Verify Parameters
       port_name = '\\\\.\\' + port_name if port_name =~ /^COM[0-9]{2,3}$/
 
-      raise(ArgumentError, "Invalid baud rate: #{baud_rate}") unless Win32::BAUD_RATES.include?(baud_rate)
+      raise(ArgumentError, "Invalid baud rate: #{baud_rate}") unless baud_rate.between?(Win32::BAUD_RATES[0], Win32::BAUD_RATES[-1])
 
       raise(ArgumentError, "Invalid parity: #{parity}") if parity and !SerialDriver::VALID_PARITY.include?(parity)
       case parity