openc3 5.11.3 → 5.13.0

data/lib/openc3/packets/parsers/processor_parser.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/processors'
@@ -28,9 +28,9 @@ module OpenC3
     # @param packet [Packet] The current packet
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
     def self.parse(parser, packet, cmd_or_tlm)
-      @parser = ProcessorParser.new(parser)
-      @parser.verify_parameters(cmd_or_tlm)
-      @parser.create_processor(packet)
+      parser = ProcessorParser.new(parser)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_processor(packet)
     end
 
     # @param parser [ConfigParser] Configuration parser

data/lib/openc3/packets/parsers/state_parser.rb

@@ -34,9 +34,9 @@ module OpenC3
       raise parser.error("Items with LIMITS can't define STATE") if item.limits.values
       raise parser.error("Items with UNITS can't define STATE") if item.units
 
-      @parser = StateParser.new(parser)
-      @parser.verify_parameters(cmd_or_tlm)
-      @parser.create_state(packet, cmd_or_tlm, item, warnings)
+      parser = StateParser.new(parser)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_state(packet, cmd_or_tlm, item, warnings)
     end
 
     # @param parser [ConfigParser] Configuration parser

data/lib/openc3/packets/parsers/xtce_parser.rb

@@ -181,7 +181,8 @@ module OpenC3
       when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet',
         'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria',
         'ComparisonList', 'MetaCommandSet', 'ArgumentTypeSet', 'ArgumentList',
-        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime'
+        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime',
+        'AncillaryDataSet', 'AncillaryData'
         # Do Nothing
 
       when 'ErrorDetectCorrect'
@@ -446,6 +447,9 @@ module OpenC3
         process_ref_entry(element)
         return false # Already recursed
 
+      when 'ContainerRefEntry'
+        xtce_handle_base_container('ContainerRefEntry', element)
+
       when 'BaseContainer'
         # Handled in SequenceContainer/CommandContainer
 

data/lib/openc3/script/api_shared.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -69,7 +69,7 @@ module OpenC3
       method += ", #{orig_kwargs}" unless orig_kwargs.empty?
       method += ")"
     rescue Exception => error
-      Logger.info "CHECK: #{method} raised #{error.class}:#{error.message}"
+      puts "CHECK: #{method} raised #{error.class}:#{error.message}"
     else
       raise(CheckError, "#{method} should have raised an exception but did not.")
     end
@@ -107,10 +107,10 @@ module OpenC3
         end
 
         if all_checks_ok
-          Logger.info message
+          puts message
         else
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -120,11 +120,11 @@ module OpenC3
         check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
         range_str = "range #{range.first} to #{range.last} with value == #{value}"
         if range.include?(value)
-          Logger.info "#{check_str} was within #{range_str}"
+          puts "#{check_str} was within #{range_str}"
         else
           message = "#{check_str} failed to be within #{range_str}"
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -140,13 +140,13 @@ module OpenC3
     # Check to see if an expression is true without waiting.  If the expression
     # is not true, the script will pause.
     def check_expression(exp_to_eval, context = nil, scope: $openc3_scope, token: $openc3_token)
-      success = openc3_script_wait_implementation_expression(exp_to_eval, 0, DEFAULT_TLM_POLLING_RATE, context, scope: scope, token: token)
+      success = _openc3_script_wait_implementation_expression(exp_to_eval, 0, DEFAULT_TLM_POLLING_RATE, context, scope: scope, token: token)
       if success
-        Logger.info "CHECK: #{exp_to_eval} is TRUE"
+        puts "CHECK: #{exp_to_eval} is TRUE"
       else
         message = "CHECK: #{exp_to_eval} is FALSE"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end
@@ -171,7 +171,7 @@ module OpenC3
         start_time = Time.now.sys
         openc3_script_sleep()
         time_diff = Time.now.sys - start_time
-        Logger.info("WAIT: Indefinite for actual time of #{time_diff} seconds") unless quiet
+        puts "WAIT: Indefinite for actual time of #{time_diff} seconds" unless quiet
 
       # wait(5) # absolute wait time
       when 1
@@ -179,7 +179,7 @@ module OpenC3
           start_time = Time.now.sys
           openc3_script_sleep(args[0])
           time_diff = Time.now.sys - start_time
