openc3 5.12.0 → 5.14.0

data/lib/openc3/accessors/template_accessor.rb

@@ -0,0 +1,150 @@
+# 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/accessors/accessor'
+
+module OpenC3
+  class TemplateAccessor < Accessor
+    def initialize(packet, left_char = '<', right_char = '>')
+      super(packet)
+      @left_char = left_char
+      @right_char = right_char
+      @configured = false
+    end
+
+    def configure
+      return if @configured
+
+      escaped_left_char = @left_char
+      escaped_left_char = "\\#{@left_char}" if @left_char == '('
+      escaped_right_char = @right_char
+      escaped_right_char = "\\#{@right_char}" if @right_char == ')'
+
+      # Convert the template into a Regexp for reading each item
+      template = @packet.template.dup
+      template_items = template.scan(Regexp.new("#{escaped_left_char}.*?#{escaped_right_char}"))
+      escaped_read_template = template
+      if @left_char != '('
+        escaped_read_template = escaped_read_template.gsub('(', '\(')
+      end
+      if @right_char != ')'
+        escaped_read_template = escaped_read_template.gsub(')', '\)')
+      end
+
+      @item_keys = []
+      template_items.each do |item|
+        @item_keys << item[1..-2]
+        escaped_read_template.gsub!(item, "(.*)")
+      end
+      @read_regexp = Regexp.new(escaped_read_template)
+
+      @configured = true
+    end
+
+    def read_item(item, buffer)
+      return nil if item.data_type == :DERIVED
+      configure()
+
+      # Scan the response for all the variables in brackets <VARIABLE>
+      values = buffer.scan(@read_regexp)[0]
+      if !values || (values.length != @item_keys.length)
+        raise "Unexpected number of items found in buffer: #{values ? values.length : 0}, Expected: #{@item_keys.length}"
+      else
+        values.each_with_index do |value, i|
+          item_key = @item_keys[i]
+          if item_key == item.key
+            return Accessor.convert_to_type(value, item)
+          end
+        end
+      end
+
+      raise "Response does not include key #{item.key}: #{buffer}"
+    end
+
+    def read_items(items, buffer)
+      result = {}
+      configure()
+
+      # Scan the response for all the variables in brackets <VARIABLE>
+      values = buffer.scan(@read_regexp)[0]
+      if !values || (values.length != @item_keys.length)
+        raise "Unexpected number of items found in buffer: #{values ? values.length : 0}, Expected: #{@item_keys.length}"
+      else
+        items.each do |item|
+          if item.data_type == :DERIVED
+            result[item.name] = nil
+            next
+          end
+          index = @item_keys.index(item.key)
+          if index
+            result[item.name] = Accessor.convert_to_type(values[index], item)
+          else
+            raise "Unknown item with key #{item.key} requested"
+          end
+        end
+      end
+
+      return result
+    end
+
+    def write_item(item, value, buffer)
+      return nil if item.data_type == :DERIVED
+      configure()
+
+      success = buffer.gsub!("#{@left_char}#{item.key}#{@right_char}", value.to_s)
+      raise "Key #{item.key} not found in template" unless success
+      return value
+    end
+
+    def write_items(items, values, buffer)
+      configure()
+      items.each_with_index do |item, index|
+        next if item.data_type == :DERIVED
+        success = buffer.gsub!("#{@left_char}#{item.key}#{@right_char}", values[index].to_s)
+        raise "Key #{item.key} not found in template" unless success
+      end
+      return values
+    end
+
+    # If this is set it will enforce that buffer data is encoded
+    # in a specific encoding
+    def enforce_encoding
+      return nil
+    end
+
+    # This affects whether the Packet class enforces the buffer
+    # length at all.  Set to false to remove any correlation between
+    # buffer length and defined sizes of items in COSMOS
+    def enforce_length
+      return false
+    end
+
+    # This sets the short_buffer_allowed flag in the Packet class
+    # which allows packets that have a buffer shorter than the defined size.
+    # Note that the buffer is still resized to the defined length
+    def enforce_short_buffer_allowed
+      return true
+    end
+
+    # If this is true it will enfore that COSMOS DERIVED items must have a
+    # write_conversion to be written
+    def enforce_derived_write_conversion(_item)
+      return true
+    end
+  end
+end

data/lib/openc3/accessors/xml_accessor.rb

@@ -68,19 +68,29 @@ module OpenC3
       doc.to_xml
     end
 
+    # If this is set it will enforce that buffer data is encoded
+    # in a specific encoding
     def enforce_encoding
       return nil
     end
 
