cosmos 3.0.1 → 3.1.0

data/lib/cosmos/interfaces/serial_interface.rb

@@ -1,76 +1,76 @@
-# 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/interfaces/stream_interface'
-require 'cosmos/streams/serial_stream'
-
-module Cosmos
-
-  # Provides a base class for interfaces that use serial ports
-  class SerialInterface < StreamInterface
-
-    # Creates a serial interface which uses the specified stream protocol.
-    #
-    # @param write_port_name [String] The name of the serial port to write
-    # @param read_port_name [String] The name of the serial port to read
-    # @param baud_rate [Integer] The serial port baud rate
-    # @param parity [Symbol] The parity which is normally :NONE.
-    #   Must be one of :NONE, :EVEN, or :ODD.
-    # @param stop_bits [Integer] The number of stop bits which is normally 1.
-    # @param write_timeout [Integer] The number of seconds to attempt the write
-    #   before aborting
-    # @param read_timeout [Integer] The number of seconds to attempt to read
-    #   data from the serial port before aborting
-    # @param stream_protocol_type [String] Combined with 'StreamProtocol'
-    #   this should resolve to a COSMOS stream protocol class
-    # @param stream_protocol_args [Array] Arguments to pass to the stream
-    #   protocol class constructor
-    def initialize(write_port_name,
-                   read_port_name,
-                   baud_rate,
-                   parity,
-                   stop_bits,
-                   write_timeout,
-                   read_timeout,
-                   stream_protocol_type,
-                   *stream_protocol_args)
-      super(stream_protocol_type, *stream_protocol_args)
-
-      @write_port_name = ConfigParser.handle_nil(write_port_name)
-      @read_port_name  = ConfigParser.handle_nil(read_port_name)
-      @baud_rate = baud_rate
-      @parity = parity.to_s.intern
-      @stop_bits = stop_bits
-      @write_timeout = write_timeout
-      @read_timeout = read_timeout
-
-      @write_allowed     = false unless @write_port_name
-      @write_raw_allowed = false unless @write_port_name
-      @read_allowed      = false unless @read_port_name
-    end
-
-    # Connects the stream protocol to a new {SerialStream} using the
-    # parameters passed in the constructor.
-    def connect
-      stream = SerialStream.new(
-        @write_port_name,
-        @read_port_name,
-        @baud_rate,
-        @parity,
-        @stop_bits,
-        @write_timeout,
-        @read_timeout)
-      stream.raw_logger_pair = @raw_logger_pair
-      @stream_protocol.connect(stream)
-    end
-
-  end # class SerialInterface
-
-end # module Cosmos
+# 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/interfaces/stream_interface'
+require 'cosmos/streams/serial_stream'
+
+module Cosmos
+
+  # Provides a base class for interfaces that use serial ports
+  class SerialInterface < StreamInterface
+
+    # Creates a serial interface which uses the specified stream protocol.
+    #
+    # @param write_port_name [String] The name of the serial port to write
+    # @param read_port_name [String] The name of the serial port to read
+    # @param baud_rate [Integer] The serial port baud rate
+    # @param parity [Symbol] The parity which is normally :NONE.
+    #   Must be one of :NONE, :EVEN, or :ODD.
+    # @param stop_bits [Integer] The number of stop bits which is normally 1.
+    # @param write_timeout [Integer] The number of seconds to attempt the write
+    #   before aborting
+    # @param read_timeout [Integer] The number of seconds to attempt to read
+    #   data from the serial port before aborting
+    # @param stream_protocol_type [String] Combined with 'StreamProtocol'
+    #   this should resolve to a COSMOS stream protocol class
+    # @param stream_protocol_args [Array] Arguments to pass to the stream
+    #   protocol class constructor
+    def initialize(write_port_name,
+                   read_port_name,
+                   baud_rate,
+                   parity,
+                   stop_bits,
+                   write_timeout,
+                   read_timeout,
+                   stream_protocol_type,
+                   *stream_protocol_args)
+      super(stream_protocol_type, *stream_protocol_args)
+
+      @write_port_name = ConfigParser.handle_nil(write_port_name)
+      @read_port_name  = ConfigParser.handle_nil(read_port_name)
+      @baud_rate = baud_rate
+      @parity = parity.to_s.intern
+      @stop_bits = stop_bits
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+
+      @write_allowed     = false unless @write_port_name
+      @write_raw_allowed = false unless @write_port_name
+      @read_allowed      = false unless @read_port_name
+    end
+
+    # Connects the stream protocol to a new {SerialStream} using the
+    # parameters passed in the constructor.
+    def connect
+      stream = SerialStream.new(
+        @write_port_name,
+        @read_port_name,
+        @baud_rate,
+        @parity,
+        @stop_bits,
+        @write_timeout,
+        @read_timeout)
+      stream.raw_logger_pair = @raw_logger_pair
+      @stream_protocol.connect(stream)
+    end
+
+  end # class SerialInterface
+
+end # module Cosmos