-          Logger.info("WAIT: #{args[0]} seconds with actual time of #{time_diff} seconds") unless quiet
+          puts "WAIT: #{args[0]} seconds with actual time of #{time_diff} seconds" unless quiet
         else
           raise "Non-numeric wait time specified"
         end
@@ -238,7 +238,7 @@ module OpenC3
       if value.is_a?(Array)
         expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_tolerance')
 
-        success, value = openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = _openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time = Time.now.sys - start_time
 
         message = ""
@@ -254,20 +254,20 @@ module OpenC3
         end
 
         if success
-          Logger.info message unless quiet
+          puts message unless quiet
         else
-          Logger.warn message unless quiet
+          puts "WARN: #{message}" unless quiet
         end
       else
-        success, value = openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time = Time.now.sys - start_time
         range = (expected_value - tolerance)..(expected_value + tolerance)
         wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)}"
         range_str = "range #{range.first} to #{range.last} with value == #{value} after waiting #{time} seconds"
         if success
-          Logger.info "#{wait_str} was within #{range_str}" unless quiet
+          puts "#{wait_str} was within #{range_str}" unless quiet
         else
-          Logger.warn "#{wait_str} failed to be within #{range_str}" unless quiet
+          puts "WARN: #{wait_str} failed to be within #{range_str}" unless quiet
         end
       end
       time
@@ -281,12 +281,12 @@ module OpenC3
     # Wait on a custom expression to be true
     def wait_expression(exp_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, context = nil, quiet: false, scope: $openc3_scope, token: $openc3_token)
       start_time = Time.now.sys
-      success = openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: scope, token: token)
+      success = _openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: scope, token: token)
       time_diff = Time.now.sys - start_time
       if success
-        Logger.info "WAIT: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds" unless quiet
+        puts "WAIT: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds" unless quiet
       else
-        Logger.warn "WAIT: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds" unless quiet
+        puts "WARN: WAIT: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds" unless quiet
       end
       time_diff
     end
@@ -303,17 +303,20 @@ module OpenC3
     def wait_check(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token, &block)
       target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args)
       start_time = Time.now.sys
-      success, value = openc3_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
+      success, value = _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
       time_diff = Time.now.sys - start_time
-      check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
+      check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
+      if comparison_to_eval
+        check_str += " #{comparison_to_eval}"
+      end
       with_value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
-        Logger.info "#{check_str} success #{with_value_str}"
+        puts "#{check_str} success #{with_value_str}"
       else
         message = "#{check_str} failed #{with_value_str}"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end
@@ -344,7 +347,7 @@ module OpenC3
       if value.is_a?(Array)
         expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance')
 
-        success, value = openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
+        success, value = _openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
         time_diff = Time.now.sys - start_time
 
         message = ""
@@ -360,26 +363,26 @@ module OpenC3
         end
 
         if success
-          Logger.info message
+          puts message
         else
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
         end
       else
-        success, value = openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time_diff = Time.now.sys - start_time
         range = (expected_value - tolerance)..(expected_value + tolerance)
         check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
         range_str = "range #{range.first} to #{range.last} with value == #{value} after waiting #{time_diff} seconds"
         if success
-          Logger.info "#{check_str} was within #{range_str}"
+          puts "#{check_str} was within #{range_str}"
         else
           message = "#{check_str} failed to be within #{range_str}"
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -400,17 +403,17 @@ module OpenC3
                               context = nil,
                               scope: $openc3_scope, token: $openc3_token, &block)
       start_time = Time.now.sys