+    # This affects whether the Packet class enforces the buffer
+    # length at all.  Set to false to remove any correlation between
+    # buffer length and defined sizes of items in COSMOS
     def enforce_length
       return false
     end
 
+    # This sets the short_buffer_allowed flag in the Packet class
+    # which allows packets that have a buffer shorter than the defined size.
+    # Note that the buffer is still resized to the defined length
     def enforce_short_buffer_allowed
       return true
     end
 
-    def enforce_derived_write_conversion(item)
+    # If this is true it will enfore that COSMOS DERIVED items must have a
+    # write_conversion to be written
+    def enforce_derived_write_conversion(_item)
       return true
     end
   end

data/lib/openc3/accessors.rb

@@ -25,4 +25,5 @@ module OpenC3
   autoload(:HttpAccessor, 'openc3/accessors/http_accessor.rb')
   autoload(:JsonAccessor, 'openc3/accessors/json_accessor.rb')
   autoload(:XmlAccessor, 'openc3/accessors/xml_accessor.rb')
+  autoload(:TemplateAccessor, 'openc3/accessors/template_accessor.rb')
 end

data/lib/openc3/api/cmd_api.rb

@@ -39,12 +39,17 @@ module OpenC3
                        'cmd_raw_no_range_check',
                        'cmd_raw_no_hazardous_check',
                        'cmd_raw_no_checks',
-                       'build_command',
+                       'build_cmd',
+                       'build_command', # DEPRECATED
                        'send_raw',
-                       'get_all_commands',
-                       'get_all_command_names',
-                       'get_command',
-                       'get_parameter',
+                       'get_all_cmds',
+                       'get_all_commands', # DEPRECATED
+                       'get_all_cmd_names',
+                       'get_all_command_names', # DEPRECATED
+                       'get_cmd',
+                       'get_command', # DEPRECATED
+                       'get_param',
+                       'get_parameter', # DEPRECATED
                        'get_cmd_buffer',
                        'get_cmd_hazardous',
                        'get_cmd_value',
@@ -100,7 +105,7 @@ module OpenC3
     # Build a command binary
     #
     # @since 5.8.0
