openc3 6.4.1 → 6.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 864ffdf1957f4dc816dc54fb49e31da9b824ade6d4ff0e016dc81d0b4eaafc0c
-  data.tar.gz: ad01826136970333f93f6fd24199b5c9f6d21245c342db1709f035a35d09ae49
+  metadata.gz: 5c28c663c7d3743f9bb095a0818ae486accf2f1bb69f5079ec95788153f3005f
+  data.tar.gz: 64a60dc5bad2e3cdc78953b2dbd49a689d4b91a08e80bf8a2c4668b308a811bf
 SHA512:
-  metadata.gz: 8d3515bdd13040340bb39ac3d0bc51478c65b57e9b42ed31b11e6c10ed4228c4eccb9f7228cd2f7271e533bd66a9eee42e386f91ffabaf7c4e5179cc9ddd6efb
-  data.tar.gz: 2ef03561529805ed8f09037ab664477071bf6d8e672095b979ad828ce8cddc819ec056999b022df0dd1f522254a36f58bf9b31656ce3845b12c65869eb8f011b
+  metadata.gz: 88c76af077c0feeec36831656367e9a5c2ff4968d8d567a6d3822f4a7dec1afea33d4921aa6d5941f97c4234a85da68aa7ef7b1767eeb629650a85589f9db673
+  data.tar.gz: 0c548964225e629edff50e0666347eedcc8e6b0d9fb7ab5d134fb0a206e481ba2353568fa6ab99f0fbdfdc6758c62eec7320deeb1c0a37a4448544b2ee26215d

data/bin/openc3cli

@@ -15,7 +15,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2024, OpenC3, Inc.
+# All changes Copyright 2025, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -62,14 +62,7 @@ def print_usage
   puts "  cli help                          # Displays this information"
   puts "  cli rake                          # Runs rake in the local directory"
   puts "  cli irb                           # Runs irb in the local directory"
-  puts "  cli script list /PATH SCOPE       # lists script names filtered by path within scope, 'DEFAULT' if not given"
-  puts "  cli script spawn NAME SCOPE  variable1=value1 variable2=value2  # Starts named script remotely"
-  puts "  cli script run NAME SCOPE variable1=value1 variable2=value2  # Starts named script, monitoring status on console,\
-  by default until error or exit"
-  puts "  cli script init                   # initialize running scripts (Enterprise Only)"
-  puts "    PARAMETERS name-value pairs to form the script's runtime environment"
-  puts "    OPTIONS: --wait 0 seconds to monitor status before detaching from the running script; ie --wait 100"
-  puts "             --disconnect run the script in disconnect mode"
+  puts "  cli script                        # Interact with scripts. Run with --help for more info."
   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 list <SCOPE>                  # Lists installed plugins, SCOPE is DEFAULT if not given"
@@ -619,86 +612,180 @@ def cli_script_monitor(script_id)
   return ret_code
 end
 
-def cli_script_list(args=[])
-  path = ''
-  if (args[0] && args[0][0] == '/')
-    path = (args.shift)[1..-1]+'/'
+def get_env_from_args(args)
+  # Figure out if there are any optional environment variables
+  # args[0] is the command, args[1] is the script file
+  # args[2..-1] are environment variables specified as NAME=VALUE
+  environ = {}
+  if args.length > 2
+    args[2..-1].each do |arg|
+      name, value = arg.split('=')
+      if name and value
+        environ[name] = value
+      end
+    end
   end
-  scope = args[1]
-  scope ||= 'DEFAULT'
+  return environ
+end
+
+def cli_script_init
   require 'openc3/script'
-  script_list(scope: scope).each do |script_name|
-    puts(script_name) if script_name.start_with?(path)
-  end
+  initialize_offline_access()
   return 0
 end
 
-def cli_script_run(disconnect=false, environment={}, args=[])
-  #  we are limiting the wait for status, not the script run time
-  #  we make 0 mean 'forever'
+def cli_script_list(args, options)
+  require 'openc3/script'
+  puts script_list(scope: options[:scope])
+  return 0
+end
+
+def cli_script_run(args, options)
+  environment = get_env_from_args(args)
+
   ret_code = ERROR_CODE
