openc3 6.9.1 → 6.10.0

data/lib/openc3/accessors/accessor.rb

@@ -17,6 +17,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'json'
+require 'openc3/config/config_parser'
 
 module OpenC3
   class Accessor
@@ -28,11 +29,26 @@ module OpenC3
     end
 
     def read_item(item, buffer)
-      self.class.read_item(item, buffer)
+      if item.parent_item
+        # Structure is used to read items with parent, not accessor
+        structure_buffer = read_item(item.parent_item, buffer)
+        structure = item.parent_item.structure
+        structure.read(item.key, :RAW, structure_buffer)
+      else
+        self.class.read_item(item, buffer)
+      end
     end
 
     def write_item(item, value, buffer)
-      self.class.write_item(item, value, buffer)
+      if item.parent_item
+        # Structure is used to write items with parent, not accessor
+        structure_buffer = read_item(item.parent_item, buffer)
+        structure = item.parent_item.structure
+        structure.write(item.key, value, :RAW, structure_buffer)
+        self.class.write_item(item.parent_item, structure_buffer, buffer)
+      else
+        self.class.write_item(item, value, buffer)
+      end
     end
 
     def read_items(items, buffer)
@@ -106,8 +122,16 @@ module OpenC3
     def self.convert_to_type(value, item)
       return value if value.nil?
       case item.data_type
+      when :ANY
+        begin
+          value = JSON.parse(value) if value.is_a? String
+        rescue Exception
+          # Just leave value as is
+        end
+      when :BOOL
+        value = ConfigParser.handle_true_false(value) if value.is_a? String
       when :OBJECT, :ARRAY
-        # Do nothing for complex object types
+        value = JSON.parse(value) if value.is_a? String
       when :STRING, :BLOCK
         if item.array_size
           value = JSON.parse(value) if value.is_a? String

data/lib/openc3/accessors/binary_accessor.rb

@@ -137,8 +137,16 @@ module OpenC3
 
     def read_item(item, buffer)
       return nil if item.data_type == :DERIVED
-      handle_read_variable_bit_size(item, buffer) if item.variable_bit_size
-      self.class.read_item(item, buffer)
+      if item.parent_item
+        handle_read_variable_bit_size(item.parent_item, buffer) if item.parent_item.variable_bit_size
+        # Structure is used to read items with parent, not accessor
+        structure_buffer = read_item(item.parent_item, buffer)
+        structure = item.parent_item.structure
+        structure.read(item.key, :RAW, structure_buffer)
+      else
+        handle_read_variable_bit_size(item, buffer) if item.variable_bit_size
+        self.class.read_item(item, buffer)
+      end
     end
 
     def handle_write_variable_bit_size(item, value, buffer)
@@ -270,8 +278,17 @@ module OpenC3
 
     def write_item(item, value, buffer)
       return nil if item.data_type == :DERIVED
-      handle_write_variable_bit_size(item, value, buffer) if item.variable_bit_size
-      self.class.write_item(item, value, buffer)
+      if item.parent_item
+        # Structure is used to write items with parent, not accessor
+        structure_buffer = read_item(item.parent_item, buffer)
+        structure = item.parent_item.structure
+        structure.write(item.key, value, :RAW, structure_buffer)
+        handle_write_variable_bit_size(item.parent_item, structure_buffer, buffer) if item.parent_item.variable_bit_size
+        self.class.write_item(item.parent_item, structure_buffer, buffer)
+      else
+        handle_write_variable_bit_size(item, value, buffer) if item.variable_bit_size
+        self.class.write_item(item, value, buffer)
+      end
     end
 
     # Note: do not use directly - use instance read_item

data/lib/openc3/accessors/template_accessor.rb

@@ -25,6 +25,7 @@ module OpenC3
       @left_char = left_char
       @right_char = right_char
       @configured = false
+      @args = [left_char, right_char]
     end
 
     def configure
@@ -65,7 +66,7 @@ module OpenC3
         values.each_with_index do |value, i|
           item_key = @item_keys[i]
           if item_key == item.key
-            return Accessor.convert_to_type(value, item)
+            return self.class.convert_to_type(value, item)
           end
         end
       end
@@ -89,7 +90,7 @@ module OpenC3
           end
           index = @item_keys.index(item.key)
           if index
-            result[item.name] = Accessor.convert_to_type(values[index], item)
+            result[item.name] = self.class.convert_to_type(values[index], item)
           else
             raise "Unknown item with key #{item.key} requested"
           end