data/lib/cosmos/interfaces/simulated_target_interface.rb

@@ -1,128 +1,129 @@
-# 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/interfaces/interface'
-
-module Cosmos
-
-  # An interface class that provides simulated telemetry and command responses
-  class SimulatedTargetInterface < Interface
-
-    # @param sim_target_file [String] Filename of the simulator target class
-    def initialize(sim_target_file)
-      super()
-
-      @connected = false
-      @initialized = false
-      @count_100hz = 0
-      @next_tick_time = nil
-      @pending_packets = []
-
-      @sim_target_class = Cosmos.require_class sim_target_file
-      @sim_target = nil
-      @write_raw_allowed = false
-      @raw_logger_pair = nil
-    end
-
-    # Initialize the simulated target object and "connect" to the target
-    def connect
-      unless @initialized
-        # Save the current time + 10 ms as the next expected tick time
-        @next_tick_time = Time.now + 0.01
-
-        # Create Simulated Target Object
-        @sim_target = @sim_target_class.new(@target_names[0])
-
-        # Set telemetry rates
-        @sim_target.set_rates
-
-        @initialized = true
-      end
-
-      @connected = true
-    end
-
-    # @return [Boolean] Whether the simulated target is connected (initialized)
-    def connected?
-      @connected
-    end
-
-    # @return [Packet] Returns a simulated target packet from the simulator
-    def read
-      if @connected
-        packet = first_pending_packet()
-        return packet if packet
-
-        while true
-          # Calculate time to sleep to make ticks 10ms apart
-          now = Time.now
-          delta = @next_tick_time - now
-          if delta > 0.0
-            sleep(delta) # Sleep up to 10 ms
-          elsif delta < -1.0
-            # Fell way behind - jump next tick time
-            @next_tick_time = Time.now
-          end
-
-          @pending_packets = @sim_target.read(@count_100hz, @next_tick_time)
-          @next_tick_time += 0.01
-          @count_100hz += 1
-
-          packet = first_pending_packet()
-          return packet if packet
-        end
-      else
-        raise "Interface not connected"
-      end
-    end
-
-    # @param packet [Packet] Command packet to send to the simulator
-    def write(packet)
-      if @connected
-        # Update count of commands sent through this interface
-        @write_count += 1
-        @bytes_written += packet.buffer.length
-
-        # Have simulated target handle the packet
-        @sim_target.write(packet)
-      else
-        raise "Interface not connected"
-      end
-    end
-
-    # write_raw is not implemented and will raise a RuntimeError
-    def write_raw(data)
-      raise "write_raw not implemented for SimulatedTargetInterface"
-    end
-
-    # Raise an error because raw logging is not supported for this interface
-    def raw_logger_pair=(raw_logger_pair)
-      raise "Raw logging not supported for SimulatedTargetInterface"
-    end
-
-    # Disconnect from the simulator
-    def disconnect
-      @connected = false
-    end
-
-    protected
-
-    def first_pending_packet
-      packet = nil
-      unless @pending_packets.empty?
-        @read_count += 1
-        packet = @pending_packets.pop.clone
-        @bytes_read += packet.buffer.length
-      end
-      packet
-    end
-  end
-
-end # module Cosmos
+# 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/interfaces/interface'
+
+module Cosmos
+
+  # An interface class that provides simulated telemetry and command responses
+  class SimulatedTargetInterface < Interface
+
+    # @param sim_target_file [String] Filename of the simulator target class
+    def initialize(sim_target_file)
+      super()
+
+      @connected = false
+      @initialized = false
+      @count_100hz = 0
+      @next_tick_time = nil
+      @pending_packets = []
+
+      @sim_target_class = Cosmos.require_class sim_target_file
+      @sim_target = nil
+      @write_raw_allowed = false
+      @raw_logger_pair = nil
+    end
+
+    # Initialize the simulated target object and "connect" to the target
+    def connect
+      unless @initialized
+        # Save the current time + 10 ms as the next expected tick time
+        @next_tick_time = Time.now + 0.01
+
+        # Create Simulated Target Object
+        @sim_target = @sim_target_class.new(@target_names[0])
+
+        # Set telemetry rates
+        @sim_target.set_rates
+
+        @initialized = true
+      end
+
+      @connected = true
+    end
+
+    # @return [Boolean] Whether the simulated target is connected (initialized)
+    def connected?
+      @connected
+    end
+
+    # @return [Packet] Returns a simulated target packet from the simulator
+    def read
+      if @connected
+        packet = first_pending_packet()
+        return packet if packet
+
+        while true
+          # Calculate time to sleep to make ticks 10ms apart
+          now = Time.now
+          delta = @next_tick_time - now
+          if delta > 0.0
+            sleep(delta) # Sleep up to 10 ms
+            return nil unless @connected
+          elsif delta < -1.0
+            # Fell way behind - jump next tick time
+            @next_tick_time = Time.now
+          end
+
+          @pending_packets = @sim_target.read(@count_100hz, @next_tick_time)
+          @next_tick_time += 0.01
+          @count_100hz += 1
+
+          packet = first_pending_packet()
+          return packet if packet
+        end
+      else
+        raise "Interface not connected"
+      end
+    end
+
+    # @param packet [Packet] Command packet to send to the simulator
+    def write(packet)
+      if @connected
+        # Update count of commands sent through this interface
+        @write_count += 1
+        @bytes_written += packet.buffer.length
+
+        # Have simulated target handle the packet
+        @sim_target.write(packet)
+      else
+        raise "Interface not connected"
+      end
+    end
+
+    # write_raw is not implemented and will raise a RuntimeError
+    def write_raw(data)
+      raise "write_raw not implemented for SimulatedTargetInterface"
+    end
+
+    # Raise an error because raw logging is not supported for this interface
+    def raw_logger_pair=(raw_logger_pair)
+      raise "Raw logging not supported for SimulatedTargetInterface"
+    end
+
+    # Disconnect from the simulator
+    def disconnect
+      @connected = false
+    end
+
+    protected
+
+    def first_pending_packet
+      packet = nil
+      unless @pending_packets.empty?
+        @read_count += 1
+        packet = @pending_packets.pop.clone
+        @bytes_read += packet.buffer.length
+      end
+      packet
+    end
+  end
+
+end # module Cosmos