-  wait_limit = 0
-  if (i = args.index('--wait'))
-    begin
-      args.delete('--wait')
-      # pull out the flag
-      seconds = args[i]
-      wait_limit = Integer(seconds, 10) # only decimal, ignore leading 0
-      args.delete_at(i)
-      # and its value
-    rescue ArgumentError
-      abort("  --wait requires a number of seconds to wait, not [#{seconds}]")
-    end
-  end
-  abort("No script file provided") if args[0].nil?
-  scope = args[1]
-  scope ||= 'DEFAULT'
   require 'openc3/script'
-  id = script_run(args[0], disconnect: disconnect, environment: environment, scope: scope) # could raise
-  $script_interrupt_text = "  Script #{args[0]} still running remotely.\n" # for Ctrl-C
-  if (wait_limit < 1) then
-    ret_code = cli_script_monitor(id)
-  else
-    Timeout::timeout(wait_limit, nil, "--wait #{wait_limit} exceeded") do
+  if (id = script_run(args[1], disconnect: options[:disconnect], environment: environment, scope: options[:scope]))
+    puts id
+    $script_interrupt_text = "  Script #{args[1]} still running remotely.\n" # for Ctrl-C
+    if (options[:wait] < 1) then
       ret_code = cli_script_monitor(id)
-    rescue Timeout::ExitException, Timeout::Error => e
-      # Timeout exceptions are also raised by the Websocket API, so we check
-      if e.message =~ /^--wait /
-        puts e.message + ", detaching from running script #{args[0]}"
-      else
-        raise
+    else
+      Timeout::timeout(options[:wait], nil, "--wait #{options[:wait]} exceeded") do
+        ret_code = cli_script_monitor(id)
+      rescue Timeout::ExitException, Timeout::Error => e
+        # Timeout exceptions are also raised by the Websocket API, so we check
+        if e.message =~ /^--wait /
+          puts e.message + ", detaching from running script #{args[1]}"
+        else
+          raise
+        end
       end
     end
   end
   return ret_code
+rescue => e
+  puts "Error running script: #{e.message}"
+  puts "Have you called 'script init'?"
+  puts e.backtrace
+  return ERROR_CODE
 end
 
-def cli_script_spawn(disconnect=false, environment={}, args=[])
+def cli_script_spawn(args, options)
+  environment = get_env_from_args(args)
+
   ret_code = ERROR_CODE
-  if (args.index('--wait'))
-    abort("Did you mean \"script run --wait <seconds> [...]\"?")
-  end
-  abort("No script file provided") if args[0].nil?
-  # heaven help you if you left out the script name
-  scope = args[1]
-  scope ||= 'DEFAULT'
   require 'openc3/script'
-  if (id = script_run(args[0], disconnect: disconnect, environment: environment, scope: scope))
+  if (id = script_run(args[1], disconnect: options[:disconnect], environment: environment, scope: options[:scope]))
     puts id
     ret_code = 0
   end
   return ret_code
+rescue => e
+  puts "Error running script: #{e.message}"
+  puts "Have you called 'script init'?"
+  puts e.backtrace
+  return ERROR_CODE
 end
 
-def cli_script_init
+def cli_script_running(args, options)
+  ret_code = ERROR_CODE
   require 'openc3/script'
-  initialize_offline_access()
+  if args[1]
+    limit = args[1].to_i
+  else
+    limit = 100
+  end
+  if args[2]
+    offset = args[2].to_i
+  else
+    offset = 0
+  end
+  if (list = running_script_list(limit: limit, offset: offset, scope: options[:scope]))
+    if options[:verbose]
+      pp list
+    else
+      printf("%-5s %-20s %-30s %-22s %-10s\n", "ID", "User", "Filename", "Start Time", "State")
+      list.each do |hash|
+        printf("%-5s %-20s %-30s %-22s %-10s\n", hash['name'], hash['user_full_name'], hash['filename'], hash['start_time'], hash['state'])
+      end
+    end
+    ret_code = 0
+  end
+  return ret_code
+rescue => e
+  puts "Error getting script status for #{args[1]}: #{e.message}"
+  puts "Have you called 'script init'?"
+  puts e.backtrace
+  return ERROR_CODE
+end
+
+def cli_script_status(args, options)
+  ret_code = ERROR_CODE
+  require 'openc3/script'
+  if (hash = script_get(args[1], scope: options[:scope]))
+    if options[:verbose]
+      pp hash
+    else
+      printf("%-5s %-20s %-30s %-22s %-10s\n", "ID", "User", "Filename", "Start Time", "State")
+      printf("%-5s %-20s %-30s %-22s %-10s\n", hash['name'], hash['user_full_name'], hash['filename'], hash['start_time'], hash['state'])
+    end
+    ret_code = 0
+  end
+  return ret_code
+rescue => e
+  puts "Error getting script status for #{args[1]}: #{e.message}"
+  puts "Have you called 'script init'?"
+  puts e.backtrace
+  return ERROR_CODE
+end
+
+def cli_script_stop(args, options)
+  require 'openc3/script'
+  running_script_stop(args[1], scope: options[:scope])
   return 0
