cosmos 4.2.4-java → 4.5.0-java

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

@@ -156,7 +156,7 @@ module Cosmos
     end
 
     def log_discard(length, found)
-      Logger.error("Sync #{'not ' unless found}found. Discarding #{length} bytes of data.")
+      Logger.error("#{@interface ? @interface.name : ""}: 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/lib/cosmos/interfaces/protocols/crc_protocol.rb

@@ -140,7 +140,7 @@ module Cosmos
       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}."
+        Logger.error "#{@interface ? @interface.name : ""}: 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

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

@@ -68,37 +68,59 @@ module Cosmos
 
       @interface.target_names.each do |target_name|
         target_packets = nil
+        unique_id_mode = false
         begin
           if @telemetry
             target_packets = System.telemetry.packets(target_name)
+            target = System.targets[target_name]
+            unique_id_mode = target.tlm_unique_id_mode if target
           else
             target_packets = System.commands.packets(target_name)
+            target = System.targets[target_name]
+            unique_id_mode = target.cmd_unique_id_mode if target
           end
         rescue RuntimeError
-          # No telemetry for this target
+          # No commands/telemetry for this target
           next
         end
 
-        target_packets.each do |packet_name, packet|
-          if packet.identify?(@data)
-            identified_packet = packet
-            if identified_packet.defined_length > @data.length
-              # Check if need more data to finish packet
-              return :STOP if @data.length < identified_packet.defined_length
+        if unique_id_mode
+          target_packets.each do |packet_name, packet|
+            if packet.identify?(@data[@discard_leading_bytes .. -1])
+              identified_packet = packet
+              break
             end
-            # Set some variables so we can update the packet in
-            # read_packet
-            @received_time = Time.now.sys
-            @target_name = identified_packet.target_name
-            @packet_name = identified_packet.packet_name
-
-            # Get the data from this packet
-            packet_data = @data[0..(identified_packet.defined_length - 1)]
-            @data.replace(@data[identified_packet.defined_length..-1])
-            break
           end
+        else
+          # Do a hash lookup to quickly identify the packet
+          if target_packets.length > 0
+            packet = target_packets.first[1]
+            key = packet.read_id_values(@data[@discard_leading_bytes .. -1])
+            if @telemetry
+              hash = System.telemetry.config.tlm_id_value_hash[target_name]
+            else
+              hash = System.commands.config.cmd_id_value_hash[target_name]
+            end
+            identified_packet = hash[key]
+            identified_packet = hash['CATCHALL'.freeze] unless identified_packet
+          end          
+        end
+        
+        if identified_packet
+          if identified_packet.defined_length + @discard_leading_bytes > @data.length
+            # Check if need more data to finish packet
+            return :STOP
+          end
+          # Set some variables so we can update the packet in
+          # read_packet
+          @received_time = Time.now.sys
+          @target_name = identified_packet.target_name
+          @packet_name = identified_packet.packet_name
+
+          # Get the data from this packet
+          packet_data = @data.slice!(0, identified_packet.defined_length + @discard_leading_bytes)
+          break
         end
-        break if identified_packet
       end
 
       unless identified_packet

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

@@ -0,0 +1,46 @@
+# encoding: ascii-8bit
+
+# Copyright 2018 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
+  # Ignore a specific packet by not letting it through the protocol
+  class IgnorePacketProtocol < Protocol
+    # @param target_name [String] Target name
+    # @param packet_name [String] Packet name
+    def initialize(target_name, packet_name, allow_empty_data = nil)
+      super(allow_empty_data)
+      System.telemetry.packet(target_name, packet_name)
+      @target_name = target_name
+      @packet_name = packet_name
+    end
+
+    def read_packet(packet)
+      # Need to make sure packet is identified and defined
+      target_names = nil
+      target_names = @interface.target_names if @interface
+      identified_packet = System.telemetry.identify_and_define_packet(packet, target_names)
+      if identified_packet
+        if identified_packet.target_name == @target_name && identified_packet.packet_name == @packet_name
+          return :STOP
+        end
+      end
+      return super(packet)
+    end
+
+    def write_packet(packet)
+      return :STOP if packet.target_name == @target_name && packet.packet_name == @packet_name
+      return super(packet)
+    end
+  end
+end

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