data/lib/openc3/api/cmd_api.rb

@@ -545,9 +545,13 @@ module OpenC3
         queue = ENV['OPENC3_DEFAULT_QUEUE']
       end
       if queue
-        # Pull the command out of the script string, e.g. cmd("INST ABORT")
-        queued = cmd_string.split('("')[1].split('")')[0]
-        QueueModel.queue_command(queue, command: queued, username: username, scope: scope)
+        # Pass the command components separately for the queue microservice to use the 3-parameter cmd() method
+        QueueModel.queue_command(queue,
+          target_name: target_name,
+          cmd_name: cmd_name,
+          cmd_params: cmd_params,
+          username: username,
+          scope: scope)
       else
         CommandTopic.send_command(command, timeout: timeout, scope: scope)
       end

data/lib/openc3/api/tlm_api.rb

@@ -221,15 +221,21 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @param packet_name [String] Name of the packet
     # @return [Hash] telemetry hash with last telemetry buffer
-    def get_tlm_buffer(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_buffer(*args, manual: false, scope: $openc3_scope, token: $openc3_token, timeout: 5)
       target_name, packet_name = _extract_target_packet_names('get_tlm_buffer', *args)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
-      TargetModel.packet(target_name, packet_name, scope: scope)
-      topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-      msg_id, msg_hash = Topic.get_newest_message(topic)
-      if msg_id
+      model = TargetModel.packet(target_name, packet_name, scope: scope)
+      if model["subpacket"]
+        msg_hash = DecomInterfaceTopic.get_tlm_buffer(target_name, packet_name, timeout: timeout, scope: scope)
         msg_hash['buffer'] = msg_hash['buffer'].b
         return msg_hash
+      else
+        topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
+        msg_id, msg_hash = Topic.get_newest_message(topic)
+        if msg_id
+          msg_hash['buffer'] = msg_hash['buffer'].b
+          return msg_hash
+        end
       end
       return nil
     end
@@ -249,7 +255,8 @@ module OpenC3
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       t = _validate_tlm_type(type)
       raise ArgumentError, "Unknown type '#{type}' for #{target_name} #{packet_name}" if t.nil?
-      items = packet['items'].map { | item | item['name'].upcase }
+      items = packet["items"].reject { | item | item["hidden"] }
+      items = items.map { | item | item['name'].upcase }
       cvt_items = items.map { | item | [target_name, packet_name, item, type] }
       current_values = CvtModel.get_tlm_values(cvt_items, stale_time: stale_time, cache_timeout: cache_timeout, scope: scope)
       items.zip(current_values).map { | item , values | [item, values[0], values[1]]}
@@ -437,8 +444,11 @@ module OpenC3
     # @param packet_name [String] Name of the packet
     # @param item_name [String] Name of the packet
     # @return [Hash] Telemetry packet item hash
-    def get_item(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
+    def get_item(*args, manual: false, scope: $openc3_scope, token: $openc3_token, cache_timeout: nil)
       target_name, packet_name, item_name = _extract_target_packet_item_names('get_item', *args)
+      if packet_name == 'LATEST'
+        packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: scope)
+      end
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
     end

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

@@ -89,12 +89,10 @@ module OpenC3
         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
+            unique_id_mode = System.telemetry.tlm_unique_id_mode(target_name)
           else
             target_packets = System.commands.packets(target_name)
-            target = System.targets[target_name]
-            unique_id_mode = target.cmd_unique_id_mode if target
+            unique_id_mode = System.commands.cmd_unique_id_mode(target_name)
           end
         rescue RuntimeError
           # No commands/telemetry for this target
@@ -103,7 +101,7 @@ module OpenC3
 
         if unique_id_mode
           target_packets.each do |_packet_name, packet|
-            if packet.identify?(@data[@discard_leading_bytes..-1])
+            if not packet.subpacket and packet.identify?(@data[@discard_leading_bytes..-1]) # identify? handles virtual
               identified_packet = packet
               break
             end
@@ -111,15 +109,23 @@ module OpenC3
         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]
+            packet = nil
+            target_packets.each do |_packet_name, target_packet|
+              next if target_packet.virtual
+              next if target_packet.subpacket
+              packet = target_packet
+              break
+            end
+            if packet
+              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
-            identified_packet = hash[key]
-            identified_packet = hash['CATCHALL'.freeze] unless identified_packet
           end
         end
 