+rescue => e
+  puts "Error stopping script #{args[1]}: #{e.message}"
+  puts "Have you called 'script init'?"
+  puts e.backtrace
+  return ERROR_CODE
 end
 
-## cli_script(args) turns an ARGV of [spawn|run] <--wait 123...> <--disconnect> SCRIPT <scope> <ENV_A=1 ENV_B=2 ...>
-#                   into function calls and tidied parameters to remote-control a script via RunningScriptWebSocketApi
 def cli_script(args=[])
+  options = {scope: 'DEFAULT', disconnect: false, wait: 0, verbose: false}
+  option_parser = OptionParser.new do |opts|
+    opts.banner = "Usage: script --scope SCOPE [init | list | spawn | run]\n" +
+      "  init                               Initialize running scripts (Enterprise Only)\n" +
+      "  list                               List scripts in the specified scope\n" +
+      "  spawn SCRIPT [ENV=VALUE]           Spawn SCRIPT in the specified scope with optional env vars and return script ID\n" +
+      "  run SCRIPT [ENV=VALUE]             Run SCRIPT in the specified scope with optional env vars and print script output\n" +
+      "  running [LIMIT] [OFFSET]           Get a list of all running scripts (limit 100 by default). Use LIMIT and OFFSET to get large batches.\n" +
+      "  status SCRIPT_ID                   Get status for the running script given by SCRIPT_ID\n" +
+      "  stop SCRIPT_ID                     Stop the running script given by SCRIPT_ID\n"
+    opts.on("-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+    opts.on("--scope SCOPE", "Run with specified scope (default = DEFAULT)") do |arg|
+      options[:scope] = arg
+    end
+    opts.on("-d", "--disconnect", "Run a script in disconnect mode (default = false)") do |arg|
+      options[:disconnect] = arg
+    end
+    opts.on("-w SECONDS", "--wait SECONDS", "*run only* - wait for the specified number of seconds before aborting script monitoring") do |arg|
+      options[:wait] = Integer(arg)
+    end
+    opts.on("-v", "--verbose", "*status only* - output ALL status information") do |arg|
+      options[:verbose] = arg
+    end
+  end
+
+  begin
+    option_parser.parse!(args)
+  rescue
+    abort(option_parser.to_s)
+  end
+
   ret_code = ERROR_CODE
   check_environment()
   # Double check for the OPENC3_API_PASSWORD because it is absolutely required
@@ -706,38 +793,30 @@ def cli_script(args=[])
   if ENV['OPENC3_API_PASSWORD'].nil? or ENV['OPENC3_API_PASSWORD'].empty?
     abort "OPENC3_API_PASSWORD environment variable is required for cli script"
   end
-  command = args.shift
-  # pull out the disconnect flag
-  discon = args.delete('--disconnect')
-  discon = (discon.is_a? String) ? true : false
-  environ = {}
-  args.each do |arg|
-    name, value = arg.split('=')
-    if name and value
-    # add env[k]=v ; pull out "k=v"
-      environ[name] = value
-      args.delete(arg)
-    end
-  end
+
+  # The script command is the first parameter and it is required
+  command = args[0]
+  abort(option_parser.to_s) unless command
+
   case command
-  # for list
-  # args[] should now be ["/<path>", "<scope>"]
-  #                   or ["/<path>"]
-  #                   or ["<scope>"]
-  #                   or []
+  when 'init'
+    ret_code = cli_script_init()
   when 'list'
-    ret_code = cli_script_list(args)
-  # for spawn or run
-  # args[] should now be ["--wait 100", "script_name", "<scope>"]
-  #                   or ["--wait 100", "script_name"]
-  #                   or ["script_name", "<scope>"]
-  #                   or ["script_name"]
+    ret_code = cli_script_list(args, options)
   when 'spawn'
-    ret_code = cli_script_spawn(discon, environ, args)
+    abort(option_parser.to_s) unless args[1] # script file is required
+    ret_code = cli_script_spawn(args, options)
   when 'run'
-    ret_code = cli_script_run(discon, environ, args)
-  when 'init'
-    ret_code = cli_script_init()
+    abort(option_parser.to_s) unless args[1] # script file is required
+    ret_code = cli_script_run(args, options)
+  when 'running'
+    ret_code = cli_script_running(args, options)
+  when 'status'
+    abort(option_parser.to_s) unless args[1] # script ID is required
+    ret_code = cli_script_status(args, options)
+  when 'stop'
+    abort(option_parser.to_s) unless args[1] # script ID is required
+    ret_code = cli_script_stop(args, options)
   else
     abort 'openc3cli internal error: parsing arguments'
   end
@@ -754,13 +833,7 @@ if not ARGV[0].nil? # argument(s) given
     IRB.start
 
   when 'script'
-    case ARGV[1]
-    when 'list', 'run', 'spawn', 'init'
-      cli_script(ARGV[1..-1])
-    else
-      # invalid actions, misplaced and malformed leading options and 'help' come here
-      abort("cli script <action> must be one of #{CLI_SCRIPT_ACTIONS}, not [#{ARGV[1]}]")
-    end
+    cli_script(ARGV[1..-1])
 
   when 'rake'
     if File.exist?('Rakefile')
@@ -790,6 +863,8 @@ if not ARGV[0].nil? # argument(s) given
     cli_pkg_uninstall(ARGV[1], scope: ARGV[2])
 
   when 'generate'
+    # To test against a local copy call this file from the root cosmos directory like this:
+    # ruby -Iopenc3/lib openc3/bin/openc3cli generate ...
     OpenC3::CliGenerator.generate(ARGV[1..-1])
 
   when 'rubysloc'

data/data/config/_graph_params.yaml

@@ -1,17 +1,17 @@
 ---
-- name: Target name
+- name: Target Name
   required: true
   description: The target name
   values: .+
-- name: Packet name
+- name: Packet Name
   required: true
   description: The packet name
   values: .+
-- name: Item name
+- name: Item Name
   required: true
   description: The item name
   values: .+
-- name: Value type
+- name: Value Type
   required: false
   description: The type of the value to display. Default is CONVERTED.
   values: <%= %w(RAW CONVERTED) %>

data/data/config/conversions.yaml

@@ -0,0 +1,274 @@
+BIT_REVERSE_CONVERSION:
+  summary: Reverses the bits of the current telemetry item. Can be used as both a read and write conversion.
+  ruby_example: |
+    READ_CONVERSION bit_reverse_conversion.rb
+    WRITE_CONVERSION bit_reverse_conversion.rb
+  python_example: |
+    READ_CONVERSION openc3/conversions/bit_reverse_conversion.py
+    WRITE_CONVERSION openc3/conversions/bit_reverse_conversion.py
+IP_READ_CONVERSION:
+  summary: Reads a packed 32 bit integer into an IP address string
+  description: |
+    This command reads a packed 32 bit integer into an IP address string.
+    For example, 0xFFFF8000 would be converted to '255.255.128.0'.
+  ruby_example: READ_CONVERSION ip_read_conversion.rb
+  python_example: READ_CONVERSION openc3/conversions/ip_read_conversion.py
+IP_WRITE_CONVERSION:
+  summary: Write an ip address string into a packed 32 bit integer
+  description: |
+    This command writes an IP address string into a packed 32 bit integer. The IP address
+    string should be in the format 'x.x.x.x' where x is a number between 0 and 255.
+    For example, '255.255.128.0' would be converted to 0xFFFF8000.
+  ruby_example: WRITE_CONVERSION ip_write_conversion.rb
+  python_example: WRITE_CONVERSION openc3/conversions/ip_write_conversion.py
+OBJECT_READ_CONVERSION:
+  summary: Reads values from the given packet object
+  description: |
+    This command reads all the values from the given packet object. The values are
+    returned as a Ruby hash or Python dict. The packet object must be defined in the target's configuration.
+  parameters:
+    - name: Command or Telemetry
+      required: true
+      description: Whether the packet is a command or telemetry
+      values: [CMD, TLM]
+    - name: Target Name
+      required: true
+      description: Name of the target
+      values: .*
+    - name: Packet Name
+      required: true
+      description: Name of the packet
+      values: .*
+  ruby_example: READ_CONVERSION object_read_conversion.rb CMD INST COLLECT
+  python_example: READ_CONVERSION openc3/conversions/object_read_conversion.py CMD INST COLLECT
+OBJECT_WRITE_CONVERSION:
+  summary: Writes values into the given packet object
+  description: |
+    This command writes values into the given packet object. The values are specified
+    in a hash format where the keys are the field names in the packet and the values
+    are the values to write. The packet object must be defined in the target's configuration.
+  parameters:
+    - name: Command or Telemetry
+      required: true
+      description: Whether the packet is a command or telemetry
+      values: [CMD, TLM]
+    - name: Target Name
+      required: true
+      description: Name of the target
+      values: .*
+    - name: Packet Name
+      required: true
+      description: Name of the packet
+      values: .*
+  ruby_example: WRITE_CONVERSION object_write_conversion.rb CMD INST COLLECT
+  python_example: WRITE_CONVERSION openc3/conversions/object_write_conversion.py CMD INST COLLECT
+PACKET_TIME_FORMATTED_CONVERSION:
+  summary: Converts the packet time to a formatted string like "YYYY/MM/DD HH:MM:SS.US"
+  description: |
+    This in an internal conversion which is automatically applied to the
+    'PACKET_TIMEFORMATTED' derived telemetry item. It is typically not explicitly used.
+    For more information see the [Received Time and Packet Time](/docs/configuration/telemetry#received-time-and-packet-time) documentation.
+  ruby_example: READ_CONVERSION packet_time_formatted_conversion.rb
+  python_example: READ_CONVERSION openc3/conversions/packet_time_formatted_conversion.py
+PACKET_TIME_SECONDS_CONVERSION:
+  summary: Converts the packet time to a floating point number of seconds since the epoch
+  description: |
+    This in an internal conversion which is automatically applied to the
+    'PACKET_TIMESECONDS' derived telemetry item. It is typically not explicitly used.
+    For more information see the [Received Time and Packet Time](/docs/configuration/telemetry#received-time-and-packet-time) documentation.
+  ruby_example: READ_CONVERSION packet_time_seconds_conversion.rb
+  python_example: READ_CONVERSION openc3/conversions/packet_time_seconds_conversion.py
+POLYNOMIAL_CONVERSION:
+  summary: Adds a polynomial conversion factor to the current item. Can be used as both a read and write conversion.
+  description:
+    For commands, the conversion factor is applied to raw value set by the user (via tool or script)
+    before it is written into the binary command packet and sent. For telemetry, the conversion factor
+    is applied to the raw value in the telemetry packet before it is displayed to the user. The user still
+    has the ability to see the raw unconverted value in a details dialog.
+  parameters:
+    - name: C0
+      required: true
+      description: Coefficient
+      values: .*
+    - name: Cx
+      required: false
+      description: Additional coefficient values for the conversion. Any order
+        polynomial conversion may be used so the value of 'x' will vary with the
+        order of the polynomial. Note that larger order polynomials take longer
+        to process than shorter order polynomials, but are sometimes more accurate.
+      values: .*
+  ruby_example: |
+    READ_CONVERSION polynomial_conversion.rb 10 0.5 0.25
+    # Since this is a common conversion it has an alias:
+    POLY_READ_CONVERSION 10 0.5 0.25
+
+    WRITE_CONVERSION polynomial_conversion.rb 10 0.5 0.25
+    # Since this is a common conversion it has an alias:
+    POLY_WRITE_CONVERSION 10 0.5 0.25
+  python_example: |
+    READ_CONVERSION openc3/conversions/polynomial_conversion.py 10 0.5 0.25
+    # Since this is a common conversion it has an alias:
+    POLY_READ_CONVERSION 10 0.5 0.25
+
+    WRITE_CONVERSION openc3/conversions/polynomial_conversion.py 10 0.5 0.25
+    # Since this is a common conversion it has an alias:
+    POLY_WRITE_CONVERSION 10 0.5 0.25
+PROCESSOR_CONVERSION:
+  summary: Read a value from a processor
+  description: |
+    This command reads a value from a processor. The value is read from the
+    processor's available values. The processor must be defined in the target's configuration.
+    See the [Processor](/docs/configuration/processors) documentation for more information.
+  parameters:
+    - name: Processor Name
+      required: true
+      description: Name of the processor
+      values: .*
+    - name: Processor Value
+      required: true
+      description: Published processor value
+      values: .*
+  ruby_example: |
+    PROCESSOR TEMP1WATER watermark_processor.rb TEMP1
+    ITEM TEMP1HIGH 0 0 DERIVED "High-water mark for TEMP1"
+      READ_CONVERSION processor_conversion.rb TEMP1WATER HIGH_WATER
+  python_example: |
+    PROCESSOR TEMP1WATER openc3/conversions/watermark_processor.py TEMP1
+    ITEM TEMP1HIGH 0 0 DERIVED "High-water mark for TEMP1"
+      READ_CONVERSION openc3/conversions/processor_conversion.py TEMP1WATER HIGH_WATER
+RECEIVED_COUNT_CONVERSION:
+  summary: Converts the packet received count to a UINT 32 value
+  description: |
+    This in an internal conversion which is automatically applied to the
+    'RECEIVED_COUNT' derived telemetry item. It is typically not explicitly used.
+  ruby_example: READ_CONVERSION received_count_conversion.rb
+  python_example: READ_CONVERSION openc3/conversions/received_count_conversion.py
+RECEIVED_TIME_FORMATTED_CONVERSION:
+  summary: Converts the packet received time to a formatted string like "YYYY/MM/DD HH:MM:SS.US"
+  description: |
+    This in an internal conversion which is automatically applied to the
+    'RECEIVED_TIMEFORMATTED' derived telemetry item. It is typically not explicitly used.
+    For more information see the [Received Time and Packet Time](/docs/configuration/telemetry#received-time-and-packet-time) documentation.
+  ruby_example: READ_CONVERSION received_time_formatted_conversion.rb
+  python_example: READ_CONVERSION openc3/conversions/received_time_formatted_conversion.py
+RECEIVED_TIME_SECONDS_CONVERSION:
+  summary: Converts the packet received to a floating point number of seconds since the epoch
+  description: |
+    This in an internal conversion which is automatically applied to the
+    'RECEIVED_TIMESECONDS' derived telemetry item. It is typically not explicitly used.
+    For more information see the [Received Time and Packet Time](/docs/configuration/telemetry#received-time-and-packet-time) documentation.
+  ruby_example: READ_CONVERSION received_time_formatted_conversion.rb
+  python_example: READ_CONVERSION openc3/conversions/received_time_formatted_conversion.py
+SEGMENTED_POLYNOMIAL_CONVERSION:
+  summary: Adds a segmented polynomial conversion factor to the current item. Can be used as both a read and write conversion.
+  description:
+    For commands, this conversion factor is applied to the raw value set by the user
+    (via tool or script) before it is written into the binary command packet and sent.
+    For telemetry, the conversion factor is applied to the raw value in the telemetry packet
+    before it is displayed to the user. The user still has the ability to see the raw
+    unconverted value in a details dialog.
+  parameters:
+    - name: Lower Bound
+      required: true
+      description:
+        Defines the lower bound of the range of values that this segmented
+        polynomial applies to. Is ignored for the segment with the smallest lower bound.
+      values: .*
+    - name: C0
+      required: true
+      description: Coefficient
+      values: .*
+    - name: Cx
+      required: false
+      description: Additional coefficient values for the conversion. Any order
+        polynomial conversion may be used so the value of 'x' will vary with the
+        order of the polynomial. Note that larger order polynomials take longer
+        to process than shorter order polynomials, but are sometimes more accurate.
+      values: .*
+  ruby_example: |
+    READ_CONVERSION segmented_polynomial_conversion.rb 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    # Since this is a common conversion it has an alias:
+    SEG_POLY_READ_CONVERSION 10 0.5 0.25 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    SEG_POLY_READ_CONVERSION 50 11 0.5 0.275 # Apply the conversion to all values >= 50 and < 100
+    SEG_POLY_READ_CONVERSION 100 12 0.5 0.3 # Apply the conversion to all values >= 100
+
+    WRITE_CONVERSION segmented_polynomial_conversion.rb 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    # Since this is a common conversion it has an alias:
+    SEG_POLY_WRITE_CONVERSION 10 0.5 0.25 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    SEG_POLY_WRITE_CONVERSION 50 11 0.5 0.275 # Apply the conversion to all values >= 50 and < 100
+    SEG_POLY_WRITE_CONVERSION 100 12 0.5 0.3 # Apply the conversion to all values >= 100
+  python_example: |
+    READ_CONVERSION openc3/conversions/segmented_polynomial_conversion.py 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    # Since this is a common conversion it has an alias:
+    SEG_POLY_READ_CONVERSION 10 0.5 0.25 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    SEG_POLY_READ_CONVERSION 50 11 0.5 0.275 # Apply the conversion to all values >= 50 and < 100
+    SEG_POLY_READ_CONVERSION 100 12 0.5 0.3 # Apply the conversion to all values >= 100
+
+    WRITE_CONVERSION openc3/conversions/segmented_polynomial_conversion.py 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    # Since this is a common conversion it has an alias:
+    SEG_POLY_WRITE_CONVERSION 10 0.5 0.25 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    SEG_POLY_WRITE_CONVERSION 50 11 0.5 0.275 # Apply the conversion to all values >= 50 and < 100
+    SEG_POLY_WRITE_CONVERSION 100 12 0.5 0.3 # Apply the conversion to all values >= 100
+UNIX_TIME_CONVERSION:
+  summary: Converts values to a native Ruby or Python time object
+  parameters:
+    - name: Seconds Item Name
+      required: true
+      description: The name of the item which contains the seconds since the epoch.
+      values: .*
+    - name: Microseconds Item Name
+      required: false
+      description: The name of the item which contains the microseconds since the epoch.
+      values: .*
+    - name: Seconds Type
+      required: false
+      description: How to read the seconds item. Defaults to 'RAW'.
+      values: [RAW, CONVERTED]
+    - name: Microseconds Type
+      required: false
+      description: How to read the microseconds item. Defaults to 'RAW'.
+      values: [RAW, CONVERTED]
+  ruby_example: READ_CONVERSION unix_time_conversion.rb TIMESEC TIMEUS
+  python_example: READ_CONVERSION openc3/conversions/unix_time_conversion.py TIMESEC TIMEUS
+UNIX_TIME_FORMATTED_CONVERSION:
+  summary: Converts values to a formatted time string like "YYYY/MM/DD HH:MM:SS.US"
+  parameters:
+    - name: Seconds Item Name
+      required: true
+      description: The name of the item which contains the seconds since the epoch.
+      values: .*
+    - name: Microseconds Item Name
+      required: false
+      description: The name of the item which contains the microseconds since the epoch.
+      values: .*
+    - name: Seconds Type
+      required: false
+      description: How to read the seconds item. Defaults to 'RAW'.
+      values: [RAW, CONVERTED]
+    - name: Microseconds Type
+      required: false
+      description: How to read the microseconds item. Defaults to 'RAW'.
+      values: [RAW, CONVERTED]
+  ruby_example: READ_CONVERSION unix_time_formatted_conversion.rb TIMESEC TIMEUS
+  python_example: READ_CONVERSION openc3/conversions/unix_time_formatted_conversion.py TIMESEC TIMEUS
+UNIX_TIME_SECONDS_CONVERSION:
+  summary: Converts values to a floating point number of seconds since the epoch
+  parameters:
+    - name: Seconds Item Name
+      required: true
+      description: The name of the item which contains the seconds since the epoch.
+      values: .*
+    - name: Microseconds Item Name
+      required: false
+      description: The name of the item which contains the microseconds since the epoch.
+      values: .*
+    - name: Seconds Type
+      required: false
+      description: How to read the seconds item. Defaults to 'RAW'.
+      values: [RAW, CONVERTED]
+    - name: Microseconds Type
+      required: false
+      description: How to read the microseconds item. Defaults to 'RAW'.
+      values: [RAW, CONVERTED]
+  ruby_example: READ_CONVERSION unix_time_seconds_conversion.rb TIMESEC TIMEUS
+  python_example: READ_CONVERSION openc3/conversions/unix_time_seconds_conversion.py TIMESEC TIMEUS