cosmos 3.9.2 → 4.0.0

data/lib/cosmos/interfaces/linc_interface.rb

@@ -12,7 +12,6 @@ require 'cosmos/interfaces/tcpip_client_interface'
 require 'uuidtools'
 
 module Cosmos
-
   # Interface for connecting to Ball Aerospace LINC Labview targets
   class LincInterface < TcpipClientInterface
     # The maximum number of asynchronous commands we can wait for at a time.
@@ -450,12 +449,11 @@ module Cosmos
       # make packet - store on object as a defined packet of type command that this handshakes
       @identified_command = System.commands.packet(interface_target_name, packet_name).clone
       @identified_command.buffer = packet_data
-      @identified_command.received_time = Time.at(handshake.read('TIME_SECONDS'), handshake.read('TIME_MICROSECONDS'))
+      @identified_command.received_time = Time.at(handshake.read('TIME_SECONDS'), handshake.read('TIME_MICROSECONDS')).sys
     end
 
     def get_cmd_guid(fieldname_guid)
       return @identified_command.read(fieldname_guid)
     end
-  end  # class LincHandshake
-
-end # module Cosmos
+  end
+end

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

@@ -0,0 +1,173 @@
+# 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/protocol'
+require 'thread'
+
+module Cosmos
+  # Reads all data available on the interface and creates a packet
+  # with that data.
+  class BurstProtocol < Protocol
+    # @param discard_leading_bytes [Integer] The number of bytes to discard
+    #   from the binary data after reading. Note that this is often
+    #   used to remove a sync pattern from the final packet data.
+    # @param sync_pattern [String] String representing a hex number ("0x1234")
+    #   that will be searched for in the raw data. Bytes encountered before
+    #   this pattern is found are discarded.
+    # @param fill_fields [Boolean] Fill any required fields when writing packets
+    def initialize(discard_leading_bytes = 0, sync_pattern = nil, fill_fields = false, allow_empty_data = false)
+      super(allow_empty_data)
+      @discard_leading_bytes = discard_leading_bytes.to_i
+      @sync_pattern = ConfigParser.handle_nil(sync_pattern)
+      @sync_pattern = @sync_pattern.hex_to_byte_string if @sync_pattern
+      @fill_fields = ConfigParser.handle_true_false(fill_fields)
+    end
+
+    def reset
+      super()
+      @data = ''
+      @data.force_encoding('ASCII-8BIT')
+      @sync_state = :SEARCHING
+    end
+
+    # Reads from the interface. It can look for a sync pattern before
+    # creating a Packet. It can discard a set number of bytes at the beginning
+    # before creating the Packet.
+    #
+    # @return [String|nil] Data for a packet consisting of the bytes read
+    def read_data(data)
+      @data << data
+
+      control = handle_sync_pattern()
+      return control if control
+
+      # Reduce the data to a single packet
+      packet_data = reduce_to_single_packet()
+      return packet_data if Symbol === packet_data
+      @sync_state = :SEARCHING
+
+      # Discard leading bytes if necessary
+      packet_data.replace(packet_data[@discard_leading_bytes..-1]) if @discard_leading_bytes > 0
+      packet_data
+    end
+
+    # Called to perform modifications on a command packet before it is sent
+    #
+    # @param packet [Packet] Original packet
+    # @return [Packet] Potentially modified packet
+    def write_packet(packet)
+      # If we're filling the sync pattern and the sync pattern is part of the
+      # packet (since we're not discarding any leading bytes) then we have to
+      # fill the sync pattern in the actual packet so do it here.
+      if @fill_fields && @sync_pattern && @discard_leading_bytes == 0
+        # Directly write the packet buffer and fill in the sync pattern
+        BinaryAccessor.write(@sync_pattern, 0, @sync_pattern.length * 8, :BLOCK,
+                             packet.buffer(false), :BIG_ENDIAN, :ERROR)
+      end
+      packet
+    end
+
+    # Called to perform modifications on write data before sending it to the interface
+    #
+    # @param data [String] Raw packet data
+    # @return [String] Potentially modified packet data
+    def write_data(data)
+      # If we're filling the sync pattern and discarding the leading bytes
+      # during a read then we need to put them back during a write.
+      # If we're discarding the bytes then by definition they can't be part
+      # of the packet so we just modify the data.
+      if @fill_fields && @discard_leading_bytes > 0
+        data = ("\x00" * @discard_leading_bytes) << data
+        if @sync_pattern
+          BinaryAccessor.write(@sync_pattern, 0, @sync_pattern.length * 8, :BLOCK,
+                               data, :BIG_ENDIAN, :ERROR)
+        end
+      end
+      super(data)
+    end
+
+    # @return [Boolean] control code (nil, :STOP)
+    def handle_sync_pattern
+      if @sync_pattern and @sync_state == :SEARCHING
+        loop do
+          # Make sure we have some data to look for a sync word in
+          return :STOP if @data.length < @sync_pattern.length
+
+          # 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
+            return :STOP if @data.length < (sync_index + @sync_pattern.length)
+
+            # Check for the rest of the sync pattern
+            found = true
+            index = sync_index
+            @sync_pattern.each_byte do |byte|
+              if @data.getbyte(index) != byte
+                found = false
+                break
+              end
+              index += 1
+            end
+
+            if found
+              if sync_index != 0
+                discard_length = @data[0..(sync_index - 1)].length
+                log_discard(discard_length, true)
+                # Delete Data Before Sync Pattern
+                @data.replace(@data[sync_index..-1])
+              end
+              @sync_state = :FOUND
+              return nil
+
+            else # not found
+              log_discard(@data[0..sync_index].length, false)
+              # Delete Data Before and including first character of suspected sync Pattern
+              @data.replace(@data[(sync_index + 1)..-1])
+              next
+            end # if found
+
+          else # sync_index = nil
+            log_discard(@data.length, false)
+            @data.replace('')
+            return :STOP
+          end # unless sync_index.nil?
+        end # end loop
+      end # if @sync_pattern
+      nil
+    end
+
+    def log_discard(length, found)
+      Logger.error("Sync #{'not ' unless found}found. Discarding #{length} bytes of data.")
+      if @data.length >= 0
+        Logger.error(sprintf("Starting: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
+          @data.length >= 1 ? @data.getbyte(0) : 0,
+          @data.length >= 2 ? @data.getbyte(1) : 0,
+          @data.length >= 3 ? @data.getbyte(2) : 0,
+          @data.length >= 4 ? @data.getbyte(3) : 0,
+          @data.length >= 5 ? @data.getbyte(4) : 0,
+          @data.length >= 6 ? @data.getbyte(5) : 0))
+      end
+    end
+
+    def reduce_to_single_packet
+      if @data.length <= 0
+        # Need some data
+        return :STOP
+      end
+
+      # Reduce to packet data and clear data for next packet
+      packet_data = @data.clone
+      @data.replace('')
+      packet_data
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# 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/protocol'
+require 'cosmos/utilities/crc'
+require 'thread'
+
+module Cosmos
+  # Creates a CRC on write and verifies a CRC on read
+  class CrcProtocol < Protocol
+    ERROR = "ERROR" # on CRC mismatch
+    DISCONNECT = "DISCONNECT" # on CRC mismatch
+
+    def initialize(write_item_name, strip_crc, bad_strategy, bit_offset,
+                   bit_size = 32, endianness = 'BIG_ENDIAN',
+                   poly = nil, seed = nil, xor = nil, reflect = nil)
+      @write_item_name = ConfigParser.handle_nil(write_item_name)
+      @strip_crc = ConfigParser.handle_true_false(strip_crc)
+      raise "Invalid strip CRC of '#{strip_crc}'. Must be TRUE or FALSE." unless !!@strip_crc == @strip_crc
+
+      case bad_strategy
+      when ERROR, DISCONNECT
+        @bad_strategy = bad_strategy
+      else
+        raise "Invalid bad CRC strategy of #{bad_strategy}. Must be ERROR or DISCONNECT."
+      end
+
+      case endianness.to_s.upcase
+      when 'BIG_ENDIAN'
+        @endianness = :BIG_ENDIAN # Convert to symbol for use in BinaryAccessor.write
+      when 'LITTLE_ENDIAN'
+        @endianness = :LITTLE_ENDIAN # Convert to symbol for use in BinaryAccessor.write
+      else
+        raise "Invalid endianness '#{endianness}'. Must be BIG_ENDIAN or LITTLE_ENDIAN."
+      end
+
+      @bit_offset = Integer(bit_offset)
+      raise "Invalid bit offset of #{bit_offset}. Must be divisible by 8." if bit_offset % 8 != 0
+      @bit_size = Integer(bit_size)
+      poly = Integer(poly) if poly
+      seed = Integer(seed) if seed
+      xor = ConfigParser.handle_true_false(xor) if xor
+      raise "Invalid XOR value of '#{xor}'. Must be TRUE or FALSE." if xor && !!xor != xor
+      reflect = ConfigParser.handle_true_false(reflect) if reflect
+      raise "Invalid reflect value of '#{reflect}'. Must be TRUE or FALSE." if reflect && !!reflect != reflect
+      # Built the CRC arguments array. All subsequent arguments are dependent
+      # on the previous ones so we build it up incrementally.
+      args = []
+      if poly
+        args << poly
+        if seed
+          args << seed
+          unless xor.nil? # Can't check raw variable because it could be false
+            args << xor
+            unless reflect.nil? # Can't check raw variable because it could be false
+              args << reflect
+            end
+          end
+        end
+      end
+
+      case bit_size
+      when 16
+        @pack = (@endianness == :BIG_ENDIAN) ? 'n' : 'v'
+        if args.empty?
+          @crc = Crc16.new
+        else
+          @crc = Crc16.new(*args)
+        end
+      when 32
+        @pack = (@endianness == :BIG_ENDIAN) ? 'N' : 'V'
+        if args.empty?
+          @crc = Crc32.new
+        else
+          @crc = Crc32.new(*args)
+        end
+      when 64
+        @pack = (@endianness == :BIG_ENDIAN) ? 'N' : 'V'
+        if args.empty?
+          @crc = Crc64.new
+        else
+          @crc = Crc64.new(*args)
+        end
+      else
+        raise "Invalid bit size of #{bit_size}. Must be 16, 32, or 64."
+      end
+    end
+
+    def read_data(data)
+      crc = BinaryAccessor.read(@bit_offset, @bit_size, :UINT, data, @endianness)
+      calculated_crc = @crc.calc(data[0...(@bit_offset / 8)])
+      if calculated_crc != crc
+        Logger.error "Invalid CRC detected! Calculated 0x#{calculated_crc.to_s(16).upcase} vs found 0x#{crc.to_s(16).upcase}."
+        if @bad_strategy == DISCONNECT
+          return :DISCONNECT
+        end
+      end
+      if @strip_crc
+        new_data = data.dup
+        new_data = new_data[0...(@bit_offset / 8)]
+        end_range = (@bit_offset + @bit_size) / 8
+        new_data << data[end_range..-1] if end_range != 0
+        return new_data
+      end
+      return data
+    end
+
+    def write_packet(packet)
+      if @write_item_name
+        end_range = packet.get_item(@write_item_name).bit_offset / 8
+        crc = @crc.calc(packet.buffer(false)[0...end_range])
+        packet.write(@write_item_name, crc)
+      end
+      packet
+    end
+
+    def write_data(data)
+      unless @write_item_name
+        if @bit_size == 64
+          crc = @crc.calc(data)
+          data << ("\x00" * 8)
+          BinaryAccessor.write((crc >> 32), -64, 32, :UINT, data, @endianness, :ERROR)
+          BinaryAccessor.write((crc & 0xFFFFFFFF), -32, 32, :UINT, data, @endianness, :ERROR)
+        else
+          crc = @crc.calc(data)
+          data << ("\x00" * (@bit_size / 8))
+          BinaryAccessor.write(crc, -@bit_size, @bit_size, :UINT, data, @endianness, :ERROR)
+        end
+      end
+      data
+    end
+  end
+end