data/lib/openc3/interfaces.rb

@@ -34,14 +34,16 @@ module OpenC3
   autoload(:TcpipServerInterface, 'openc3/interfaces/tcpip_server_interface.rb')
   autoload(:UdpInterface, 'openc3/interfaces/udp_interface.rb')
 
-  autoload(:Protocol, 'openc3/interfaces/protocols/protocol.rb')
   autoload(:BurstProtocol, 'openc3/interfaces/protocols/burst_protocol.rb')
+  autoload(:CmdResponseProtocol, 'openc3/interfaces/protocols/cmd_response_protocol.rb')
+  autoload(:CobsProtocol, 'openc3/interfaces/protocols/cobs_protocol.rb')
+  autoload(:CrcProtocol, 'openc3/interfaces/protocols/crc_protocol.rb')
   autoload(:FixedProtocol, 'openc3/interfaces/protocols/fixed_protocol.rb')
+  autoload(:IgnorePacketProtocol, 'openc3/interfaces/protocols/ignore_packet_protocol.rb')
   autoload(:LengthProtocol, 'openc3/interfaces/protocols/length_protocol.rb')
   autoload(:PreidentifiedProtocol, 'openc3/interfaces/protocols/preidentified_protocol.rb')
+  autoload(:Protocol, 'openc3/interfaces/protocols/protocol.rb')
+  autoload(:SlipProtocol, 'openc3/interfaces/protocols/slip_protocol.rb')
   autoload(:TemplateProtocol, 'openc3/interfaces/protocols/template_protocol.rb')
   autoload(:TerminatedProtocol, 'openc3/interfaces/protocols/terminated_protocol.rb')
-  autoload(:CmdResponseProtocol, 'openc3/interfaces/protocols/cmd_response_protocol.rb')
-  autoload(:CrcProtocol, 'openc3/interfaces/protocols/crc_protocol.rb')
-  autoload(:IgnorePacketProtocol, 'openc3/interfaces/protocols/ignore_packet_protocol.rb')
 end

data/lib/openc3/io/json_rpc.rb

@@ -59,6 +59,12 @@ class String
   NON_ASCII_PRINTABLE = /[^\x21-\x7e\s]/
   NON_UTF8_PRINTABLE = /[\x00-\x08\x0E-\x1F\x7F]/
   def as_json(_options = nil)
+    # If string is ASCII-8BIT (binary) and has non-ASCII bytes (> 127), encode as binary
+    # This handles data from hex_to_byte_string and other binary sources
+    if self.encoding == Encoding::ASCII_8BIT && self.bytes.any? { |b| b > 127 }
+      return self.to_json_raw_object
+    end
+
     as_utf8 = self.dup.force_encoding('UTF-8')
     if as_utf8.valid_encoding?
       if as_utf8 =~ NON_UTF8_PRINTABLE

data/lib/openc3/microservices/decom_microservice.rb

@@ -24,6 +24,7 @@ require 'time'
 require 'thread'
 require 'openc3/microservices/microservice'
 require 'openc3/microservices/interface_decom_common'
+require 'openc3/microservices/interface_microservice'
 require 'openc3/topics/telemetry_decom_topic'
 require 'openc3/topics/limits_event_topic'
 
@@ -127,6 +128,10 @@ module OpenC3
                   handle_build_cmd(msg_hash['build_cmd'], msg_id)
                   next
                 end
+                if msg_hash.key?('get_tlm_buffer')
+                  handle_get_tlm_buffer(msg_hash['get_tlm_buffer'], msg_id)
+                  next
+                end
               else
                 decom_packet(topic, msg_id, msg_hash, redis)
                 @metric.set(name: 'decom_total', value: @count, type: 'counter')
@@ -154,9 +159,12 @@ module OpenC3
         @metric.set(name: 'decom_topic_delta_seconds', value: delta, type: 'gauge', unit: 'seconds', help: 'Delta time between data written to stream and decom start')
 
         start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        #######################################
+        # Build packet object from topic data
+        #######################################
         target_name = msg_hash["target_name"]
         packet_name = msg_hash["packet_name"]
-
         packet = System.telemetry.packet(target_name, packet_name)
         packet.stored = ConfigParser.handle_true_false(msg_hash["stored"])
         # Note: Packet time will be recalculated as part of decom so not setting
