openc3 5.4.3.pre.beta0 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 859879129f5646a4e8fd10a916e1e88859a7b5ed178fe2983f42df4e7e8c1a52
-  data.tar.gz: 745a188c5e9277e0bb793207f383f85d6ec6d571d41d6115530f6f78bd671817
+  metadata.gz: 0a21cdfc706de17b576884e2d65593ed329ce736d12384ce0ab1880b3d5d7986
+  data.tar.gz: a1927adc509a3087157cfc5b35737f01796c7fe54a711dd7e750a56de14d7b17
 SHA512:
-  metadata.gz: '0582ba269983955ae39c8d0c941666d2fcc65811416e3c1ae7026811fa00d9699ecffc09e195909f30cac3c8571f6b83889349fed9c96ec89c95091aff088a61'
-  data.tar.gz: a9c9c554d6595cd7718dc58b1e2e07e0ff9a440cd6545674b47250a3542164a41d27bad1bf237c8c121f170dd04380eeaa125769abc9423c0de2e610578f9799
+  metadata.gz: 0dc0c6851d30a29b647ae243b7cb6bfcf641c8cea7a86b41277c677a02f60ce9558f5bb1d37255eb358e99d4670c67e5fa9fecbe422055b061df10ee167591fb
+  data.tar.gz: ed5c29f6c49930381ed2985e22736ec5ee2037774c60ec50d27e25afddd6ab90224d1012ff57ffa109402abe489abeafa78faf63e9111e65fa7689ec65222b3f

data/bin/openc3cli

@@ -26,6 +26,7 @@
 require 'openc3'
 require 'openc3/utilities/local_mode'
 require 'openc3/utilities/bucket'
+require 'openc3/utilities/cli_generator'
 require 'openc3/models/scope_model'
 require 'openc3/models/plugin_model'
 require 'openc3/models/gem_model'
@@ -42,20 +43,17 @@ require 'json'
 require 'redis'
 require 'erb'
 require 'pp'
-# require 'psych' # Psych code is commented out
 require "irb"
 require "irb/completion"
 
 $redis_url = "redis://#{ENV['OPENC3_REDIS_HOSTNAME']}:#{ENV['OPENC3_REDIS_PORT']}"
-# Initialize the connection to the bucket library
-OpenC3::Bucket.getClient()
 
 # Build the OpenStruct and OptionParser here as constants so we can use in methods
 MIGRATE_OPTIONS = OpenStruct.new
 MIGRATE_OPTIONS.all = false
 MIGRATE_PARSER = OptionParser.new do |op|
-  op.banner = "cli migrate PLUGIN [TGT1...] # Create a OpenC3 plugin from existing COSMOS 4 targets"
-  op.on("-a", "--all", "    Move all COSMOS 4 targets into a single OpenC3 plugin") do
+  op.banner = "cli migrate PLUGIN [TGT1...]      # Create a OpenC3 plugin from existing COSMOS 4 targets"
+  op.on("-a", "--all", " Move all COSMOS 4 targets into a single OpenC3 plugin") do
     MIGRATE_OPTIONS.all = true
   end
 end
@@ -69,9 +67,10 @@ def print_usage
   puts "  cli irb                           # Runs irb in the local directory"
   puts "  cli validate /PATH/FILENAME.gem SCOPE variables.txt # Validate a COSMOS plugin gem file"
   puts "  cli load /PATH/FILENAME.gem SCOPE variables.txt     # Loads a COSMOS plugin gem file"
-  puts "  cli generate plugin PLUGIN_NAME   # Generate a COSMOS plugin"
+  puts "  cli generate TYPE OPTIONS         # Generate various COSMOS entities"
   puts "  #{MIGRATE_PARSER}"
   puts "  cli bridge CONFIG_FILENAME        # Run COSMOS host bridge"
+  puts "  cli bridgegem gem_name variable1=value1 variable2=value2 # Runs bridge using gem bridge.txt"
   puts "  cli bridgesetup CONFIG_FILENAME   # Create a default config file"
   puts "  cli geminstall GEMFILENAME SCOPE  # Install loaded gem to /gems"
   puts "  cli rubysloc                      # Counts Ruby SLOC recursively. Run with --help for more info."
@@ -80,55 +79,6 @@ def print_usage
   puts ""
 end
 
