cosmos 3.9.2 → 4.0.0

data/lib/cosmos/interfaces/protocols/terminated_protocol.rb

@@ -0,0 +1,81 @@
+# encoding: ascii-8bit
+
+# Copyright 2017 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/config/config_parser'
+require 'cosmos/interfaces/protocols/burst_protocol'
+
+module Cosmos
+  # Protocol which delineates packets using termination characters at
+  # the end of the data.
+  class TerminatedProtocol < BurstProtocol
+    # @param write_termination_characters [String] The characters to write
+    #   after writing the Packet buffer. Must be given as a
+    #   hexadecimal string such as '0xABCD'.
+    # @param read_termination_characters [String] The characters at the end of
+    #   the data which delineate the end of a Packet. Must be given as a
+    #   hexadecimal string such as '0xABCD'.
+    # @param strip_read_termination [Boolean] Whether to remove the
+    #   read_termination_characters before turning the data into a
+    #   Packet.
+    # @param discard_leading_bytes (see BurstProtocol#initialize)
+    # @param sync_pattern (see BurstProtocol#initialize)
+    # @param fill_fields (see BurstProtocol#initialize)
+    def initialize(
+      write_termination_characters,
+      read_termination_characters,
+      strip_read_termination = true,
+      discard_leading_bytes = 0,
+      sync_pattern = nil,
+      fill_fields = false
+    )
+      @write_termination_characters = write_termination_characters.hex_to_byte_string
+      @read_termination_characters = read_termination_characters.hex_to_byte_string
+      @strip_read_termination = ConfigParser.handle_true_false(strip_read_termination)
+
+      super(discard_leading_bytes, sync_pattern, fill_fields)
+    end
+
+    def write_data(data)
+      raise "Packet contains termination characters!" if data.index(@write_termination_characters)
+      data = super(data)
+      @write_termination_characters.each_byte do |byte|
+        data << byte
+      end
+      return data
+    end
+
+    protected
+
+    def reduce_to_single_packet
+      index = @data.index(@read_termination_characters)
+
+      # Reduce to packet data and setup current_data for next packet
+      if index
+        if index > 0
+          if @strip_read_termination
+            packet_data = @data[0..(index - 1)]
+          else
+            packet_data = @data[0..(index + @read_termination_characters.length - 1)]
+          end
+        else # @data begins with the termination characters
+          if @strip_read_termination
+            packet_data = ''
+          else # Keep everything
+            packet_data = @data[0..(@read_termination_characters.length - 1)]
+          end
+        end
+        @data.replace(@data[(index + @read_termination_characters.length)..-1])
+        return packet_data
+      else
+        return :STOP
+      end
+    end
+  end
+end

data/lib/cosmos/interfaces/serial_interface.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -12,10 +12,8 @@ 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
@@ -28,10 +26,9 @@ module Cosmos
     #   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
+    # @param protocol_type [String] Combined with 'Protocol' to resolve
+    #   to a COSMOS protocol class
+    # @param protocol_args [Array] Arguments to pass to the protocol constructor
     def initialize(write_port_name,
                    read_port_name,
                    baud_rate,
@@ -39,38 +36,46 @@ module Cosmos
                    stop_bits,
                    write_timeout,
                    read_timeout,
-                   stream_protocol_type,
-                   *stream_protocol_args)
-      super(stream_protocol_type, *stream_protocol_args)
+                   protocol_type = nil,
+                   *protocol_args)
+      super(protocol_type, protocol_args)
 
       @write_port_name = ConfigParser.handle_nil(write_port_name)
-      @read_port_name  = ConfigParser.handle_nil(read_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_allowed = false unless @write_port_name
       @write_raw_allowed = false unless @write_port_name
-      @read_allowed      = false unless @read_port_name
+      @read_allowed = false unless @read_port_name
+      @flow_control = :NONE
     end
 
-    # Connects the stream protocol to a new {SerialStream} using the
-    # parameters passed in the constructor.
+    # Creates a new {SerialStream} using the parameters passed in the constructor
     def connect
-      stream = SerialStream.new(
+      @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)
+        @read_timeout,
+        @flow_control
+      )
+      super()
     end
 
