openc3 5.17.0 → 5.18.0

data/lib/openc3/api/tlm_api.rb

@@ -69,27 +69,27 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     # @return [Object] The telemetry value formatted as requested
-    def tlm(*args, type: :CONVERTED, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
+    def tlm(*args, type: :CONVERTED, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'tlm', cache_timeout: cache_timeout, scope: scope)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       CvtModel.get_item(target_name, packet_name, item_name, type: type.intern, cache_timeout: cache_timeout, scope: scope)
     end
 
-    def tlm_raw(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args, type: :RAW, cache_timeout: cache_timeout, scope: scope, token: token)
+    def tlm_raw(*args, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args, type: :RAW, cache_timeout: cache_timeout, manual: manual, scope: scope, token: token)
     end
 
-    def tlm_formatted(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args, type: :FORMATTED, cache_timeout: cache_timeout, scope: scope, token: token)
+    def tlm_formatted(*args, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args, type: :FORMATTED, cache_timeout: cache_timeout, manual: manual, scope: scope, token: token)
     end
 
-    def tlm_with_units(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args, type: :WITH_UNITS, cache_timeout: cache_timeout, scope: scope, token: token)
+    def tlm_with_units(*args, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args, type: :WITH_UNITS, cache_timeout: cache_timeout, manual: manual, scope: scope, token: token)
     end
 
     # @deprecated Use tlm with type:
-    def tlm_variable(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args[0..-2], type: args[-1].intern, cache_timeout: cache_timeout, scope: scope, token: token)
+    def tlm_variable(*args, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args[0..-2], type: args[-1].intern, cache_timeout: cache_timeout, manual: manual, scope: scope, token: token)
     end
 
     # Set a telemetry item in the current value table.
@@ -107,9 +107,9 @@ module OpenC3
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
-    def set_tlm(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+    def set_tlm(*args, type: :CONVERTED, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name, value = _set_tlm_process_args(args, __method__, scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       CvtModel.set_item(target_name, packet_name, item_name, value, type: type.intern, scope: scope)
     end
 
@@ -119,8 +119,8 @@ module OpenC3
     # @param packet_name [String] Packet name of the packet
     # @param item_hash [Hash] Hash of item_name and value for each item you want to change from the current value table
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
-    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       type = type.to_s.intern
       target_name = target_name.upcase
       packet_name = packet_name.upcase
@@ -168,15 +168,15 @@ module OpenC3
     #   three strings followed by a value (see the calling style in the
     #   description).
     # @param type [Symbol] Telemetry type, :ALL (default), :RAW, :CONVERTED, :FORMATTED, :WITH_UNITS
-    def override_tlm(*args, type: :ALL, scope: $openc3_scope, token: $openc3_token)
+    def override_tlm(*args, type: :ALL, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name, value = _set_tlm_process_args(args, __method__, scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       CvtModel.override(target_name, packet_name, item_name, value, type: type.intern, scope: scope)
     end
 
     # Get the list of CVT overrides
-    def get_overrides(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_overrides(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       CvtModel.overrides(scope: scope)
     end
 
@@ -193,9 +193,9 @@ module OpenC3
     #   (see the calling style in the description).
     # @param type [Symbol] Telemetry type, :ALL (default), :RAW, :CONVERTED, :FORMATTED, :WITH_UNITS
     #   Also takes :ALL which means to normalize all telemetry types
-    def normalize_tlm(*args, type: :ALL, scope: $openc3_scope, token: $openc3_token)
+    def normalize_tlm(*args, type: :ALL, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, __method__, scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       CvtModel.normalize(target_name, packet_name, item_name, type: type.intern, scope: scope)
     end
 
@@ -204,9 +204,9 @@ 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, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_buffer(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_tlm_buffer', *args)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      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)
@@ -226,9 +226,9 @@ module OpenC3
     # @return [Array<String, Object, Symbol|nil>] Returns an Array consisting
     #   of [item name, item value, item limits state] where the item limits
     #   state can be one of {OpenC3::Limits::LIMITS_STATES}
-    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_tlm_packet', *args)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       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?
@@ -248,7 +248,7 @@ module OpenC3
     # @return [Array<Object, Symbol>]
     #   Array consisting of the item value and limits state
     #   given as symbols such as :RED, :YELLOW, :STALE
-    def get_tlm_values(items, stale_time: 30, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_values(items, stale_time: 30, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
       if !items.is_a?(Array) || !items[0].is_a?(String)
         raise ArgumentError, "items must be array of strings: ['TGT__PKT__ITEM__TYPE', ...]"
       end
@@ -265,7 +265,7 @@ module OpenC3
       end
       packets.uniq!
       packets.each do |target_name, packet_name|
-        authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+        authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       end
       CvtModel.get_tlm_values(cvt_items, stale_time: stale_time, cache_timeout: cache_timeout, scope: scope)
     end
@@ -275,9 +275,9 @@ module OpenC3
     # @since 5.0.0
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all telemetry packet hashes
-    def get_all_tlm(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_tlm(target_name, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
-      authorize(permission: 'tlm', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'tlm', target_name: target_name, manual: manual, scope: scope, token: token)
       TargetModel.packets(target_name, type: :TLM, scope: scope)
     end
     alias get_all_telemetry get_all_tlm
@@ -287,9 +287,9 @@ module OpenC3
     # @since 5.0.6
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all telemetry packet names
-    def get_all_tlm_names(target_name, hidden: false, scope: $openc3_scope, token: $openc3_token)
+    def get_all_tlm_names(target_name, hidden: false, manual: false, scope: $openc3_scope, token: $openc3_token)
       begin
-        packets = get_all_tlm(target_name, scope: scope, token: token)
+        packets = get_all_tlm(target_name, manual: manual, scope: scope, token: token)
       rescue RuntimeError
         packets = []
       end
@@ -311,9 +311,9 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @param packet_name [String] Name of the packet
     # @return [Hash] Telemetry packet hash
-    def get_tlm(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_tlm', *args)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      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)
     end
     alias get_telemetry get_tlm
@@ -325,9 +325,9 @@ 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, scope: $openc3_scope, token: $openc3_token)
+    def get_item(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _extract_target_packet_item_names('get_item', *args)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      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
 
@@ -339,7 +339,7 @@ module OpenC3
     #
     # @param packets [Array<Array<String, String>>] Array of arrays consisting of target name, packet name
     # @return [String] ID which should be passed to get_packets
-    def subscribe_packets(packets, scope: $openc3_scope, token: $openc3_token)
+    def subscribe_packets(packets, manual: false, scope: $openc3_scope, token: $openc3_token)
       if !packets.is_a?(Array) || !packets[0].is_a?(Array)
         raise ArgumentError, "packets must be nested array: [['TGT','PKT'],...]"
       end
@@ -348,7 +348,7 @@ module OpenC3
       packets.each do |target_name, packet_name|
         target_name = target_name.upcase
         packet_name = packet_name.upcase
-        authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+        authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
         topic = "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
         id, _ = Topic.get_newest_message(topic)
         result[topic] = id ? id : '0-0'
@@ -363,8 +363,8 @@ module OpenC3
     # @param block [Integer] Unused - Blocking must be implemented at the client
     # @param count [Integer] Maximum number of packets to return from EACH packet stream
     # @return [Array<String, Array<Hash>] Array of the ID and array of all packets found
-    def get_packets(id, block: nil, count: 1000, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_packets(id, block: nil, count: 1000, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       # Split the list of topic, ID values and turn it into a hash for easy updates
       lookup = Hash[*id.split(SUBSCRIPTION_DELIMITER)]
       xread = Topic.read_topics(lookup.keys, lookup.values, nil, count) # Always don't block
@@ -387,9 +387,9 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @param packet_name [String] Name of the packet
     # @return [Numeric] Receive count for the telemetry packet
-    def get_tlm_cnt(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_cnt(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_tlm_cnt', *args)
-      authorize(permission: 'system', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'system', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
       Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
     end
@@ -398,8 +398,8 @@ module OpenC3
     #
     # @param target_packets [Array<Array<String, String>>] Array of arrays containing target_name, packet_name
     # @return [Array<Numeric>] Receive count for the telemetry packets
-    def get_tlm_cnts(target_packets, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_tlm_cnts(target_packets, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       counts = []
       target_packets.each do |target_name, packet_name|
         target_name = target_name.upcase
@@ -414,9 +414,9 @@ module OpenC3
     # @param target_name [String] Target name
     # @param packet_name [String] Packet name
     # @return [Array<String>] All of the ignored telemetry items for a packet.
-    def get_packet_derived_items(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_packet_derived_items(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_packet_derived_items', *args)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       return packet['items'].select { |item| item['data_type'] == 'DERIVED' }.map { |item| item['name'] }
     end

data/lib/openc3/conversions/bit_reverse_conversion.rb

@@ -0,0 +1,60 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 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/conversions/conversion'
+
+module OpenC3
+  class BitReverseConversion < Conversion
+    def initialize(converted_type, converted_bit_size)
+      super()
+      @converted_type = converted_type.to_s.upcase.intern
+      @converted_bit_size = converted_bit_size.to_i
+      if @converted_type == :FLOAT
+        raise "Float Bit Reverse Not Yet Supported"
+      end
+    end
+
+    # Perform the conversion on the value.
+    #
+    # @param value [Object] The value to convert
+    # @param packet [Packet] The packet which contains the value. This can
+    #   be useful to reach into the packet and use other values in the
+    #   conversion.
+    # @param buffer [String] The packet buffer
+    # @return The converted value
+    def call(value, _packet, _buffer)
+      reversed = 0
+      @converted_bit_size.times do
+        reversed = (reversed << 1) | (value & 1)
+        value >>= 1
+      end
+      return reversed & ((2 ** @converted_bit_size) - 1)
+    end
+
+    # @return [String] The conversion class
+    def to_s
+      "#{self.class.to_s.split('::')[-1]}.new(:#{@converted_type}, #{@converted_bit_size})"
+    end
+
+    # @param read_or_write [String] Either 'READ' or 'WRITE'
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      "    #{read_or_write}_CONVERSION #{self.class.name.class_name_to_filename} #{@converted_type} #{@converted_bit_size}\n"
+    end
+  end
+end

data/lib/openc3/conversions/ip_read_conversion.rb

@@ -0,0 +1,59 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 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/conversions/conversion'
+
+module OpenC3
+  class IpReadConversion < Conversion
+    def initialize
+      @converted_type = :STRING
+      @converted_bit_size = 120
+      @converted_array_size = nil
+    end
+
+    # Perform the conversion on the value.
+    #
+    # @param value [Object] The value to convert
+    # @param packet [Packet] The packet which contains the value. This can
+    #   be useful to reach into the packet and use other values in the
+    #   conversion.
+    # @param buffer [String] The packet buffer
+    # @return The converted value
+    def call(value, _packet, _buffer)
+      byte4 = (value & 0xFF)
+      value = value >> 8
+      byte3 = (value & 0xFF)
+      value = value >> 8
+      byte2 = (value & 0xFF)
+      value = value >> 8
+      byte1 = (value & 0xFF)
+      return "#{byte1}.#{byte2}.#{byte3}.#{byte4}"
+    end
+
+    # @return [String] The conversion class
+    def to_s
+      "#{self.class.to_s.split('::')[-1]}.new"
+    end
+
+    # @param read_or_write [String] Either 'READ' or 'WRITE'
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      "    #{read_or_write}_CONVERSION #{self.class.name.class_name_to_filename}\n"
+    end
+  end
+end

data/lib/openc3/conversions/ip_write_conversion.rb

@@ -0,0 +1,61 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 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/conversions/conversion'
+
+module OpenC3
+  class IpWriteConversion < Conversion
+    def initialize
+      @converted_type = :UINT
+      @converted_bit_size = 32
+      @converted_array_size = nil
+    end
+
+    # Perform the conversion on the value.
+    #
+    # @param value [Object] The value to convert
+    # @param packet [Packet] The packet which contains the value. This can
+    #   be useful to reach into the packet and use other values in the
+    #   conversion.
+    # @param buffer [String] The packet buffer
+    # @return The converted value
+    def call(value, _packet, _buffer)
+      bytes = value.split('.')
+      result = 0
+      result += Integer(bytes[0])
+      result = result << 8
+      result += Integer(bytes[1])
+      result = result << 8
+      result += Integer(bytes[2])
+      result = result << 8
+      result += Integer(bytes[3])
+      return result
+    end
+
+    # @return [String] The conversion class
+    def to_s
+      "#{self.class.to_s.split('::')[-1]}.new"
+    end
+
+    # @param read_or_write [String] Either 'READ' or 'WRITE'
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      "    #{read_or_write}_CONVERSION #{self.class.name.class_name_to_filename}\n"
+    end
+  end
+end

data/lib/openc3/conversions/object_read_conversion.rb

@@ -0,0 +1,88 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 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/config/config_parser'
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  class ObjectReadConversion < Conversion
+    def initialize(cmd_or_tlm, target_name, packet_name)
+      super()
+      cmd_or_tlm = ConfigParser.handle_nil(cmd_or_tlm)
+      if cmd_or_tlm
+        @cmd_or_tlm = cmd_or_tlm.to_s.upcase.intern
+        raise ArgumentError, "Unknown type: #{cmd_or_tlm}" unless %i(CMD TLM COMMAND TELEMETRY).include?(@cmd_or_tlm)
+      else
+        # Unknown - Will need to search
+        @cmd_or_tlm = nil
+      end
+      @target_name = target_name.to_s.upcase
+      @packet_name = packet_name.to_s.upcase
+      @converted_type = :OBJECT
+      @converted_bit_size = 0
+    end
+
+    def lookup_packet
+      if @cmd_or_tlm
+        if @cmd_or_tlm == :CMD or @cmd_or_tlm == :COMMAND
+          return System.commands.packet(@target_name, @packet_name)
+        else
+          return System.telemetry.packet(@target_name, @packet_name)
+        end
+      else
+        # Always searches commands first
+        begin
+          return System.commands.packet(@target_name, @packet_name)
+        rescue
+          return System.telemetry.packet(@target_name, @packet_name)
+        end
+      end
+    end
+
+    # Perform the conversion on the value.
+    #
+    # @param value [String] The BLOCK data to make into a packet
+    # @param packet [Packet] Unused
+    # @param buffer [String] The packet buffer
+    # @return The converted value
+    def call(value, _packet, buffer)
+      fill_packet = lookup_packet()
+      fill_packet.buffer = value
+      return fill_packet.read_all(:CONVERTED, buffer, true).to_h
+    end
+
+    # @return [String] The conversion class
+    def to_s
+      "#{self.class.to_s.split('::')[-1]} #{@cmd_or_tlm ? @cmd_or_tlm : "nil"} #{@target_name} #{@packet_name}"
+    end
+
+    # @param read_or_write [String] Not used
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      "    #{read_or_write}_CONVERSION #{self.class.name.class_name_to_filename} #{@cmd_or_tlm ? @cmd_or_tlm : "nil"} #{@target_name} #{@packet_name}\n"
+    end
+
+    def as_json(*a)
+      result = super(*a)
+      result['cmd_or_tlm'] = @cmd_or_tlm
+      result['target_name'] = @target_name
+      result['packet_name'] = @packet_name
+      return result
+    end
+  end
+end

data/lib/openc3/conversions/object_write_conversion.rb

@@ -0,0 +1,38 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 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/conversions/object_read_conversion'
+
+module OpenC3
+  class ObjectWriteConversion < ObjectReadConversion
+    # Perform the conversion on the value.
+    #
+    # @param value [Object] Hash of packet key/value pairs
+    # @param packet [Packet] Unused
+    # @param buffer [String] The packet buffer
+    # @return Raw BLOCK data
+    def call(value, _packet, buffer)
+      fill_packet = lookup_packet()
+      fill_packet.restore_defaults()
+      value.each do |key, write_value|
+        fill_packet.write(key, write_value)
+      end
+      return fill_packet.buffer
+    end
+  end
+end

data/lib/openc3/conversions.rb

@@ -17,12 +17,17 @@
 # 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.
 
 module OpenC3
   autoload(:Conversion, 'openc3/conversions/conversion.rb')
+  autoload(:BitReverseConversion, 'openc3/conversions/bit_reverse_conversion.rb')
   autoload(:GenericConversion, 'openc3/conversions/generic_conversion.rb')
+  autoload(:IpReadConversion, 'openc3/conversions/ip_read_conversion.rb')
+  autoload(:IpWriteConversion, 'openc3/conversions/ip_write_conversion.rb')
+  autoload(:ObjectReadConversion, 'openc3/conversions/object_read_conversion.rb')
+  autoload(:ObjectWriteConversion, 'openc3/conversions/object_write_conversion.rb')
   autoload(:PacketTimeFormattedConversion, 'openc3/conversions/packet_time_formatted_conversion.rb')
   autoload(:PacketTimeSecondsConversion, 'openc3/conversions/packet_time_seconds_conversion.rb')
   autoload(:PolynomialConversion, 'openc3/conversions/polynomial_conversion.rb')