@@ -135,6 +135,11 @@ module Cosmos
                                    @length_endianness)
       raise "Length value received larger than max_length: #{length} > #{@max_length}" if @max_length and length > @max_length
       packet_length = (length * @length_bytes_per_count) + @length_value_offset
+      # Ensure the calculated packet length is long enough to support the location of the length field
+      # without overlap into the next packet
+      if (packet_length * 8) < (@length_bit_offset + @length_bit_size)
+        raise "Calculated packet length of #{packet_length * 8} bits < (offset:#{@length_bit_offset} + size:#{@length_bit_size})"
+      end
 
       # Make sure we have enough data for the packet
       return :STOP if @data.length < packet_length

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

@@ -9,6 +9,7 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos/interfaces/protocols/burst_protocol'
+require 'cosmos/packet_logs/packet_log_reader'
 
 module Cosmos
   # Delineates packets using the COSMOS preidentification system
@@ -17,10 +18,11 @@ module Cosmos
     # @param sync_pattern (see BurstProtocol#initialize)
     # @param max_length [Integer] The maximum allowed value of the length field
     # @param allow_empty_data [true/false/nil] See Protocol#initialize
-    def initialize(sync_pattern = nil, max_length = nil, allow_empty_data = nil)
+    def initialize(sync_pattern = nil, max_length = nil, mode = 4, allow_empty_data = nil)
       super(0, sync_pattern, false, allow_empty_data)
       @max_length = ConfigParser.handle_nil(max_length)
       @max_length = Integer(@max_length) if @max_length
+      @mode = Integer(mode)
     end
 
     def reset
@@ -29,21 +31,34 @@ module Cosmos
     end
 
     def read_packet(packet)
-      packet.received_time = @received_time
-      packet.target_name = @target_name
-      packet.packet_name = @packet_name
+      packet.received_time = @read_received_time
+      packet.target_name = @read_target_name
+      packet.packet_name = @read_packet_name
+      if @mode == 4 # COSMOS4.3+ Protocol
+        packet.stored = @read_stored
+        packet.extra = @read_extra
+      end
       return packet
     end
 
     def write_packet(packet)
       received_time = packet.received_time
       received_time = Time.now unless received_time
-      @time_seconds = [received_time.tv_sec].pack('N') # UINT32
-      @time_microseconds = [received_time.tv_usec].pack('N') # UINT32
-      @target_name = packet.target_name
-      @target_name = 'UNKNOWN' unless @target_name
-      @packet_name = packet.packet_name
-      @packet_name = 'UNKNOWN' unless @packet_name
+      @write_time_seconds = [received_time.tv_sec].pack('N') # UINT32
+      @write_time_microseconds = [received_time.tv_usec].pack('N') # UINT32
+      @write_target_name = packet.target_name
+      @write_target_name = 'UNKNOWN' unless @write_target_name
+      @write_packet_name = packet.packet_name
+      @write_packet_name = 'UNKNOWN' unless @write_packet_name
+      if @mode == 4 # COSMOS4.3+ Protocol
+        @write_flags = 0
+        @write_flags |= PacketLogReader::COSMOS4_STORED_FLAG_MASK if packet.stored
+        @write_extra = nil
+        if packet.extra
+          @write_flags |= PacketLogReader::COSMOS4_EXTRA_FLAG_MASK
+          @write_extra = packet.extra.to_json
+        end
+      end
       return packet
     end
 
@@ -51,12 +66,19 @@ module Cosmos
       data_length = [data.length].pack('N') # UINT32
       data_to_send = ''
       data_to_send << @sync_pattern if @sync_pattern
-      data_to_send << @time_seconds
-      data_to_send << @time_microseconds
-      data_to_send << @target_name.length
-      data_to_send << @target_name
-      data_to_send << @packet_name.length
-      data_to_send << @packet_name
+      if @mode == 4 # COSMOS4.3+ Protocol
+        data_to_send << @write_flags
+        if @write_extra
+          data_to_send << [@write_extra.length].pack('N')
+          data_to_send << @write_extra
+        end
+      end
+      data_to_send << @write_time_seconds
+      data_to_send << @write_time_microseconds
+      data_to_send << @write_target_name.length
+      data_to_send << @write_target_name
+      data_to_send << @write_packet_name.length
+      data_to_send << @write_packet_name
       data_to_send << data_length
       data_to_send << data
       return data_to_send