@@ -168,29 +176,101 @@ module OpenC3
           packet.extra = extra
         end
         packet.buffer = msg_hash["buffer"]
-        # Processors are user code points which must be rescued
-        # so the TelemetryDecomTopic can write the packet
-        begin
-          packet.process # Run processors
-        rescue Exception => e
-          @error_count += 1
-          @metric.set(name: 'decom_error_total', value: @error_count, type: 'counter')
-          @error = e
-          @logger.error e.message
-        end
-        # Process all the limits and call the limits_change_callback (as necessary)
-        # check_limits also can call user code in the limits response
-        # but that is rescued separately in the limits_change_callback
-        packet.check_limits(System.limits_set)
 
-        # This is what actually decommutates the packet and updates the CVT
-        TelemetryDecomTopic.write_packet(packet, scope: @scope)
+        ################################################################################
+        # Break packet into subpackets (if necessary)
+        # Subpackets are typically channelized data
+        ################################################################################
+        packet_and_subpackets = packet.subpacketize
+
+        packet_and_subpackets.each do |packet_or_subpacket|
+          if packet_or_subpacket.subpacket
+            packet_or_subpacket = handle_subpacket(packet, packet_or_subpacket)
+          end
+
+          #####################################################################################
+          # Run Processors
+          # This must be before the full decom so that processor derived values are available
+          #####################################################################################
+          begin
+            packet_or_subpacket.process # Run processors
+          rescue Exception => e
+            @error_count += 1
+            @metric.set(name: 'decom_error_total', value: @error_count, type: 'counter')
+            @error = e
+            @logger.error e.message
+          end
+
+          #############################################################################
+          # Process all the limits and call the limits_change_callback (as necessary)
+          # This must be before the full decom so that limits states are available
+          #############################################################################
+          packet_or_subpacket.check_limits(System.limits_set)
+
+          # This is what actually decommutates the packet and updates the CVT
+          TelemetryDecomTopic.write_packet(packet_or_subpacket, scope: @scope)
+        end
 
         diff = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start # seconds as a float
         @metric.set(name: 'decom_duration_seconds', value: diff, type: 'gauge', unit: 'seconds')
       end
     end
 
+    def handle_subpacket(packet, subpacket)
+      # Subpacket received time always = packet.received_time
+      # Use packet_time appropriately if another timestamp is needed
+      subpacket.received_time = packet.received_time
+      subpacket.stored = packet.stored
+      subpacket.extra = packet.extra
+
+      if subpacket.stored
+        # Stored telemetry does not update the current value table
+        identified_subpacket = System.telemetry.identify_and_define_packet(subpacket, @target_names, subpackets: true)
+      else
+        # Identify and update subpacket
+        if subpacket.identified?
+          begin
+            # Preidentifed subpacket - place it into the current value table
+            identified_subpacket = System.telemetry.update!(subpacket.target_name,
+                                                            subpacket.packet_name,
+                                                            subpacket.buffer)
+          rescue RuntimeError
+            # Subpacket identified but we don't know about it
+            # Clear packet_name and target_name and try to identify
+            @logger.warn "#{@name}: Received unknown identified subpacket: #{subpacket.target_name} #{subpacket.packet_name}"
+            subpacket.target_name = nil
+            subpacket.packet_name = nil
+            identified_subpacket = System.telemetry.identify!(subpacket.buffer,
+                                                              @target_names, subpackets: true)
+          end
+        else
+          # Packet needs to be identified
+          identified_subpacket = System.telemetry.identify!(subpacket.buffer,
+                                                            @target_names, subpackets: true)
+        end
+      end
+
+      if identified_subpacket
+        identified_subpacket.received_time = subpacket.received_time
+        identified_subpacket.stored = subpacket.stored
+        identified_subpacket.extra = subpacket.extra
+        subpacket = identified_subpacket
+      else
+        unknown_subpacket = System.telemetry.update!('UNKNOWN', 'UNKNOWN', subpacket.buffer)
+        unknown_subpacket.received_time = subpacket.received_time
+        unknown_subpacket.stored = subpacket.stored
+        unknown_subpacket.extra = subpacket.extra
+        subpacket = unknown_subpacket
+        num_bytes_to_print = [InterfaceMicroservice::UNKNOWN_BYTES_TO_PRINT, subpacket.length].min
+        data = subpacket.buffer(false)[0..(num_bytes_to_print - 1)]
+        prefix = data.each_byte.map { | byte | sprintf("%02X", byte) }.join()
+        @logger.warn "#{@name} #{subpacket.target_name} packet length: #{subpacket.length} starting with: #{prefix}"
+      end
+
+      TargetModel.sync_tlm_packet_counts(subpacket, @target_names, scope: @scope)
+      return subpacket
+    end
+
     # Called when an item in any packet changes limits states.
     #
     # @param packet [Packet] Packet which has had an item change limits state