-def generate(args)
-  case args[0]
-  when 'plugin'
-    if args.length != 2
-      abort("Usage: cli generate plugin <NAME>")
-    end
-    if args[1] =~ /\s/
-      abort("Plugin names can not have spaces!")
-    end
-
-    plugin = args[1].downcase.gsub(/_+|-+/, '-')
-    plugin_name = "openc3-cosmos-#{plugin}"
-    if File.exist?(plugin_name)
-      abort("Plugin #{plugin_name} already exists!")
-    end
-    FileUtils.mkdir(plugin_name)
-    Dir.chdir(plugin_name) # Change to the plugin path to make copying easier
-
-    # Grab the plugin template
-    template_dir = "#{File.dirname(__FILE__)}/../templates/plugin-template"
-    target_name = plugin.upcase.gsub('-', '_')
-    target_lib_filename = "#{target_name.downcase}.rb"
-    target_class = target_lib_filename.filename_to_class_name
-    target_object = target_name.downcase
-    b = binding
-
-    Dir.glob("#{template_dir}/**/*").each do |file|
-      base_name = file.sub("#{template_dir}/", '')
-      # Rename the template TARGET to our actual target named after the plugin
-      base_name.sub!("targets/TARGET", "targets/#{target_name}")
-      if File.directory?(file)
-        FileUtils.mkdir(base_name)
-        next
-      end
-      base_name.sub!("target.rb", target_lib_filename)
-      base_name.sub!("plugin.gemspec", "#{plugin_name}.gemspec")
-      output = ERB.new(File.read(file), trim_mode: "-").result(b)
-      File.open(base_name, 'w') do |file|
-        file.write output
-      end
-    end
-
-    puts "Plugin #{plugin_name} successfully generated!\n"
-    return target_name # This makes the migrate method easier
-  else # Unknown generator
-    abort("Unknown generator #{args[0]}")
-  end
-end
-
 def migrate(args)
   MIGRATE_PARSER.parse!(args)
   abort(MIGRATE_PARSER.to_s) if args.length == 0
@@ -151,7 +101,7 @@ def migrate(args)
   # NOTE: generate does a chdir to be inside the plugin directory
   ###############################################################
   plugin = args.shift
-  target_name = generate(['plugin', plugin])
+  target_name = OpenC3::CliGenerator.generate(['plugin', plugin])
   # Delete target contents from the plugin framework (but keep directory)
   FileUtils.rm_rf Dir.glob("targets/#{target_name}/*")
 
@@ -263,10 +213,6 @@ def xtce_converter(args)
       puts e.backtrace
       result = ERROR_CODE
     ensure
-      # Uninstall not necessary because this is run against a temporary container
-      # name = Psych.safe_load(`gem spec #{options[:plugin]} name`).to_s
-      # version = Psych.safe_load(`gem spec #{options[:plugin]} version`, permitted_classes: [Gem::Version]).to_s
-      # Gem::Uninstaller.new(name, {:version => version, :force => true}).uninstall
       exit(result)
     end
   else
@@ -318,10 +264,6 @@ rescue => e
   puts "Error: #{e.message}"
   result = ERROR_CODE
 ensure
-  # Uninstall not necessary because this is run against a temporary container
-  # name = Psych.safe_load(`gem spec #{plugin_file_path} name`).to_s
-  # version = Psych.safe_load(`gem spec #{plugin_file_path} version`, permitted_classes: [Gem::Version]).to_s
-  # Gem::Uninstaller.new(name, {:version => version, :force => true}).uninstall
   exit(result)
 end
 
@@ -524,6 +466,26 @@ def run_migrations(folder)
   end
 end
 
+def run_bridge(filename, params)
+  variables = {}
+  params.each do |param|
+    name, value = param.split('=')
+    if name and value
+      variables[name] = value
+    else
+      raise "Invalid variable passed to bridgegem (syntax name=value): #{param}"
+    end
+  end
+  bridge = OpenC3::Bridge.new(filename, variables)
+  begin
+    while true
+      sleep(1)
+    end
+  rescue Interrupt
+    exit(0)
+  end
+end
+
 if not ARGV[0].nil? # argument(s) given
 
   # Handle each task
@@ -551,7 +513,7 @@ if not ARGV[0].nil? # argument(s) given
     gem_install(ARGV[1], scope: ARGV[2])
 
   when 'generate'
-    generate(ARGV[1..-1])
+    OpenC3::CliGenerator.generate(ARGV[1..-1])
 
   when 'migrate'
     migrate(ARGV[1..-1])
@@ -569,14 +531,34 @@ if not ARGV[0].nil? # argument(s) given
     ENV['OPENC3_NO_STORE'] = '1'
     filename = ARGV[1]
     filename = 'bridge.txt' unless filename