@@ -104,27 +126,50 @@ module Cosmos
         @reduction_state = :SYNC_REMOVED
       end
 
-      # Read and remove packet received time
-      if @reduction_state == :SYNC_REMOVED
+      if @reduction_state == :SYNC_REMOVED and @mode == 4
+        # Read and remove flags
+        return :STOP if @data.length < 1
+        flags = @data[0].unpack('C')[0] # byte
+        @data.replace(@data[1..-1])
+        @read_stored = false
+        @read_stored = true if (flags & PacketLogReader::COSMOS4_STORED_FLAG_MASK) != 0
+        @read_extra = nil
+        if (flags & PacketLogReader::COSMOS4_EXTRA_FLAG_MASK) != 0
+          @reduction_state = :NEED_EXTRA
+        else
+          @reduction_state = :FLAGS_REMOVED
+        end
+      end
+
+      if @reduction_state == :NEED_EXTRA
+        # Read and remove extra
+        @read_extra = read_length_field_followed_by_string(4)
+        return :STOP if @read_extra == :STOP
+        @read_extra = JSON.parse(@read_extra)
+        @reduction_state = :FLAGS_REMOVED
+      end
+
+      if @reduction_state == :FLAGS_REMOVED or (@reduction_state == :SYNC_REMOVED and @mode != 4)
+        # Read and remove packet received time
         return :STOP if @data.length < 8
         time_seconds = @data[0..3].unpack('N')[0] # UINT32
         time_microseconds = @data[4..7].unpack('N')[0] # UINT32
-        @received_time = Time.at(time_seconds, time_microseconds).sys
+        @read_received_time = Time.at(time_seconds, time_microseconds).sys
         @data.replace(@data[8..-1])
         @reduction_state = :TIME_REMOVED
       end
 
       if @reduction_state == :TIME_REMOVED
         # Read and remove the target name
-        @target_name = read_length_field_followed_by_string(1)
-        return :STOP if @target_name == :STOP
+        @read_target_name = read_length_field_followed_by_string(1)
+        return :STOP if @read_target_name == :STOP
         @reduction_state = :TARGET_NAME_REMOVED
       end
 
       if @reduction_state == :TARGET_NAME_REMOVED
         # Read and remove the packet name
-        @packet_name = read_length_field_followed_by_string(1)
-        return :STOP if @packet_name == :STOP
+        @read_packet_name = read_length_field_followed_by_string(1)
+        return :STOP if @read_packet_name == :STOP
         @reduction_state = :PACKET_NAME_REMOVED
       end
 

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

@@ -62,6 +62,7 @@ module Cosmos
         allow_empty_data)
       @response_template = nil
       @response_packet = nil
+      @response_target_name = nil
       @response_packets = []
       @write_block_queue = Queue.new
       @ignore_lines = ignore_lines.to_i
@@ -124,7 +125,7 @@ module Cosmos
         end
 
         # Grab the response packet specified in the command
-        result_packet = System.telemetry.packet(@interface.target_names[0], @response_packet).clone
+        result_packet = System.telemetry.packet(@response_target_name, @response_packet).clone
         result_packet.received_time = nil
         result_packet.id_items.each do |item|
           result_packet.write_item(item, item.id_value, :RAW)
@@ -145,13 +146,13 @@ module Cosmos
         # Write the packet value with each of the values received
         response_values = response_string.scan(response_regexp)[0]
         if !response_values || (response_values.length != response_item_names.length)
-          handle_error("#{@interface.name}: Unexpected response: #{response_string}")
+          handle_error("#{@interface ? @interface.name : ""}: Unexpected response: #{response_string}")
         else
           response_values.each_with_index do |value, i|
             begin
               result_packet.write(response_item_names[i], value)
             rescue => error