data/lib/openc3/microservices/interface_decom_common.rb

@@ -76,5 +76,37 @@ module OpenC3
       end
       Topic.write_topic(ack_topic, msg_hash)
     end
+
+    def handle_get_tlm_buffer(get_tlm_buffer_json, msg_id)
+      get_tlm_buffer_hash = JSON.parse(get_tlm_buffer_json, allow_nan: true, create_additions: true)
+      target_name = get_tlm_buffer_hash['target_name']
+      packet_name = get_tlm_buffer_hash['packet_name']
+      ack_topic = "{#{@scope}__ACKCMD}TARGET__#{target_name}"
+      begin
+        packet = System.telemetry.packet(target_name, packet_name)
+        msg_hash = {
+          id: msg_id,
+          result: 'SUCCESS',
+          time: packet.packet_time.to_nsec_from_epoch,
+          received_time: packet.received_time.to_nsec_from_epoch,
+          target_name: packet.target_name,
+          packet_name: packet.packet_name,
+          received_count: packet.received_count,
+          stored: packet.stored.to_s,
+          buffer: packet.buffer(false)
+        }
+        msg_hash[:extra] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
+
+      # If there is an error due to parameter out of range, etc, we rescue it so we can
+      # write the ACKCMD}TARGET topic and allow the source to return
+      rescue => error
+        msg_hash = {
+          id: msg_id,
+          result: 'ERROR',
+          message: error.message
+        }
+      end
+      Topic.write_topic(ack_topic, msg_hash)
+    end
   end
 end

data/lib/openc3/microservices/interface_microservice.rb

@@ -231,6 +231,8 @@ module OpenC3
           cmd_name = msg_hash['cmd_name']
           manual = ConfigParser.handle_true_false(msg_hash['manual'])
           cmd_params = nil
+          range_check = true
+          raw = false
           cmd_buffer = nil
           hazardous_check = nil
           if msg_hash['cmd_params']
@@ -288,14 +290,13 @@ module OpenC3
             if @critical_commanding and @critical_commanding != 'OFF' and not release_critical
               restricted = command.restricted
               if hazardous or restricted or (@critical_commanding == 'ALL' and manual)
+                cmd_type = 'NORMAL'
                 if hazardous
-                  type = 'HAZARDOUS'
+                  cmd_type = 'HAZARDOUS'
                 elsif restricted
-                  type = 'RESTRICTED'
-                else
-                  type = 'NORMAL'
+                  cmd_type = 'RESTRICTED'
                 end
-                model = CriticalCmdModel.new(name: SecureRandom.uuid, type: type, interface_name: @interface.name, username: msg_hash['username'], cmd_hash: msg_hash, scope: @scope)
+                model = CriticalCmdModel.new(name: SecureRandom.uuid, type: cmd_type, interface_name: @interface.name, username: msg_hash['username'], cmd_hash: msg_hash, scope: @scope)
                 model.create
                 @logger.info("Critical Cmd Pending: #{msg_hash['cmd_string']}", user: msg_hash['username'], scope: @scope)
                 next "CriticalCmdError\n#{model.name}"
@@ -428,10 +429,12 @@ module OpenC3
               params = JSON.parse(msg_hash['params'], allow_nan: true, create_additions: true)
             end
             @router = @tlm.attempting(*params)
+            next 'SUCCESS'
           end
           if msg_hash['disconnect']
             @logger.info "#{@router.name}: Disconnect requested"
             @tlm.disconnect(false)
+            next 'SUCCESS'
           end
           if msg_hash.key?('log_stream')
             if msg_hash['log_stream'] == 'true'
@@ -441,6 +444,7 @@ module OpenC3
               @logger.info "#{@router.name}: Disable stream logging"
               @router.stop_raw_logging
             end
+            next 'SUCCESS'
           end
           if msg_hash.key?('router_cmd')
             params = JSON.parse(msg_hash['router_cmd'], allow_nan: true, create_additions: true)