-    def build_command(*args, range_check: true, raw: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def build_cmd(*args, range_check: true, raw: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
@@ -123,6 +128,8 @@ module OpenC3
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       DecomInterfaceTopic.build_cmd(target_name, cmd_name, cmd_params, range_check, raw, scope: scope)
     end
+    # build_command is DEPRECATED
+    alias build_command build_cmd
 
     # Send a raw binary string to the specified interface.
     #
@@ -140,9 +147,8 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Hash] command hash with last command buffer
-    def get_cmd_buffer(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
+    def get_cmd_buffer(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name = _extract_target_command_names('get_cmd_buffer', *args)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
@@ -159,35 +165,38 @@ module OpenC3
     # @since 5.0.0
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all commands as a hash
-    def get_all_commands(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmds(target_name, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packets(target_name, type: :CMD, scope: scope)
     end
+    # get_all_commands is DEPRECATED
+    alias get_all_commands get_all_cmds
 
     # Returns an array of all the command packet names
     #
     # @since 5.0.6
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all command packet names
-    def get_all_command_names(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmd_names(target_name, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet_names(target_name, type: :CMD, scope: scope)
     end
+    # get_all_command_names is DEPRECATED
+    alias get_all_command_names get_all_cmd_names
 
     # Returns a hash of the given command
     #
     # @since 5.0.0
-    # @param target_name [String] Name of the target
-    # @param command_name [String] Name of the packet
     # @return [Hash] Command as a hash
-    def get_command(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
+    def get_cmd(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name = _extract_target_command_names('get_cmd', *args)
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
     end
+    # get_command is DEPRECATED
+    alias get_command get_cmd
 
     # Returns a hash of the given command parameter
     #
@@ -196,13 +205,13 @@ module OpenC3
     # @param command_name [String] Name of the packet
     # @param parameter_name [String] Name of the parameter
     # @return [Hash] Command parameter as a hash
-    def get_parameter(target_name, command_name, parameter_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
-      parameter_name = parameter_name.upcase
+    def get_param(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name, parameter_name = _extract_target_command_parameter_names('get_param', *args)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet_item(target_name, command_name, parameter_name, type: :CMD, scope: scope)
     end
+    # get_parameter is DEPRECATED
+    alias get_parameter get_param
 
     # Returns whether the specified command is hazardous
     #
@@ -257,19 +266,35 @@ module OpenC3
     end
 
     # Returns a value from the specified command
-    #
-    # @param target_name [String] Target name of the command
-    # @param command_name [String] Packet name of the command
-    # @param parameter_name [String] Parameter name in the command
-    # @param value_type [Symbol] How the values should be converted. Must be
-    #   one of {Packet::VALUE_TYPES}
-    # @return [Varies] value
-    def get_cmd_value(target_name, command_name, parameter_name, value_type = :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
-      parameter_name = parameter_name.upcase
+    # Supports the following call syntax:
+    #   get_cmd_value("TGT PKT ITEM", type: :RAW)
+    #   get_cmd_value("TGT", "PKT", "ITEM", type: :RAW)
+    #   get_cmd_value("TGT", "PKT", "ITEM", :RAW) # DEPRECATED
+    def get_cmd_value(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+      target_name = nil
+      command_name = nil
+      parameter_name = nil
+      case args.length
+      when 1
+        target_name, command_name, parameter_name = args[0].upcase.split
+      when 3
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+        parameter_name = args[2].upcase
+      when 4
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+        parameter_name = args[2].upcase
+        type = args[3].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to get_cmd_value()"
+      end
+      if target_name.nil? or command_name.nil? or parameter_name.nil?
+        raise "ERROR: Target name, command name and parameter name required. Usage: get_cmd_value(\"TGT CMD PARAM\") or #{method_name}(\"TGT\", \"CMD\", \"PARAM\")"
+      end
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
-      CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: value_type, scope: scope)
+      CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: type, scope: scope)
     end
 
     # Returns the time the most recent command was sent
@@ -317,9 +342,8 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Numeric] Transmit count for the command
-    def get_cmd_cnt(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
+    def get_cmd_cnt(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name = _extract_target_command_names('get_cmd_cnt', *args)
       authorize(permission: 'system', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
@@ -347,6 +371,46 @@ module OpenC3
     # PRIVATE implementation details
     ###########################################################################
 
+    def _extract_target_command_names(method_name, *args)
+      target_name = nil
+      command_name = nil
+      case args.length
+      when 1
+        target_name, command_name = args[0].upcase.split
+      when 2
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
+      end
+      if target_name.nil? or command_name.nil?
+        raise "ERROR: Target name and command name required. Usage: #{method_name}(\"TGT CMD\") or #{method_name}(\"TGT\", \"CMD\")"
+      end
+      return [target_name, command_name]
+    end
+
+    def _extract_target_command_parameter_names(method_name, *args)
+      target_name = nil
+      command_name = nil
+      parameter_name = nil
+      case args.length
+      when 1
+        target_name, command_name, parameter_name = args[0].upcase.split
+      when 3
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+        parameter_name = args[2].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
+      end
+      if target_name.nil? or command_name.nil? or parameter_name.nil?
+        raise "ERROR: Target name, command name and parameter name required. Usage: #{method_name}(\"TGT CMD PARAM\") or #{method_name}(\"TGT\", \"CMD\", \"PARAM\")"
+      end
+      return [target_name, command_name, parameter_name]
+    end
+
     def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil,
                            scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)

data/lib/openc3/api/limits_api.rb

@@ -190,10 +190,10 @@ module OpenC3
     #               'TVAC' => [-25, -10, 50, 55] }
     #
     # @return [Hash{String => Array<Number, Number, Number, Number, Number, Number>}]
-    def get_limits(target_name, packet_name, item_name, scope: $openc3_scope, token: $openc3_token)
+    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       limits = {}
-      item = _get_item(target_name, packet_name, item_name, scope: scope)
+      item = _get_item(target_name, packet_name, item_name, cache_timeout: cache_timeout, scope: scope)
       item['limits'].each do |key, vals|
         next unless vals.is_a?(Hash)
 
@@ -374,7 +374,7 @@ module OpenC3
     # @param item_name [String] item name
     # @param scope [String] scope
     # @return Hash The requested item based on the packet name
-    def _get_item(target_name, packet_name, item_name, cache_timeout: 0.1, scope:)
+    def _get_item(target_name, packet_name, item_name, cache_timeout: nil, scope:)
       # Determine if this item exists, it will raise appropriate errors if not
       packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: $openc3_scope) if packet_name == 'LATEST'
       return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)

data/lib/openc3/api/tlm_api.rb

@@ -44,9 +44,12 @@ module OpenC3
                        'get_tlm_buffer',
                        'get_tlm_packet',
                        'get_tlm_values',
-                       'get_all_telemetry',
-                       'get_all_telemetry_names',
-                       'get_telemetry',
+                       'get_all_tlm',
+                       'get_all_telemetry', # DEPRECATED
+                       'get_all_tlm_names',
+                       'get_all_telemetry_names', # DEPRECATED
+                       'get_tlm',
+                       'get_telemetry', # DEPRECATED
                        'get_item',
                        'subscribe_packets',
                        'get_packets',
@@ -66,26 +69,26 @@ 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: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm(*args, type: :CONVERTED, cache_timeout: nil, 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)
       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: 0.1, scope: $openc3_scope, token: $openc3_token)
+    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)
     end
 
-    def tlm_formatted(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    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)
     end
 
-    def tlm_with_units(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    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)
     end
 
     # @deprecated Use tlm with type:
-    def tlm_variable(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    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)
     end
 
@@ -201,9 +204,8 @@ 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(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      packet_name = packet_name.upcase
+    def get_tlm_buffer(*args, 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)
       TargetModel.packet(target_name, packet_name, scope: scope)
       topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
@@ -224,9 +226,8 @@ 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(target_name, packet_name, stale_time: 30, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      packet_name = packet_name.upcase
+    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: nil, 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)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       t = _validate_tlm_type(type)
@@ -247,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: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_values(items, stale_time: 30, cache_timeout: nil, 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
@@ -274,22 +275,24 @@ 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_telemetry(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_tlm(target_name, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       authorize(permission: 'tlm', target_name: target_name, scope: scope, token: token)
       TargetModel.packets(target_name, type: :TLM, scope: scope)
     end
+    alias get_all_telemetry get_all_tlm
 
     # Returns an array of all the telemetry packet names
     #
     # @since 5.0.6
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all telemetry packet names
-    def get_all_telemetry_names(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_tlm_names(target_name, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet_names(target_name, type: :TLM, scope: scope)
     end
+    alias get_all_telemetry_names get_all_tlm_names
 
     # Returns a telemetry packet hash
     #
@@ -297,12 +300,12 @@ 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_telemetry(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      packet_name = packet_name.upcase
+    def get_tlm(*args, 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)
       TargetModel.packet(target_name, packet_name, scope: scope)
     end
+    alias get_telemetry get_tlm
 
     # Returns a telemetry packet item hash
     #
@@ -311,10 +314,8 @@ 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(target_name, packet_name, item_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      packet_name = packet_name.upcase
-      item_name = item_name.upcase
+    def get_item(*args, 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)
       TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
     end
@@ -375,9 +376,8 @@ 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(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      packet_name = packet_name.upcase
+    def get_tlm_cnt(*args, 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)
       TargetModel.packet(target_name, packet_name, scope: scope)
       Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
@@ -403,9 +403,8 @@ 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(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      packet_name = packet_name.upcase
+    def get_packet_derived_items(*args, 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)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       return packet['items'].select { |item| item['data_type'] == 'DERIVED' }.map { |item| item['name'] }
@@ -413,6 +412,46 @@ module OpenC3
 
     # PRIVATE
 
+    def _extract_target_packet_names(method_name, *args)
+      target_name = nil
+      packet_name = nil
+      case args.length
+      when 1
+        target_name, packet_name = args[0].upcase.split
+      when 2
+        target_name = args[0].upcase
+        packet_name = args[1].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
+      end
+      if target_name.nil? or packet_name.nil?
+        raise "ERROR: Both target name and packet name required. Usage: #{method_name}(\"TGT PKT\") or #{method_name}(\"TGT\", \"PKT\")"
+      end
+      return [target_name, packet_name]
+    end
+
+    def _extract_target_packet_item_names(method_name, *args)
+      target_name = nil
+      packet_name = nil
+      item_name = nil
+      case args.length
+      when 1
+        target_name, packet_name, item_name = args[0].upcase.split
+      when 3
+        target_name = args[0].upcase
+        packet_name = args[1].upcase
+        item_name = args[2].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
+      end
+      if target_name.nil? or packet_name.nil? or item_name.nil?
+        raise "ERROR: Target name, packet name, and item name are required. Usage: #{method_name}(\"TGT PKT ITEM\") or #{method_name}(\"TGT\", \"PKT\", \"ITEM\")"
+      end
+      return [target_name, packet_name, item_name]
+    end
+
     def _validate_tlm_type(type)
       case type.intern
       when :RAW
@@ -427,7 +466,7 @@ module OpenC3
       return nil
     end
 
-    def _tlm_process_args(args, method_name, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def _tlm_process_args(args, method_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       case args.length
       when 1
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])