-              handle_error("#{@interface.name}: Could not write value #{value} due to #{error.message}")
+              handle_error("#{@interface ? @interface.name : ""}: Could not write value #{value} due to #{error.message}")
               break
             end
           end
@@ -181,17 +182,20 @@ module Cosmos
       begin
         @response_template = packet.read("RSP_TEMPLATE").strip
         @response_packet = packet.read("RSP_PACKET").strip
+        @response_target_name = packet.target_name
         # If the template or packet are empty set them to nil. This allows for
         # the user to remove the RSP_TEMPLATE and RSP_PACKET values and avoid
         # any response timeouts
         if @response_template.empty? || @response_packet.empty?
           @response_template = nil
           @response_packet = nil
+          @response_target_name = nil
         end
       rescue
         # If there is no response template we set to nil
         @response_template = nil
         @response_packet = nil
+        @response_target_name = nil
       end
 
       # Grab the command template because that is all we eventually send
@@ -230,11 +234,12 @@ module Cosmos
           sleep(@response_polling_period)
           retry if !response_timeout_time
           retry if response_timeout_time and Time.now < response_timeout_time
-          handle_error("#{@interface.name}: Timeout waiting for response")
+          handle_error("#{@interface ? @interface.name : ""}: Timeout waiting for response")
         end
 
         @response_template = nil
         @response_packet = nil
+        @response_target_name = nil
         @response_packets.clear
       end
       return super(packet, data)

data/lib/cosmos/interfaces/serial_interface.rb

@@ -52,6 +52,7 @@ module Cosmos
       @read_allowed = false unless @read_port_name
       @flow_control = :NONE
       @data_bits = 8
+      @struct = []
     end
 
     # Creates a new {SerialStream} using the parameters passed in the constructor
@@ -65,13 +66,16 @@ module Cosmos
         @write_timeout,
         @read_timeout,
         @flow_control,
-        @data_bits
+        @data_bits,
+        @struct
       )
       super()
     end
 
     # Supported Options
     # FLOW_CONTROL - Flow control method NONE or RTSCTS. Defaults to NONE
+    # DATA_BITS - How many data bits to use
+    # STRUCT - Directly set fields in the Win32 DCB or POSIX termios structure
     def set_option(option_name, option_values)
       super(option_name, option_values)
       case option_name.upcase
@@ -79,6 +83,8 @@ module Cosmos
         @flow_control = option_values[0]
       when 'DATA_BITS'
         @data_bits = option_values[0].to_i
+      when 'STRUCT'
+        @struct << option_values
       end
     end
   end

data/lib/cosmos/interfaces/simulated_target_interface.rb

@@ -56,10 +56,14 @@ module Cosmos
       if @connected
         packet = first_pending_packet()
         if packet
-          # This is just to support the override functionality
+          # Support read_packet (but not read data) in protocols
           # Generic protocol use is not supported
-          packet = @read_protocols[0].read_packet(packet)
-          return packet
+          @read_protocols.each do |protocol|
+            packet = protocol.read_packet(packet)
+            return nil if packet == :DISCONNECT # Disconnect handled by thread
+            break if packet == :STOP
+          end
+          return packet unless packet == :STOP
         end
 
         while true
@@ -80,9 +84,14 @@ module Cosmos
 
           packet = first_pending_packet()
           if packet
-            # This is just to support the override functionality
+            # Support read_packet (but not read data) in protocols
             # Generic protocol use is not supported
-            packet = @read_protocols[0].read_packet(packet)
+            @read_protocols.each do |protocol|
+              packet = protocol.read_packet(packet)
+              return nil if packet == :DISCONNECT # Disconnect handled by thread
+              break if packet == :STOP
+            end
+            next if packet == :STOP
             return packet
           end
         end

data/lib/cosmos/interfaces/stream_interface.rb

@@ -49,7 +49,7 @@ module Cosmos
       begin
         data = @stream.read
       rescue Timeout::Error
-        Logger.instance.error "Timeout waiting for data to be read"
+        Logger.instance.error "#{@name}: Timeout waiting for data to be read"
         data = nil
       end
       return nil if data.nil? or data.length <= 0