data/lib/cosmos/{streams/fixed_stream_protocol.rb → interfaces/protocols/fixed_protocol.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,41 +9,44 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos/config/config_parser'
-require 'cosmos/streams/stream_protocol'
+require 'cosmos/interfaces/protocols/burst_protocol'
 
 module Cosmos
 
-  # This StreamProtocol delineates packets by identifying them and then
+  # Delineates packets by identifying them and then
   # reading out their entire fixed length. Packets lengths can vary but
   # they must all be fixed.
-  class FixedStreamProtocol < StreamProtocol
-
+  class FixedProtocol < BurstProtocol
     # @param min_id_size [Integer] The minimum amount of data needed to
     #   identify a packet.
-    # @param discard_leading_bytes (see StreamProtocol#initialize)
-    # @param sync_pattern (see StreamProtocol#initialize)
-    # @param telemetry_stream [Boolean] Whether the stream is returning
+    # @param discard_leading_bytes (see BurstProtocol#initialize)
+    # @param sync_pattern (see BurstProtocol#initialize)
+    # @param telemetry [Boolean] Whether the interface is returning
     #   telemetry (true) or commands (false)
-    # @param fill_sync_pattern (see StreamProtocol#initialize)
-    def initialize(min_id_size,
-                   discard_leading_bytes = 0,
-                   sync_pattern = nil,
-                   telemetry_stream = true,
-                   fill_sync_pattern = false)
-      super(discard_leading_bytes, sync_pattern, fill_sync_pattern)
+    # @param fill_fields (see BurstProtocol#initialize)
+    # @param unknown_raise Whether to raise an exception on an unknown packet
+    def initialize(
+      min_id_size,
+      discard_leading_bytes = 0,
+      sync_pattern = nil,
+      telemetry = true,
+      fill_fields = false,
+      unknown_raise = false
+    )
+      super(discard_leading_bytes, sync_pattern, fill_fields)
       @min_id_size = Integer(min_id_size)
-      @telemetry_stream = telemetry_stream
+      @telemetry = telemetry
+      @unknown_raise = ConfigParser::handle_true_false(unknown_raise)
     end
 
     # Set the received_time, target_name and packet_name which we recorded when
     # we identified this packet. The server will also do this but since we know
     # the information here, we perform this optimization.
-    # See StreamProtocol#post_read_packet
-    def post_read_packet(packet)
+    def read_packet(packet)
       packet.received_time = @received_time
       packet.target_name = @target_name
       packet.packet_name = @packet_name
-      packet
+      return packet
     end
 
     protected
@@ -52,16 +55,16 @@ module Cosmos
     # returned but the packet that matched is recorded so it can be set in the
     # post_read_packet callback.
     #
-    # @return [String|nil] The identified packet data or nil if the stream was
-    #   closed
+    # @return [String|Symbol] The identified packet data or :STOP if more data
+    #   is required to build a packet
     def identify_and_finish_packet
       packet_data = nil
+      identified_packet = nil
 
-      raise "Interface required for FixedStreamProtocol" unless @interface
       @interface.target_names.each do |target_name|
         target_packets = nil
         begin
-          if @telemetry_stream
+          if @telemetry
             target_packets = System.telemetry.packets(target_name)
           else
             target_packets = System.commands.packets(target_name)
@@ -71,18 +74,16 @@ module Cosmos
           next
         end
 
-        identified_packet = nil
         target_packets.each do |packet_name, packet|
           if (packet.identify?(@data))
             identified_packet = packet
             if identified_packet.defined_length > @data.length
-              # Need more data to finish packet
-              read_minimum_size(identified_packet.defined_length)
-              return nil if @data.length <= 0
+              # Check if need more data to finish packet
+              return :STOP if @data.length < identified_packet.defined_length
             end
             # Set some variables so we can update the packet in
             # post_read_packet
-            @received_time = Time.now
+            @received_time = Time.now.sys
             @target_name = identified_packet.target_name
             @packet_name = identified_packet.packet_name
 
@@ -92,20 +93,22 @@ module Cosmos
             break
           end
         end
-
         break if identified_packet
       end
 
-      packet_data
+      unless identified_packet
+        raise "Unknown data received by FixedProtocol" if @unknown_raise
+        # Unknown packet?  Just return all the current data
+        packet_data = @data.clone
+        @data.replace('')
+      end
+
+      return packet_data
     end
 
     def reduce_to_single_packet
-      read_minimum_size(@min_id_size)
-      return nil if @data.length <= 0
-
+      return :STOP if @data.length < @min_id_size
       identify_and_finish_packet()
     end
-
-  end # class FixedStreamProtocol
-
-end # module Cosmos
+  end
+end