-  end # class SerialInterface
-
-end # module Cosmos
+    # Supported Options
+    # FLOW_CONTROL - Flow control method NONE or RTSCTS. Defaults to NONE
+    def set_option(option_name, option_values)
+      super(option_name, option_values)
+      case option_name.upcase
+      when 'FLOW_CONTROL'
+        @flow_control = option_values[0]
+      end
+    end
+  end
+end

data/lib/cosmos/interfaces/simulated_target_interface.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -9,43 +9,39 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos/interfaces/interface'
+require 'cosmos/interfaces/protocols/override_protocol'
 
 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
+      add_protocol(OverrideProtocol, [], :READ)
     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
-
+        @next_tick_time = Time.now.sys + 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
 
@@ -56,20 +52,26 @@ module Cosmos
 
     # @return [Packet] Returns a simulated target packet from the simulator
     def read
+      packet = nil
       if @connected
         packet = first_pending_packet()
-        return packet if packet
+        if packet
+          # This is just to support the override functionality
+          # Generic protocol use is not supported
+          packet = @read_protocols[0].read_packet(packet)
+          return packet
+        end
 
         while true
           # Calculate time to sleep to make ticks 10ms apart
-          now = Time.now
+          now = Time.now.sys
           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
+            @next_tick_time = Time.now.sys
           end
 
           @pending_packets = @sim_target.read(@count_100hz, @next_tick_time)
@@ -77,11 +79,17 @@ module Cosmos
           @count_100hz += 1
 
           packet = first_pending_packet()
-          return packet if packet
+          if packet
+            # This is just to support the override functionality
+            # Generic protocol use is not supported
+            packet = @read_protocols[0].read_packet(packet)
+            return packet
+          end
         end
       else
         raise "Interface not connected"
       end
+      return packet
     end
 
     # @param packet [Packet] Command packet to send to the simulator
@@ -89,7 +97,9 @@ module Cosmos
       if @connected
         # Update count of commands sent through this interface
         @write_count += 1
-        @bytes_written += packet.buffer.length
+        @bytes_written += packet.length
+        @written_raw_data_time = Time.now
+        @written_raw_data = packet.buffer
 
         # Have simulated target handle the packet
         @sim_target.write(packet)
@@ -120,10 +130,11 @@ module Cosmos
       unless @pending_packets.empty?
         @read_count += 1
         packet = @pending_packets.pop.clone
-        @bytes_read += packet.buffer.length
+        @bytes_read += packet.length
+        @read_raw_data_time = Time.now
+        @read_raw_data = packet.buffer
       end
       packet
     end
   end
-
-end # module Cosmos
+end

data/lib/cosmos/interfaces/stream_interface.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -9,128 +9,56 @@
 # 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.
+  # Base class for interfaces that act read and write from a stream
   class StreamInterface < Interface
+    attr_accessor :stream
 
-    # @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)
+    def initialize(protocol_type = nil, protocol_args = [])
       super()
-
-      stream_protocol_class = stream_protocol_type.to_s.capitalize << 'StreamProtocol'
-      klass = Cosmos.require_class(stream_protocol_class.class_name_to_filename)
-      @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
+      @protocol_type = ConfigParser::handle_nil(protocol_type)
+      @protocol_args = protocol_args
+      if @protocol_type
+        protocol_class_name = protocol_type.to_s.capitalize << 'Protocol'
+        klass = Cosmos.require_class(protocol_class_name.class_name_to_filename)
+        add_protocol(klass, protocol_args, :READ_WRITE)
+      end
     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
+    def connect
+      super()
+      @stream.connect if @stream
     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
+    def connected?
+      if @stream
+        @stream.connected?
       else
-        raise "Interface not connected for write_raw : #{@name}"
+        false
       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
+    def disconnect
+      @stream.disconnect if @stream
+      super()
     end
 
-    # @return [Integer] The number of bytes written to the stream protocol
-    def bytes_written
-      @stream_protocol.bytes_written
+    def read_interface
+      begin
+        data = @stream.read
+      rescue Timeout::Error
+        Logger.instance.error "Timeout waiting for data to be read"
+        data = nil
+      end
+      return nil if data.nil? or data.length <= 0
+      read_interface_base(data)
+      data
     end
 
-    # @return [Integer] Sets the number of bytes written to the stream protocol
-    def bytes_written=(bytes_written)
-      @stream_protocol.bytes_written = bytes_written
+    def write_interface(data)
+      write_interface_base(data)
+      @stream.write(data)
     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
+  end
+end