-    bridge = OpenC3::Bridge.new(filename)
-    begin
-      while true
-        sleep(1)
+    params = ARGV[2..-1]
+    params = [] unless params
+    run_bridge(filename, params)
+
+  when 'bridgegem'
+    ENV['OPENC3_NO_STORE'] = '1'
+    filename = nil
+    gem_name = ARGV[1]
+    Gem::Specification.each do |s|
+      # This appears to return the newest version of each gem first,
+      # so its ok that we stop on the first time it is found
+      if s.name == gem_name
+        if Array === Gem.path
+          Gem.path.each do |gem_path|
+            filename = File.join(gem_path, 'gems', "#{s.name}-#{s.version}", 'bridge.txt')
+            puts "Trying #{filename}"
+            break if File.exist?(filename)
+          end
+        else
+          filename = File.join(Gem.path, 'gems', "#{s.name}-#{s.version}", 'bridge.txt')
+        end
+        raise "#{filename} not found" unless File.exist?(filename)
       end
-    rescue Interrupt
-      exit(0)
     end
+    raise "gem #{gem_name} not found" unless filename
+    params = ARGV[2..-1]
+    params = [] unless params
+    run_bridge(filename, params)
 
   when 'bridgesetup'
     ENV['OPENC3_NO_STORE'] = '1'
@@ -637,9 +619,11 @@ if not ARGV[0].nil? # argument(s) given
 
   when 'initbuckets'
     client = OpenC3::Bucket.getClient()
-    client.create(ENV['OPENC3_CONFIG_BUCKET'])
-    client.create(ENV['OPENC3_LOGS_BUCKET'])
-    client.create(ENV['OPENC3_TOOLS_BUCKET'])
+    ENV.map do |key, value|
+      if key.match(/^OPENC3_(.+)_BUCKET$/) && !value.empty?
+        client.create(value)
+      end
+    end
     client.ensure_public(ENV['OPENC3_TOOLS_BUCKET'])
 
   when 'runmigrations'

data/data/config/item_modifiers.yaml

@@ -52,7 +52,7 @@ READ_CONVERSION:
           @multiplier = multiplier.to_f
         end
         def call(value, packet, buffer)
-          return value * multiplier
+          return value * @multiplier
         end
       end
     end

data/data/config/plugins.yaml

@@ -13,6 +13,11 @@ VARIABLE:
       required: true
       description: Default value of the variable
       values: .+
+NEEDS_DEPENDENCIES:
+  summary: Indicates the plugin needs dependencies and sets the GEM_HOME environment variable
+  description: If the plugin has a top level lib folder or lists runtime dependencies in the gemspec,
+    NEEDS_DEPENDENCIES is effectively already set. Note that in Enterprise Edition, having
+    NEEDS_DEPENDENCIES adds the NFS volume mount to the Kuberentes pod.
 INTERFACE:
   modifiers:
     <%= MetaConfigParser.load('interface_modifiers.yaml').to_meta_config_yaml(4) %>

data/data/config/widgets.yaml

@@ -1307,12 +1307,11 @@ CANVASLABELVALUE:
       description: The type of the value to display. Default is CONVERTED.
       values: <%= %w(RAW CONVERTED FORMATTED WITH_UNITS) %>
 CANVASIMAGE:
-  summary: Displays a GIF image on the canvas
+  summary: Displays an image on the canvas
   parameters:
-    - name: Image name
+    - name: Image filename
       required: true
-      description: Name of a image file. The file must be located in the
-        <CONFIG>/data directory.
+      description: Name of a image file. The file must be in the plugin's targets/TARGET/public directory.
       values: .+
     - name: X Position
       required: true
@@ -1323,7 +1322,10 @@ CANVASIMAGE:
       description: Y position of the upper-left corner of the image on the canvas
       values: \d+
 CANVASIMAGEVALUE:
-  summary: Displays a GIF image on the canvas that changes with a telemetry value
+  summary: Displays an image on the canvas that changes with a telemetry value
+  description:
+    Use various SETTING values to indicate which images should be displayed based on telemetry.
+    For example, SETTING IMAGE CONNECTED "ground_on.png" 400 100. See the DEMO for a complete example.
   parameters:
     - name: Target name
       required: true
@@ -1337,13 +1339,13 @@ CANVASIMAGEVALUE:
       required: true
       description: The item name
       values: .+
-    - name: Filename Prefix
+    - name: Value type
+      required: true
+      description: The type of the value to display
+      values: <%= %w(RAW CONVERTED FORMATTED WITH_UNITS) %>
+    - name: Image filename
       required: true