data/lib/cosmos/interfaces/stream_interface.rb

@@ -1,156 +1,156 @@
-# 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/interfaces/interface'
-# Require all the stream protocols. Additional general purpose stream
-# protocols should be added to the require list.
-require 'cosmos/streams/burst_stream_protocol'
-require 'cosmos/streams/fixed_stream_protocol'
-require 'cosmos/streams/length_stream_protocol'
-require 'cosmos/streams/preidentified_stream_protocol'
-require 'cosmos/streams/template_stream_protocol'
-require 'cosmos/streams/terminated_stream_protocol'
-
-module Cosmos
-
-  # Stream interfaces use stream protocols to interface with the target. This
-  # class simply passes through each method to identically named methods in the
-  # stream protocol class. This class is an abstract class and should not be
-  # used directly. It should be subclassed and the connect method implemented.
-  class StreamInterface < Interface
-
-    # @param stream_protocol_type [String] Combined with 'StreamProtocol'
-    #   this should resolve to a COSMOS stream protocol class
-    # @param stream_protocol_args [Array] Arguments to pass to the stream
-    #   protocol class constructor
-    def initialize(stream_protocol_type, *stream_protocol_args)
-      super()
-
-      stream_protocol_class = stream_protocol_type.to_s.capitalize << 'StreamProtocol'
-      klass = stream_protocol_class.to_class
-      unless klass
-        begin
-          require stream_protocol_class.class_name_to_filename
-        # If the stream protocol doesn't exist require will throw a LoadError
-        rescue LoadError => err
-          msg = "Unable to require " \
-            "#{stream_protocol_class.class_name_to_filename} due to #{err.message}. " \
-            "Ensure #{stream_protocol_class.class_name_to_filename} "\
-            "is in the COSMOS lib directory."
-          Logger.instance.error msg
-          raise msg
-        # If the stream protocol exists but has problems we rescue those here
-        rescue => err
-          msg = "Unable to require " \
-            "#{stream_protocol_class.class_name_to_filename} due to #{err.message}."
-          Logger.instance.error msg
-          raise msg
-        end
-      end
-
-      @stream_protocol = klass.new(*stream_protocol_args)
-      @stream_protocol.interface = self
-    end
-
-    # Connect is left undefined as it must be defined by a subclass.
-
-    # @return [Boolean] Whether the stream protocol is connected to the target
-    def connected?
-      @stream_protocol.connected?
-    end
-
-    # Disconnect the stream protocol from the target
-    def disconnect
-      @stream_protocol.disconnect
-    end
-
-    # Read a packet from the stream protocol
-    def read
-      packet = @stream_protocol.read
-      @read_count += 1 if packet
-      packet
-    end
-
-    # Write a packet to the stream protocol
-    #
-    # @param packet [Packet]
-    def write(packet)
-      if connected?()
-        begin
-          @stream_protocol.write(packet)
-          @write_count += 1
-        rescue Exception => err
-          Logger.instance.error("Error writing to interface : #{@name}")
-          disconnect()
-          raise err
-        end
-      else
-        raise "Interface not connected for write : #{@name}"
-      end
-    end
-
-    # Write a raw binary string to the stream protocol
-    #
-    # @param data [String] Raw binary string
-    def write_raw(data)
-      if connected?()
-        begin
-          @stream_protocol.write_raw(data)
-          @write_count += 1
-        rescue Exception => err
-          Logger.instance.error("Error writing raw data to interface : #{@name}")
-          disconnect()
-          raise err
-        end
-      else
-        raise "Interface not connected for write_raw : #{@name}"
-      end
-    end
-
-    # @return [Integer] The number of bytes read by the stream protocol
-    def bytes_read
-      @stream_protocol.bytes_read
-    end
-
-    # @return [Integer] Sets the number of bytes read by the stream protocol
-    def bytes_read=(bytes_read)
-      @stream_protocol.bytes_read = bytes_read
-    end
-
-    # @return [Integer] The number of bytes written to the stream protocol
-    def bytes_written
-      @stream_protocol.bytes_written
-    end
-
-    # @return [Integer] Sets the number of bytes written to the stream protocol
-    def bytes_written=(bytes_written)
-      @stream_protocol.bytes_written = bytes_written
-    end
-
-    # These methods do not exist in StreamInterface but can be implemented by
-    # subclasses and will be called by the {StreamProtocol} when processing
-    # the data in the {Stream}.
-    #
-    # Subclasses of {StreamProtocol} can implement the same method. However,
-    # if the callback method is implemented in the interface then the
-    # subclass method is not called.
-    #
-    # Thus if you are implementing an Interface that uses a {StreamProtocol}
-    # and choose to implement this method, you must be aware of any
-    # processing that the {StreamProtocol} does in the same method
-    # and re-implement it (or call @stream_protocol.post_read_data(packet_data), etc) in yours.
-    #
-    # @!method post_read_data(packet_data)
-    # @!method post_read_packet(packet)
-    # @!method pre_write_packet(packet)
-
-  end # class StreamInterface
-
-end # module Cosmos
+# 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/interfaces/interface'
+# Require all the stream protocols. Additional general purpose stream
+# protocols should be added to the require list.
+require 'cosmos/streams/burst_stream_protocol'
+require 'cosmos/streams/fixed_stream_protocol'
+require 'cosmos/streams/length_stream_protocol'
+require 'cosmos/streams/preidentified_stream_protocol'
+require 'cosmos/streams/template_stream_protocol'
+require 'cosmos/streams/terminated_stream_protocol'
+
+module Cosmos
+
+  # Stream interfaces use stream protocols to interface with the target. This
+  # class simply passes through each method to identically named methods in the
+  # stream protocol class. This class is an abstract class and should not be
+  # used directly. It should be subclassed and the connect method implemented.
+  class StreamInterface < Interface
+
+    # @param stream_protocol_type [String] Combined with 'StreamProtocol'
+    #   this should resolve to a COSMOS stream protocol class
+    # @param stream_protocol_args [Array] Arguments to pass to the stream
+    #   protocol class constructor
+    def initialize(stream_protocol_type, *stream_protocol_args)
+      super()
+
+      stream_protocol_class = stream_protocol_type.to_s.capitalize << 'StreamProtocol'
+      klass = stream_protocol_class.to_class
+      unless klass
+        begin
+          require stream_protocol_class.class_name_to_filename
+        # If the stream protocol doesn't exist require will throw a LoadError
+        rescue LoadError => err
+          msg = "Unable to require " \
+            "#{stream_protocol_class.class_name_to_filename} due to #{err.message}. " \
+            "Ensure #{stream_protocol_class.class_name_to_filename} "\
+            "is in the COSMOS lib directory."
+          Logger.instance.error msg
+          raise msg
+        # If the stream protocol exists but has problems we rescue those here
+        rescue => err
+          msg = "Unable to require " \
+            "#{stream_protocol_class.class_name_to_filename} due to #{err.message}."
+          Logger.instance.error msg
+          raise msg
+        end
+      end
+
+      @stream_protocol = klass.new(*stream_protocol_args)
+      @stream_protocol.interface = self
+    end
+
+    # Connect is left undefined as it must be defined by a subclass.
+
+    # @return [Boolean] Whether the stream protocol is connected to the target
+    def connected?
+      @stream_protocol.connected?
+    end
+
+    # Disconnect the stream protocol from the target
+    def disconnect
+      @stream_protocol.disconnect
+    end
+
+    # Read a packet from the stream protocol
+    def read
+      packet = @stream_protocol.read
+      @read_count += 1 if packet
+      packet
+    end
+
+    # Write a packet to the stream protocol
+    #
+    # @param packet [Packet]
+    def write(packet)
+      if connected?()
+        begin
+          @stream_protocol.write(packet)
+          @write_count += 1
+        rescue Exception => err
+          Logger.instance.error("Error writing to interface : #{@name}")
+          disconnect()
+          raise err
+        end
+      else
+        raise "Interface not connected for write : #{@name}"
+      end
+    end
+
+    # Write a raw binary string to the stream protocol
+    #
+    # @param data [String] Raw binary string
+    def write_raw(data)
+      if connected?()
+        begin
+          @stream_protocol.write_raw(data)
+          @write_count += 1
+        rescue Exception => err
+          Logger.instance.error("Error writing raw data to interface : #{@name}")
+          disconnect()
+          raise err
+        end
+      else
+        raise "Interface not connected for write_raw : #{@name}"
+      end
+    end
+
+    # @return [Integer] The number of bytes read by the stream protocol
+    def bytes_read
+      @stream_protocol.bytes_read
+    end
+
+    # @return [Integer] Sets the number of bytes read by the stream protocol
+    def bytes_read=(bytes_read)
+      @stream_protocol.bytes_read = bytes_read
+    end
+
+    # @return [Integer] The number of bytes written to the stream protocol
+    def bytes_written
+      @stream_protocol.bytes_written
+    end
+
+    # @return [Integer] Sets the number of bytes written to the stream protocol
+    def bytes_written=(bytes_written)
+      @stream_protocol.bytes_written = bytes_written
+    end
+
+    # These methods do not exist in StreamInterface but can be implemented by
+    # subclasses and will be called by the {StreamProtocol} when processing
+    # the data in the {Stream}.
+    #
+    # Subclasses of {StreamProtocol} can implement the same method. However,
+    # if the callback method is implemented in the interface then the
+    # subclass method is not called.
+    #
+    # Thus if you are implementing an Interface that uses a {StreamProtocol}
+    # and choose to implement this method, you must be aware of any
+    # processing that the {StreamProtocol} does in the same method
+    # and re-implement it (or call @stream_protocol.post_read_data(packet_data), etc) in yours.
+    #
+    # @!method post_read_data(packet_data)
+    # @!method post_read_packet(packet)
+    # @!method pre_write_packet(packet)
+
+  end # class StreamInterface
+
+end # module Cosmos