openc3 5.1.1 → 5.2.0

data/lib/openc3/api/cmd_api.rb

@@ -17,12 +17,13 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/target_model'
 require 'openc3/topics/command_topic'
 require 'openc3/topics/interface_topic'
+require 'openc3/script/extract'
 
 module OpenC3
   module Api
@@ -49,134 +50,48 @@ module OpenC3
                        'get_cmd_cnts',
                      ])
 
-    # Send a command packet to a target.
+    # The following methods send a command packet to a target. The 'raw' version of the equivalent
+    # command methods do not perform command parameter conversions.
     #
     # Accepts two different calling styles:
     #   cmd("TGT CMD with PARAM1 val, PARAM2 val")
     #   cmd('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
     #
     # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param args [String|Array<String>] See the description for calling style
-    # @return [Array<String, String, Hash>] target_name, command_name, parameters
-    def cmd(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(true, true, false, 'cmd', *args, scope: scope, token: token)
+    def cmd(*args, **kwargs)
+      cmd_implementation('cmd', *args, range_check: true, hazardous_check: true, raw: false, **kwargs)
+    end
+    def cmd_raw(*args, **kwargs)
+      cmd_implementation('cmd_raw', *args, range_check: true, hazardous_check: true, raw: true, **kwargs)
     end
 
     # Send a command packet to a target without performing any value range
     # checks on the parameters. Useful for testing to allow sending command
     # parameters outside the allowable range as defined in the configuration.
-    #
-    # Accepts two different calling styles:
-    #   cmd_no_range_check("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_no_range_check('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param (see #cmd)
-    # @return (see #cmd)
-    def cmd_no_range_check(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(false, true, false, 'cmd_no_range_check', *args, scope: scope, token: token)
+    def cmd_no_range_check(*args, **kwargs)
+      cmd_implementation('cmd_no_range_check', *args, range_check: false, hazardous_check: true, raw: false, **kwargs)
+    end
+    def cmd_raw_no_range_check(*args, **kwargs)
+      cmd_implementation('cmd_raw_no_range_check', *args, range_check: false, hazardous_check: true, raw: true, **kwargs)
     end
 
     # Send a command packet to a target without performing any hazardous checks
     # both on the command itself and its parameters. Useful in scripts to
     # prevent popping up warnings to the user.
-    #
-    # Accepts two different calling styles:
-    #   cmd_no_hazardous_check("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_no_hazardous_check('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param (see #cmd)
-    # @return (see #cmd)
-    def cmd_no_hazardous_check(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(true, false, false, 'cmd_no_hazardous_check', *args, scope: scope, token: token)
+    def cmd_no_hazardous_check(*args, **kwargs)
+      cmd_implementation('cmd_no_hazardous_check', *args, range_check: true, hazardous_check: false, raw: false, **kwargs)
     end
-
-    # Send a command packet to a target without performing any value range
-    # checks or hazardous checks both on the command itself and its parameters.
-    #
-    # Accepts two different calling styles:
-    #   cmd_no_checks("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_no_checks('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param (see #cmd)
-    # @return (see #cmd)
-    def cmd_no_checks(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(false, false, false, 'cmd_no_checks', *args, scope: scope, token: token)
-    end
-
-    # Send a command packet to a target without running conversions.
-    #
-    # Accepts two different calling styles:
-    #   cmd_raw("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_raw('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param args [String|Array<String>] See the description for calling style
-    # @return [Array<String, String, Hash>] target_name, command_name, parameters
-    def cmd_raw(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(true, true, true, 'cmd_raw', *args, scope: scope, token: token)
+    def cmd_raw_no_hazardous_check(*args, **kwargs)
+      cmd_implementation('cmd_raw_no_hazardous_check', *args, range_check: true, hazardous_check: false, raw: true, **kwargs)
     end
 
     # Send a command packet to a target without performing any value range
-    # checks on the parameters or running conversions. Useful for testing to allow sending command
-    # parameters outside the allowable range as defined in the configuration.
-    #
-    # Accepts two different calling styles:
-    #   cmd_raw_no_range_check("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_raw_no_range_check('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param (see #cmd)
-    # @return (see #cmd)
-    def cmd_raw_no_range_check(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(false, true, true, 'cmd_raw_no_range_check', *args, scope: scope, token: token)
-    end
-
-    # Send a command packet to a target without running conversions or performing any hazardous checks
-    # both on the command itself and its parameters. Useful in scripts to
-    # prevent popping up warnings to the user.
-    #
-    # Accepts two different calling styles:
-    #   cmd_raw_no_hazardous_check("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_raw_no_hazardous_check('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param (see #cmd)
-    # @return (see #cmd)
-    def cmd_raw_no_hazardous_check(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(true, false, true, 'cmd_raw_no_hazardous_check', *args, scope: scope, token: token)
-    end
-
-    # Send a command packet to a target without running conversions or performing any value range
     # checks or hazardous checks both on the command itself and its parameters.
-    #
-    # Accepts two different calling styles:
-    #   cmd_raw_no_checks("TGT CMD with PARAM1 val, PARAM2 val")
-    #   cmd_raw_no_checks('TGT','CMD','PARAM1'=>val,'PARAM2'=>val)
-    #
-    # Favor the first syntax where possible as it is more succinct.
-    #
-    # @param (see #cmd)
-    # @return (see #cmd)
-    def cmd_raw_no_checks(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
-      cmd_implementation(false, false, true, 'cmd_raw_no_checks', *args, scope: scope, token: token)
+    def cmd_no_checks(*args, **kwargs)
+      cmd_implementation('cmd_no_checks', *args, range_check: false, hazardous_check: false, raw: false, **kwargs)
+    end
+    def cmd_raw_no_checks(*args, **kwargs)
+      cmd_implementation('cmd_raw_no_checks', *args, range_check: false, hazardous_check: false, raw: true, **kwargs)
     end
 
     # Send a raw binary string to the specified interface.
@@ -258,7 +173,7 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @return [Boolean] Whether the command is hazardous
     def get_cmd_hazardous(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
-      args << kwargs unless kwargs.empty?
+      extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
         target_name, command_name, params = extract_fields_from_cmd_text(args[0], scope: scope)
@@ -375,7 +290,10 @@ module OpenC3
     # PRIVATE implementation details
     ###########################################################################
 
-    def cmd_implementation(range_check, hazardous_check, raw, method_name, *args, scope:, token:)
+    def cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil,
+                           scope: $openc3_scope, token: $openc3_token, **kwargs)
+      extract_string_kwargs_to_args(args, kwargs)
+
       case args.length
       when 1
         target_name, cmd_name, cmd_params = extract_fields_from_cmd_text(args[0], scope: scope)
@@ -402,8 +320,21 @@ module OpenC3
         'hazardous_check' => hazardous_check.to_s,
         'raw' => raw.to_s
       }
-      Logger.info(build_cmd_output_string(target_name, cmd_name, cmd_params, packet, raw), scope: scope) if !packet["messages_disabled"]
-      CommandTopic.send_command(command, scope: scope)
+      log_cmd = true
+      if packet["messages_disabled"]
+        log_cmd = false
+      else
+        cmd_params.each do |key, value|
+          item = packet['items'].find { |item| item['name'] == key.to_s }
+          if item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
+            log_cmd = false
+          end
+        end
+      end
+      if log_cmd
+        Logger.info(build_cmd_output_string(target_name, cmd_name, cmd_params, packet, raw), scope: scope)
+      end
+      CommandTopic.send_command(command, timeout: timeout, scope: scope)
     end
 
     def build_cmd_output_string(target_name, cmd_name, cmd_params, packet, raw)

data/lib/openc3/api/interface_api.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/interface_model'
@@ -125,7 +125,7 @@ module OpenC3
     #
     # @param target_name [String/Array] The name of the target(s)
     # @param interface_name (see #connect_interface)
-    def map_target_to_interface(target_name, interface_name, scope: $openc3_scope, token: $openc3_token)
+    def map_target_to_interface(target_name, interface_name, cmd_only: false, tlm_only: false, unmap_old: true, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
       new_interface = InterfaceModel.get_model(name: interface_name, scope: scope)
       if Array === target_name
@@ -134,7 +134,7 @@ module OpenC3
         target_names = [target_name]
       end
       target_names.each do |name|
-        new_interface.map_target(name)
+        new_interface.map_target(name, cmd_only: cmd_only, tlm_only: tlm_only, unmap_old: unmap_old)
         Logger.info("Target #{name} mapped to Interface #{interface_name}", scope: scope)
       end
       nil

data/lib/openc3/api/offline_access_api.rb

@@ -0,0 +1,78 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 OpenC3, Inc
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/models/offline_access_model'
+require 'openc3/utilities/authentication'
+
+module OpenC3
+  module Api
+    WHITELIST ||= []
+    WHITELIST.concat([
+                       'offline_access_needed',
+                       'set_offline_access'
+                     ])
+
+    def offline_access_needed(scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', scope: scope, token: token)
+      begin
+        authorize(permission: 'script_run', scope: scope, token: token)
+      rescue
+        # Not needed if can't run scripts
+        return false
+      end
+      info = user_info(token)
+      if info['roles'].to_s.include?("offline_access")
+        username = info['username']
+        if username and username != ''
+          model = OfflineAccessModel.get_model(name: username, scope: scope)
+          if model and model.offline_access_token
+            auth = OpenC3KeycloakAuthentication.new(ENV['OPENC3_KEYCLOAK_URL'])
+            valid_token = auth.get_token_from_refresh_token(model.offline_access_token)
+            if valid_token
+              return false
+            else
+              model.offline_access_token = nil
+              model.update
+              return true
+            end
+          end
+          return true
+        else
+          return false
+        end
+      else
+        return false
+      end
+    end
+
+    def set_offline_access(offline_access_token, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_run', scope: scope, token: token)
+      info = user_info(token)
+      username = info['username']
+      raise "Invalid username" if not username or username == ''
+      model = OfflineAccessModel.get_model(name: username, scope: scope)
+      if model
+        model.offline_access_token = offline_access_token
+        model.update
+      else
+        model = OfflineAccessModel.new(name: username, offline_access_token: offline_access_token, scope: scope)
+        model.create
+      end
+    end
+  end
+end

data/lib/openc3/api/settings_api.rb

@@ -17,9 +17,11 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/models/settings_model'
+
 module OpenC3
   module Api
     WHITELIST ||= []

data/lib/openc3/api/stash_api.rb

@@ -0,0 +1,63 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 OpenC3, Inc
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/models/stash_model'
+
+module OpenC3
+  module Api
+    WHITELIST ||= []
+    WHITELIST.concat([
+                       'stash_set',
+                       'stash_get',
+                       'stash_all',
+                       'stash_keys',
+                       'stash_delete'
+                     ])
+
+    def stash_set(key, value, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_run', scope: scope, token: token)
+      StashModel.set( {name: key, value: JSON.generate(value.as_json(:allow_nan => true)) }, scope: scope)
+    end
+
+    def stash_get(key, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', scope: scope, token: token)
+      result = StashModel.get(name: key, scope: scope)
+      if result
+        JSON.parse(result['value'], :allow_nan => true, :create_additions => true)
+      else
+        nil
+      end
+    end
+
+    def stash_all(scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', scope: scope, token: token)
+      StashModel.all(scope: scope).transform_values { |hash| JSON.parse(hash["value"], :allow_nan => true, :create_additions => true) }
+    end
+
+    def stash_keys(scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', scope: scope, token: token)
+      StashModel.names(scope: scope)
+    end
+
+    def stash_delete(key, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_run', scope: scope, token: token)
+      model = StashModel.get_model(name: key, scope: scope)
+      model.destroy if model
+    end
+  end
+end

data/lib/openc3/api/target_api.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/target_model'
@@ -66,14 +66,13 @@ module OpenC3
         packets.each do |packet|
           tlm_cnt += Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
         end
-        interface_name = ''
+        interface_names = []
         InterfaceModel.all(scope: scope).each do |name, interface|
           if interface['target_names'].include? target_name
-            interface_name = interface['name']
-            break
+            interface_names << interface['name']
           end
         end
-        info << [target_name, interface_name, cmd_cnt, tlm_cnt]
+        info << [target_name, interface_names.join(","), cmd_cnt, tlm_cnt]
       end
       info
     end

data/lib/openc3/config/config_parser.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/top_level'
@@ -449,12 +449,11 @@ module OpenC3
     if RUBY_ENGINE != 'ruby' or ENV['OPENC3_NO_EXT']
       # Iterates over each line of the io object and yields the keyword and parameters
       def parse_loop(io, yield_non_keyword_lines, remove_quotes, size, rx)
-        line_continuation = false
-
+        string_concat = false
         @line_number = 0
         @keyword = nil
         @parameters = []
-        @line = nil
+        @line = ''
 
         while true
           @line_number += 1
@@ -470,37 +469,57 @@ module OpenC3
           end
 
           line.strip!
-          data = line.scan(rx)
-          first_item = data[0].to_s
+          # Ensure the line length is not 0
+          next if line.length == 0
 
-          if line_continuation
-            @line << line
-            # Carry over keyword and parameters
-          else
-            @line = line
-            if (first_item.length == 0) || (first_item[0] == '#')
-              @keyword = nil
-            else
-              @keyword = first_item.upcase
+          if string_concat
+            # Skip comment lines after a string concatenation
+            if (line[0] == '#')
+              next
             end
-            @parameters = []
+            # Remove the opening quote if we're continuing the line
+            line = line[1..-1]
           end
 
-          # Ignore comments and blank lines
-          if @keyword.nil?
-            if (yield_non_keyword_lines) && (!line_continuation)
-              yield(@keyword, @parameters)
-            end
+          # Check for string continuation
+          case line[-1]
+          when '+', '\\' # String concatenation
+            newline = line[-1] == '+'
+            # Trim off the concat character plus any spaces, e.g. "line" \
+            trim = line[0..-2].strip()
+            # Now trim off the last quote so it will flow into the next line
+            @line += trim[0..-2]
+            @line += "\n" if newline
+            string_concat = true
+            next
+          when '&' # Line continuation
+            @line += line[0..-2]
             next
+          else
+            @line += line
+          end
+          string_concat = false
+
+          data = @line.scan(rx)
+          first_item = ''
+          if data.length > 0
+            first_item += data[0]
           end
 
-          if line_continuation
-            if remove_quotes
-              @parameters << first_item.remove_quotes
-            else
-              @parameters << first_item
+          if (first_item.length == 0) || (first_item[0] == '#')
+            @keyword = nil
+          else
+            @keyword = first_item.upcase
+          end
+          @parameters = []
+
+          # Ignore lines without keywords: comments and blank lines
+          if @keyword.nil?
+            if yield_non_keyword_lines
+              yield(@keyword, @parameters)
             end
-            line_continuation = false
+            @line = ''
+            next
           end
 
           length = data.length
@@ -518,13 +537,6 @@ module OpenC3
                 end
               end
 
-              # If the string is simply '&' and its the last string then its a line continuation so break the loop
-              if (string.length == 1) && (string[0] == '&') && (index == (length - 1))
-                line_continuation = true
-                next
-              end
-
-              line_continuation = false
               if remove_quotes
                 @parameters << string.remove_quotes
               else
@@ -533,20 +545,8 @@ module OpenC3
             end
           end
 
-          # If we detected a line continuation while going through all the
-          # strings on the line then we strip off the continuation character and
-          # return to the top of the loop to continue processing the line.
-          if line_continuation
-            # Strip the continuation character
-            if @line.length >= 1
-              @line = @line[0..-2]
-            else
-              @line = ""
-            end
-            next
-          end
-
           yield(@keyword, @parameters)
+          @line = ''
         end
 
         @@progress_callback.call(1.0) if @@progress_callback

data/lib/openc3/interfaces/interface.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/api/api'
@@ -38,6 +38,12 @@ module OpenC3
     # @return [Array<String>] Array of target names associated with this interface
     attr_accessor :target_names
 
+    # @return [Array<String>] Array of cmd target names associated with this interface
+    attr_accessor :cmd_target_names
+
+    # @return [Array<String>] Array of tlm target names associated with this interface
+    attr_accessor :tlm_target_names
+
     # @return [Boolean] Flag indicating if the interface should be connected
     #   to on startup
     attr_accessor :connect_on_startup
@@ -133,6 +139,8 @@ module OpenC3
       @name = self.class.to_s.split("::")[-1] # Remove namespacing if present
       @state = 'DISCONNECTED'
       @target_names = []
+      @cmd_target_names = []
+      @tlm_target_names = []
       @connect_on_startup = true
       @auto_reconnect = true
       @reconnect_delay = 5.0
@@ -381,6 +389,8 @@ module OpenC3
     def copy_to(other_interface)
       other_interface.name = self.name.clone
       other_interface.target_names = self.target_names.clone
+      other_interface.cmd_target_names = self.cmd_target_names.clone
+      other_interface.tlm_target_names = self.tlm_target_names.clone
       other_interface.connect_on_startup = self.connect_on_startup
       other_interface.auto_reconnect = self.auto_reconnect
       other_interface.reconnect_delay = self.reconnect_delay

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

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/config/config_parser'
@@ -55,30 +55,44 @@ module OpenC3
     # creating a Packet. It can discard a set number of bytes at the beginning
     # before creating the Packet.
     #
+    # Note: On the first call to this from any interface read(), data will contain a blank
+    # string. Blank string is an opportunity for protocols to return any queued up packets.
+    # If they have no queued up packets, they should pass the blank string down to chained
+    # protocols giving them the same opportunity.
+    #
     # @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 and data.length > 0
+      while true
+        control = handle_sync_pattern()
+        return control if control and data.length > 0 # Only return here if not blank string test
 
-      # Reduce the data to a single packet
-      packet_data = reduce_to_single_packet()
+        # Reduce the data to a single packet
+        packet_data = reduce_to_single_packet()
+        if packet_data == :RESYNC
+          @sync_state = :SEARCHING
+          next if data.length > 0 # Only immediately resync if not blank string test
+        end
 
-      # Potentially allow blank string to be sent to other protocols if no packet is ready in this one
-      if Symbol === packet_data
-        if (data.length <= 0) and packet_data == :STOP
-          return super(data)
-        else
-          return packet_data
+        # Potentially allow blank string to be sent to other protocols if no packet is ready in this one
+        if Symbol === packet_data
+          if (data.length <= 0) and packet_data != :DISCONNECT
+            # On blank string test, return blank string (unless we had a packet or need disconnect)
+            # The base class handles the special case of returning STOP if on the last protocol in the
+            # chain
+            return super(data)
+          else
+            return packet_data # Return any control code if not on blank string test
+          end
         end
-      end
 
-      @sync_state = :SEARCHING
+        @sync_state = :SEARCHING
 
-      # Discard leading bytes if necessary
-      packet_data.replace(packet_data[@discard_leading_bytes..-1]) if @discard_leading_bytes > 0
-      packet_data
+        # Discard leading bytes if necessary
+        packet_data.replace(packet_data[@discard_leading_bytes..-1]) if @discard_leading_bytes > 0
+        return packet_data
+      end
     end
 
     # Called to perform modifications on a command packet before it is sent