-      description: The prefix part of the filename of the gif images (expected
-        to be in the <CONFIG>/data directory). The actual filenames will be this
-        value plus the word 'on' or the word 'off' and '.gif'. For example, your
-        prefix is 'ground' so the files 'groundon.gif' and 'groundoff.gif' will
-        be searched for in the <CONFIG>/data directory.
+      description: The default image to display. The file must be in the targets/TARGET/public directory.
       values: .+
     - name: X Position
       required: true

data/lib/openc3/api/cmd_api.rb

@@ -99,6 +99,7 @@ module OpenC3
     # @param interface_name [String] The interface to send the raw binary
     # @param data [String] The raw binary data
     def send_raw(interface_name, data, scope: $openc3_scope, token: $openc3_token)
+      interface_name = interface_name.upcase
       authorize(permission: 'cmd_raw', interface_name: interface_name, scope: scope, token: token)
       get_interface(interface_name, scope: scope, token: token) # Check to make sure the interface exists
       InterfaceTopic.write_raw(interface_name, data, scope: scope)
@@ -110,6 +111,8 @@ module OpenC3
     # @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
       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}"
@@ -127,6 +130,7 @@ module OpenC3
     # @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)
+      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
@@ -137,6 +141,7 @@ module OpenC3
     # @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)
+      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
@@ -145,23 +150,28 @@ module OpenC3
     #
     # @since 5.0.0
     # @param target_name [String] Name of the target
-    # @param packet_name [String] Name of the packet
+    # @param command_name [String] Name of the packet
     # @return [Hash] Command as a hash
-    def get_command(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
+    def get_command(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      command_name = command_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
-      TargetModel.packet(target_name, packet_name, type: :CMD, scope: scope)
+      TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
     end
 
     # Returns a hash of the given command parameter
     #
     # @since 5.0.0
     # @param target_name [String] Name of the target
-    # @param packet_name [String] Name of the packet
-    # @param param_name [String] Name of the parameter
+    # @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, packet_name, param_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
-      TargetModel.packet_item(target_name, packet_name, param_name, type: :CMD, scope: scope)
+    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
+      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
 
     # Returns whether the specified command is hazardous
@@ -176,35 +186,38 @@ module OpenC3
       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)
+        target_name, command_name, parameters = extract_fields_from_cmd_text(args[0], scope: scope)
       when 2, 3
         target_name = args[0]
         command_name = args[1]
         if args.length == 2
-          params = {}
+          parameters = {}
         else
-          params = args[2]
+          parameters = args[2]
         end
       else
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to get_cmd_hazardous()"
       end
+      target_name = target_name.upcase
+      command_name = command_name.upcase
+      parameters = parameters.transform_keys(&:upcase)
 
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       return true if packet['hazardous']
 
       packet['items'].each do |item|
-        next unless params.keys.include?(item['name']) && item['states']
+        next unless parameters.keys.include?(item['name']) && item['states']
 
         # States are an array of the name followed by a hash of 'value' and sometimes 'hazardous'
         item['states'].each do |name, hash|
-          param_name = params[item['name']]
+          parameter_name = parameters[item['name']]
           # Remove quotes from string parameters
-          param_name = param_name.gsub('"', '').gsub("'", '') if param_name.is_a?(String)
+          parameter_name = parameter_name.gsub('"', '').gsub("'", '') if parameter_name.is_a?(String)
           # To be hazardous the state must be marked hazardous
           # Check if either the state name or value matches the param passed
-          if hash['hazardous'] && (name == param_name || hash['value'] == param_name)
+          if hash['hazardous'] && (name == parameter_name || hash['value'] == parameter_name)
             return true
           end
         end
@@ -222,6 +235,9 @@ module OpenC3
     #   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
       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)
     end