-      success = openc3_script_wait_implementation_expression(exp_to_eval,
+      success = _openc3_script_wait_implementation_expression(exp_to_eval,
                                                              timeout,
                                                              polling_rate,
                                                              context, scope: scope, token: token, &block)
       time_diff = Time.now.sys - start_time
       if success
-        Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds"
+        puts "CHECK: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds"
       else
         message = "CHECK: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end
@@ -537,7 +540,7 @@ module OpenC3
       if comparison_to_eval
         _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
       else
-        Logger.info "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value}"
+        puts "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value}"
       end
     end
 
@@ -545,6 +548,10 @@ module OpenC3
       case args.length
       when 1
         target_name, packet_name, item_name, comparison_to_eval = extract_fields_from_check_text(args[0])
+      when 3
+        target_name        = args[0]
+        packet_name        = args[1]
+        item_name          = args[2]
       when 4
         target_name        = args[0]
         packet_name        = args[1]
@@ -554,7 +561,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
-      raise "Invalid comparison to non-ascii value" unless comparison_to_eval.is_printable?
+      if comparison_to_eval and !comparison_to_eval.is_printable?
+        raise "ERROR: Invalid comparison to non-ascii value"
+      end
       return [target_name, packet_name, item_name, comparison_to_eval]
     end
 
@@ -599,30 +608,30 @@ module OpenC3
       # If the packet has not been received the initial_count could be nil
       initial_count = 0 unless initial_count
       start_time = Time.now.sys
-      success, value = openc3_script_wait_implementation(target_name,
-                                                         packet_name,
-                                                         'RECEIVED_COUNT',
-                                                         :CONVERTED,
-                                                         ">= #{initial_count + num_packets}",
-                                                         timeout,
-                                                         polling_rate,
-                                                         scope: scope,
-                                                         token: token)
+      success, value = _openc3_script_wait_implementation_comparison(target_name,
+                                                                     packet_name,
+                                                                     'RECEIVED_COUNT',
+                                                                     :CONVERTED,
+                                                                     ">= #{initial_count + num_packets}",
+                                                                     timeout,
+                                                                     polling_rate,
+                                                                     scope: scope,
+                                                                     token: token)
       # If the packet has not been received the value could be nil
       value = 0 unless value
       time_diff = Time.now.sys - start_time
       if success
-        Logger.info "#{type}: #{target_name.upcase} #{packet_name.upcase} received #{value - initial_count} times after waiting #{time_diff} seconds" unless quiet
+        puts "#{type}: #{target_name.upcase} #{packet_name.upcase} received #{value - initial_count} times after waiting #{time_diff} seconds" unless quiet
       else
         message = "#{type}: #{target_name.upcase} #{packet_name.upcase} expected to be received #{num_packets} times but only received #{value - initial_count} times after waiting #{time_diff} seconds"
         if check
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
         else
-          Logger.warn message unless quiet
+          puts "WARN: #{message}" unless quiet
         end
       end
       time_diff
@@ -630,15 +639,15 @@ module OpenC3
 
     def _execute_wait(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, quiet: false, scope: $openc3_scope, token: $openc3_token)
       start_time = Time.now.sys
-      success, value = openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
+      success, value = _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
       time_diff = Time.now.sys - start_time
       wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
-        Logger.info "#{wait_str} success #{value_str}" unless quiet
+        puts "#{wait_str} success #{value_str}" unless quiet
       else
-        Logger.warn "#{wait_str} failed #{value_str}" unless quiet
+        puts "WARN: #{wait_str} failed #{value_str}" unless quiet
       end
     end
 
@@ -732,8 +741,9 @@ module OpenC3
 
     def _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $openc3_scope, token: $openc3_token, &block)
       end_time = Time.now.sys + timeout
-      raise "Invalid comparison to non-ascii value" unless exp_to_eval.is_printable?
-
+      if exp_to_eval and !exp_to_eval.is_printable?
+        raise "ERROR: Invalid comparison to non-ascii value"
+      end
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
@@ -762,15 +772,23 @@ module OpenC3
 
         if canceled
           value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-          begin
-            if eval(exp_to_eval)
+          if not block.nil?
+            if block.call(value)
               return true, value
             else
               return false, value
             end
-          # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
-          rescue NoMethodError
-            return false, value
+          else
+            begin
+              if eval(exp_to_eval)
+                return true, value
+              else
+                return false, value
+              end
+            # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
+            rescue NoMethodError
+              return false, value
+            end
           end
         end
       end
@@ -787,7 +805,7 @@ module OpenC3
     end
 
     # Wait for a converted telemetry item to pass a comparison
-    def openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
+    def _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
       if comparison_to_eval
         exp_to_eval = "value " + comparison_to_eval
       else
@@ -796,12 +814,12 @@ module OpenC3
       _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
+    def _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
       exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
       _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def openc3_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
+    def _openc3_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
       statements = []
       array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
       exp_to_eval = statements.join(" && ")
@@ -809,7 +827,7 @@ module OpenC3
     end
 
     # Wait on an expression to be true.
-    def openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: $openc3_scope, token: $openc3_token)
+    def _openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: $openc3_scope, token: $openc3_token)
       end_time = Time.now.sys + timeout
       raise "Invalid comparison to non-ascii value" unless exp_to_eval.is_printable?
 