@@ -550,23 +554,7 @@ module OpenC3
         target = System.targets[target_name]
         target.interface = @interface
       end
-      @interface.tlm_target_names.each do |target_name|
-        # Initialize the target's packet counters based on the Topic stream
-        # Prevents packet count resetting to 0 when interface restarts
-        begin
-          System.telemetry.packets(target_name).each do |packet_name, packet|
-            topic = "#{@scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-            msg_id, msg_hash = Topic.get_newest_message(topic)
-            if msg_id
-              packet.received_count = msg_hash['received_count'].to_i
-            else
-              packet.received_count = 0
-            end
-          end
-        rescue
-          # Handle targets without telemetry
-        end
-      end
+      TargetModel.init_tlm_packet_counts(@interface.tlm_target_names, scope: @scope)
       if @interface.connect_on_startup
         @interface.state = 'ATTEMPTING'
       else
@@ -579,9 +567,6 @@ module OpenC3
       end
 
       @queued = false
-      @sync_packet_count_data = {}
-      @sync_packet_count_time = nil
-      @sync_packet_count_delay_seconds = 1.0 # Sync packet counts every second
       @interface.options.each do |option_name, option_values|
         if option_name.upcase == 'OPTIMIZE_THROUGHPUT'
           @queued = true
@@ -590,7 +575,7 @@ module OpenC3
           StoreQueued.instance.set_update_interval(update_interval)
         end
         if option_name.upcase == 'SYNC_PACKET_COUNT_DELAY_SECONDS'
-          @sync_packet_count_delay_seconds = option_values[0].to_f
+          TargetModel.sync_packet_count_delay_seconds = option_values[0].to_f
         end
       end
 
@@ -773,7 +758,7 @@ module OpenC3
 
       # Write to stream
       if @interface.tlm_target_enabled[packet.target_name]
-        sync_tlm_packet_counts(packet)
+        TargetModel.sync_tlm_packet_counts(packet, @interface.tlm_target_names, scope: @scope)
         TelemetryTopic.write_packet(packet, queued: @queued, scope: @scope)
       end
     end
@@ -908,59 +893,6 @@ module OpenC3
     def graceful_kill
       # Just to avoid warning
     end
-
-    def sync_tlm_packet_counts(packet)
-      if @sync_packet_count_delay_seconds <= 0 or $openc3_redis_cluster
-        # Perfect but slow method
-        packet.received_count = TargetModel.increment_telemetry_count(packet.target_name, packet.packet_name, 1, scope: @scope)
-      else
-        # Eventually consistent method
-        # Only sync every period (default 1 second) to avoid hammering Redis
-        # This is a trade off between speed and accuracy
-        # The packet count is eventually consistent
-        @sync_packet_count_data[packet.target_name] ||= {}
-        @sync_packet_count_data[packet.target_name][packet.packet_name] ||= 0
-        @sync_packet_count_data[packet.target_name][packet.packet_name] += 1
-
-        # Ensures counters change between syncs
-        packet.received_count += 1
-
-        # Check if we need to sync the packet counts
-        if @sync_packet_count_time.nil? or (Time.now - @sync_packet_count_time) > @sync_packet_count_delay_seconds
-          @sync_packet_count_time = Time.now
-
-          inc_count = 0
-          # Use pipeline to make this one transaction
-          result = Store.redis_pool.pipelined do
-            # Increment global counters for packets received
-            @sync_packet_count_data.each do |target_name, packet_data|
-              packet_data.each do |packet_name, count|
-                TargetModel.increment_telemetry_count(target_name, packet_name, count, scope: @scope)
-                inc_count += 1
-              end
-            end
-            @sync_packet_count_data = {}
-
-            # Get all the packet counts with the global counters
-            @interface.tlm_target_names.each do |target_name|
-              TargetModel.get_all_telemetry_counts(target_name, scope: @scope)
-            end
-            TargetModel.get_all_telemetry_counts('UNKNOWN', scope: @scope)
-          end
-          @interface.tlm_target_names.each do |target_name|
-            result[inc_count].each do |packet_name, count|
-              update_packet = System.telemetry.packet(target_name, packet_name)
-              update_packet.received_count = count.to_i
-            end
-            inc_count += 1
-          end
-          result[inc_count].each do |packet_name, count|
-            update_packet = System.telemetry.packet('UNKNOWN', packet_name)
-            update_packet.received_count = count.to_i
-          end
-        end
-      end
-    end
   end
 end