@@ -236,12 +252,15 @@ module OpenC3
     def get_cmd_time(target_name = nil, command_name = nil, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       if target_name and command_name
+        target_name = target_name.upcase
+        command_name = command_name.upcase
         time = CommandDecomTopic.get_cmd_item(target_name, command_name, 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
         [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
       else
         if target_name.nil?
           targets = TargetModel.names(scope: scope)
         else
+          target_name = target_name.upcase
           targets = [target_name]
         end
         targets.each do |target_name|
@@ -268,6 +287,8 @@ module OpenC3
     # @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
       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}")
@@ -281,6 +302,8 @@ module OpenC3
       authorize(permission: 'system', scope: scope, token: token)
       counts = []
       target_commands.each do |target_name, command_name|
+        target_name = target_name.upcase
+        command_name = command_name.upcase
         counts << Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
       end
       counts
@@ -298,8 +321,8 @@ module OpenC3
       when 1
         target_name, cmd_name, cmd_params = extract_fields_from_cmd_text(args[0], scope: scope)
       when 2, 3
-        target_name = args[0]
-        cmd_name    = args[1]
+        target_name  = args[0]
+        cmd_name     = args[1]
         if args.length == 2
           cmd_params = {}
         else
@@ -309,6 +332,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      target_name = target_name.upcase
+      cmd_name = cmd_name.upcase
+      cmd_params = cmd_params.transform_keys(&:upcase)
       authorize(permission: 'cmd', target_name: target_name, packet_name: cmd_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, cmd_name, type: :CMD, scope: scope)
 

data/lib/openc3/api/tlm_api.rb

@@ -120,11 +120,14 @@ module OpenC3
     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)
       type = type.to_s.intern
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       unless CvtModel::VALUE_TYPES.include?(type)
         raise "Unknown type '#{type}' for #{target_name} #{packet_name}"
       end
 
       if item_hash
+        item_hash = item_hash.transform_keys(&:upcase)
         # Check that the items exist ... exceptions are raised if not
         TargetModel.packet_items(target_name, packet_name, item_hash.keys, scope: scope)
       else
@@ -201,6 +204,8 @@ module OpenC3
     # @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
       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}"
@@ -222,11 +227,13 @@ module OpenC3
     #   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, scope: $openc3_scope, token: $openc3_token)
+      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)
       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'] }
+      items = packet['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, scope: scope)
       items.zip(current_values).map { | item , values | [item, values[0], values[1]]}
@@ -246,13 +253,18 @@ module OpenC3
       if !items.is_a?(Array) || !items[0].is_a?(String)
         raise ArgumentError, "items must be array of strings: ['TGT__PKT__ITEM__TYPE', ...]"
       end
-
       items.each_with_index do |item, index|
-        target_name, packet_name, item_name, item_type = item.split('__')
+        target_name, packet_name, item_name, value_type = item.split('__')
+        raise ArgumentError, "items must be formatted as TGT__PKT__ITEM__TYPE" if target_name.nil? || packet_name.nil? || item_name.nil? || value_type.nil?
+        target_name = target_name.upcase
+        packet_name = packet_name.upcase
+        item_name = item_name.upcase
+        value_type = value_type.upcase
         if packet_name == 'LATEST'
           _, packet_name, _ = tlm_process_args([target_name, packet_name, item_name], 'get_tlm_values', scope: scope) # Figure out which packet is LATEST
-          items[index] = "#{target_name}__#{packet_name}__#{item_name}__#{item_type}" # Replace LATEST with the real packet name
         end
+        # Change packet_name in case of LATEST and ensure upcase
+        items[index] = "#{target_name}__#{packet_name}__#{item_name}__#{value_type}"
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       end
       CvtModel.get_tlm_values(items, stale_time: stale_time, scope: scope)
@@ -264,6 +276,7 @@ module OpenC3
     # @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)
+      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
@@ -274,6 +287,7 @@ module OpenC3
     # @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)
+      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
@@ -285,6 +299,8 @@ module OpenC3
     # @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
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
     end
@@ -297,6 +313,9 @@ module OpenC3
     # @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
       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
@@ -316,6 +335,8 @@ module OpenC3
 
       result = {}
       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)
         topic = "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
         id, _ = Topic.get_newest_message(topic)
@@ -356,6 +377,8 @@ module OpenC3
     # @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
       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}")
@@ -369,6 +392,8 @@ module OpenC3
       authorize(permission: 'system', scope: scope, token: token)
       counts = []
       target_packets.each do |target_name, packet_name|
+        target_name = target_name.upcase
+        packet_name = packet_name.upcase
         counts << Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
       end
       counts
@@ -380,6 +405,8 @@ module OpenC3
     # @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
       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 +440,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
+      item_name = item_name.upcase
       if packet_name == 'LATEST'
         latest = -1
         TargetModel.packets(target_name, scope: scope).each do |packet|
@@ -449,6 +479,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
+      item_name = item_name.upcase
       # Determine if this item exists, it will raise appropriate errors if not
       TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
 

data/lib/openc3/bridge/bridge.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'
@@ -27,8 +27,8 @@ require 'openc3/bridge/bridge_router_thread'
 
 module OpenC3
   class Bridge
-    def initialize(filename)
-      @config = BridgeConfig.new(filename)
+    def initialize(filename, existing_variables = {})
+      @config = BridgeConfig.new(filename, existing_variables)
       @threads = []
 
       # Start Interface Threads