@@ -855,11 +873,11 @@ module OpenC3
       value_str = value.is_a?(String) ? "'#{value}'" : value
       with_value = "with value == #{value_str}"
       if eval(string)
-        Logger.info "#{check_str} success #{with_value}"
+        puts "#{check_str} success #{with_value}"
       else
         message = "#{check_str} failed #{with_value}"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end

data/lib/openc3/script/calendar.rb

@@ -0,0 +1,109 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 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 'date'
+
+module OpenC3
+  module Script
+
+    private
+
+    def list_timelines(scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('get', "/openc3-api/timeline", scope: scope)
+      return _handle_response(response, 'Failed to list timelines')
+    end
+
+    def create_timeline(name, color: nil, scope: $openc3_scope, token: $openc3_token)
+      data = {}
+      data['name'] = name
+      data['color'] = color if color
+      response = $api_server.request('post', "/openc3-api/timeline", data: data, json: true, scope: scope)
+      return _handle_response(response, 'Failed to create timeline')
+    end
+
+    def get_timeline(name, scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('get', "/openc3-api/timeline/#{name}", scope: scope)
+      return _handle_response(response, 'Failed to get timeline')
+    end
+
+    def set_timeline_color(name, color, scope: $openc3_scope, token: $openc3_token)
+      post_data = {}
+      post_data['color'] = color
+      response = $api_server.request('post', "/openc3-api/timeline/#{name}/color", data: post_data, json: true, scope: scope)
+      return _handle_response(response, 'Failed to set timeline color')
+    end
+
+    def delete_timeline(name, force: false, scope: $openc3_scope, token: $openc3_token)
+      url = "/openc3-api/timeline/#{name}"
+      if force
+        url += "?force=true"
+      end
+      response = $api_server.request('delete', url, scope: scope)
+      return _handle_response(response, 'Failed to delete timeline')
+    end
+
+    def get_timeline_activities(name, start: nil, stop: nil, scope: $openc3_scope, token: $openc3_token)
+      url = "/openc3-api/timeline/#{name}/activities"
+      if start and stop
+        url += "?start=#{start}&stop=#{stop}"
+      end
+      response = $api_server.request('get', url, scope: scope)
+      return _handle_response(response, 'Failed to get timeline activities')
+    end
+
+    def create_timeline_activity(name, kind:, start:, stop:, data: {}, scope: $openc3_scope, token: $openc3_token)
+      kind = kind.to_s.downcase()
+      kinds = %w(command script reserve)
+      unless kinds.include?(kind)
+        raise "Unknown kind: #{kind}. Must be one of #{kinds.join(', ')}."
+      end
+      post_data = {}
+      post_data['start'] = start.to_datetime.iso8601
+      post_data['stop'] = stop.to_datetime.iso8601
+      post_data['kind'] = kind
+      post_data['data'] = data
+      response = $api_server.request('post', "/openc3-api/timeline/#{name}/activities", data: post_data, json: true, scope: scope)
+      return _handle_response(response, 'Failed to create timeline activity')
+    end
+
+    def get_timeline_activity(name, start: nil, scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('get', "/openc3-api/timeline/#{name}/activity/#{start}", scope: scope)
+      return _handle_response(response, 'Failed to get timeline activity')
+    end
+
+    def delete_timeline_activity(name, start, scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('delete', "/openc3-api/timeline/#{name}/activity/#{start}", scope: scope)
+      return _handle_response(response, 'Failed to delete timeline activity')
+    end
+
+    # Helper method to handle the response
+    def _handle_response(response, error_message)
+      return nil if response.nil?
+      if response.status >= 400
+        result = JSON.parse(response.body, :allow_nan => true, :create_additions => true)
+        raise "#{error_message} due to #{result['message']}"
+      end
+      # TODO: Not sure why the response body is empty (on delete) but check for that
+      if response.body.nil? or response.body.empty?
+        return nil
+      else
+        return JSON.parse(response.body, :allow_nan => true, :create_additions => true)
+      end
+    end
+  end
+end

data/lib/openc3/script/commands.rb

@@ -69,12 +69,12 @@ module OpenC3
     # NOTE: This is a helper method and should not be called directly
     def _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
       if no_range
-        Logger.warn "Command #{target_name} #{cmd_name} being sent ignoring range checks"
+        puts "WARN: Command #{target_name} #{cmd_name} being sent ignoring range checks"
       end
       if no_hazardous
-        Logger.warn "Command #{target_name} #{cmd_name} being sent ignoring hazardous warnings"
+        puts "WARN: Command #{target_name} #{cmd_name} being sent ignoring hazardous warnings"
       end
-      Logger.info _cmd_string(target_name, cmd_name, cmd_params, raw)
+      puts _cmd_string(target_name, cmd_name, cmd_params, raw)
     end
 
     def _cmd_disconnect(cmd, raw, no_range, no_hazardous, *args, scope: $openc3_scope)
@@ -95,7 +95,7 @@ module OpenC3
       end
 
       # Get the command and validate the parameters
-      command = $api_server.get_command(target_name, cmd_name, scope: scope)
+      command = $api_server.get_cmd(target_name, cmd_name, scope: scope)
       cmd_params.each do |param_name, param_value|
         param = command['items'].find { |item| item['name'] == param_name }
         unless param
@@ -108,7 +108,7 @@ module OpenC3
     # Send the command and log the results
     # This method signature has to include the keyword params present in cmd_api.rb cmd_implementation()
     # NOTE: This is a helper method and should not be called directly
-    def _cmd(cmd, cmd_no_hazardous, *args, scope: $openc3_scope, token: $openc3_token, timeout: nil, **kwargs)
+    def _cmd(cmd, cmd_no_hazardous, *args, timeout: nil, log_message: nil, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       raw = cmd.include?('raw')
       no_range = cmd.include?('no_range') || cmd.include?('no_checks')
@@ -118,14 +118,18 @@ module OpenC3
         _cmd_disconnect(cmd, raw, no_range, no_hazardous, *args, scope: scope)
       else
         begin
-          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args, scope: scope, token: token, timeout: timeout)
-          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args, timeout: timeout, log_message: log_message, scope: scope, token: token)
+          if log_message.nil? or log_message
+            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          end
         rescue HazardousError => e
           # This opens a prompt at which point they can cancel and stop the script
           # or say Yes and send the command. Thus we don't care about the return value.
           prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
-          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args, scope: scope, token: token, timeout: timeout)
-          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args, timeout: timeout, log_message: log_message, scope: scope, token: token)
+          if log_message.nil? or log_message
+            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          end
         end
       end
     end
@@ -171,12 +175,14 @@ module OpenC3
     # Builds a command binary
     #
     # Accepts two different calling styles:
-    #   build_command("TGT CMD with PARAM1 val, PARAM2 val")
-    #   build_command('TGT','CMD',{'PARAM1'=>val,'PARAM2'=>val})
-    def build_command(*args, **kwargs)
+    #   build_cmd("TGT CMD with PARAM1 val, PARAM2 val")
+    #   build_cmd('TGT','CMD',{'PARAM1'=>val,'PARAM2'=>val})
+    def build_cmd(*args, range_check: true, raw: false, scope: $openc3_scope, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       $api_server.build_command(*args)
     end
+    # build_command is DEPRECATED
+    alias build_command build_cmd
 
     # Returns whether the specified command is hazardous
     #
@@ -188,13 +194,6 @@ module OpenC3
       $api_server.get_cmd_hazardous(*args)
     end
 
-    # Sends raw data through an interface from a file
-    def send_raw_file(interface_name, filename, scope: $openc3_scope)
-      data = nil
-      File.open(filename, 'rb') { |file| data = file.read }
-      $api_server.send_raw(interface_name, data, scope: scope)
-    end
-
     # Returns the time the most recent command was sent
     def get_cmd_time(target_name = nil, command_name = nil, scope: $openc3_scope)
       results = $api_server.get_cmd_time(target_name, command_name, scope: scope)

data/lib/openc3/script/limits.rb

@@ -29,7 +29,7 @@ module OpenC3
       define_method(method_name) do |*args, **kw_args, &block|
         kw_args[:scope] = $openc3_scope unless kw_args[:scope]
         if $disconnect
-          Logger.info "DISCONNECT: #{method_name}(#{args}) ignored"
+          puts "DISCONNECT: #{method_name}(#{args}) ignored"
         else
           $api_server.public_send(method_name, *args, **kw_args, &block)
         end