rapidcode.proto

// This file describes the gRPC interface for the RapidCode services of RapidServer.
 
syntax = "proto3";
package RSI.RapidCodeRemote;
import "rsienums.proto";
import "rapidgrpc.proto";
 
/*** Service Definitions ***/
 
// Provides an interface for the RMP, and a way to interact with RapidCode objects
// (MotionController, Axis, MultiAxis, RTOS, etc.)
service RMPService {
  
  // RPC for MotionController: Sends config/actions, receives updated config, action details, status, and read-only info.
  rpc MotionController(MotionControllerRequest) returns (MotionControllerResponse) {};
 
  // RPC for Network: Sends config/actions, receives updated config, action details, status, and read-only info.
  rpc Network(NetworkRequest) returns (NetworkResponse) {};
 
  rpc Axis (AxisRequest) returns (AxisResponse) {};
  rpc AxisBatch (AxisBatchRequest) returns (AxisBatchResponse) {};
 
  // Use a zero-based index, unlike RapidCode which uses a motion index.
  rpc MultiAxis (MultiAxisRequest) returns (MultiAxisResponse) {};
  rpc MultiAxisBatch (MultiAxisBatchRequest) returns (MultiAxisBatchResponse) {};
 
  rpc NetworkNode (NetworkNodeRequest) returns (NetworkNodeResponse) {};
  rpc NetworkNodeBatch (NetworkNodeBatchRequest) returns (NetworkNodeBatchResponse) {};
 
  rpc Recorder (RecorderRequest) returns (RecorderResponse) {};
  rpc RecorderBatch(RecorderBatchRequest) returns (RecorderBatchResponse) {};
  
  rpc UserLimit (UserLimitRequest) returns (UserLimitResponse) {};
  rpc UserLimitBatch(UserLimitBatchRequest) returns (UserLimitBatchResponse) {};
 
  rpc RTOS(RTOSRequest) returns (RTOSResponse) {};
  rpc RTOSBatch(RTOSBatchRequest) returns (RTOSBatchResponse) {};
 
  rpc RTTask (RTTaskRequest) returns (RTTaskResponse) {};
  rpc RTTaskBatch(RTTaskBatchRequest) returns (RTTaskBatchResponse) {};
 
  rpc RTTaskManager (RTTaskManagerRequest) returns (RTTaskManagerResponse) {};
  rpc RTTaskManagerBatch(RTTaskManagerBatchRequest) returns (RTTaskManagerBatchResponse) {};
}
 
message MotionControllerConfig {
  // The number of Axis objects.
  optional int32 axis_count = 1; 
 
  // The number of MultiAxis objects.  (internal MotionCount - AxisCount)
  optional int32 multi_axis_count = 2;
 
  // The number of UserLimits.
  optional int32 user_limit_count = 3;
 
  // The number of data recorders.
  optional int32 recorder_count = 4;
 
  // The sizes of each recorder's buffer.
  repeated int32 recorder_buffer_sizes = 5;
 
  // The number of position compensators.
  optional int32 compensator_count = 6;
 
  // The number of points for each position compensator.
  repeated int32 compensator_point_counts = 7;
 
  // The size of each Axis' frame buffer. Must be power of 2.
  repeated int32 axis_frame_buffer_sizes = 8;
 
  // A 32-bit integer for users to specify a version.
  optional int32 user_version = 10;
 
  // A double to specify the sample rate in Hertz (samples per second)
  optional double sample_rate = 11;
}
 
 
 
 
message AddressInfo {
  // The requested address type.
  oneof address_type {
      RSIControllerAddressType controller = 1;
      RSIAxisAddressType axis = 2;
      RSIMultiAxisAddressType multi_axis = 3;
  }
 
  // The 64-bit host address from the server. This address can be used to configure the recorder.
  uint64 host_address = 4;
 
  // The data type at this address.  Useful for using the Recorder service.
  RSIDataType data_type = 5;
 
  // The internal 32-bit firmware address. (What you might see in VM3.)
  uint32 firmware_address = 6;
 
  // The 0-based object index for use when accessing Controller Addresses
  // Not used with Axis or MultiAxis addresses.
  optional int32 index = 7;
 
  // IO bit mask
  optional int32 mask = 8;
}
 
message MotionControllerMemory {
  message Integer {
    uint64 host_address = 1; 
    int32 value = 2;
  }
  message Double {
    uint64 host_address = 1;
    double value = 2;
  }
  message Block {
    uint64 host_address = 1;
    bytes values = 2;
    int32 size = 3;
  }
  oneof memory {
    Integer integer = 1;
    Double double = 2;
    Block block = 3;
  }
}
 
message MotionControllerCreationParameters {
  // Path to the RMP firmware (RMP.rta), license file, etc.
  optional string rmp_path = 1; 
  optional string node_name = 2; // [Windows/INtime] INtime Node used for RMP and RMPNetwork.
  
  optional string primary_nic = 3;
  optional string secondary_nic = 4;
 
  optional int32 cpu_affinity = 5; // [Linux] CPU used for RMP and RMPNetwork 
  optional int32 rmp_thread_priority_max = 6; // [Linux] Relative thread priority
 
  optional int32 controller_index = 7; // for future multiple controller support
}
 
message MotionControllerAction {
  // Create a MotionController. You must do this before using any other RapidCode remote service!
  optional MotionControllerCreationParameters create = 1;
 
  repeated MotionControllerMemory memory_sets = 2;
  repeated MotionControllerMemory memory_gets = 3;
  repeated AddressInfo address_gets = 4;
  optional Shutdown shutdown = 5;
  optional ProcessorUsageClear processor_usage_clear = 6;
  
  // shutdown the RMP
  message Shutdown {}
 
  // clear the RMP's processor usage 
  message ProcessorUsageClear {}
}
 
 
 
message MotionControllerInfo {
  // The RMP serial number.
  uint32 serial_number = 1;
 
  // The RapidCode version.
  string rapid_code_version = 2;
 
  // RMP firmware version.
  string firmware_version = 3;
 
  // The number of licensed Axis objects.
  int32 axis_license_count = 4; 
 
  repeated AddressInfo addresses = 5;
 
  // Constants from the MotionController object
  Constants constants = 6;
  
  message Constants {
    // Default time to wait when calling NetworkStart()
    uint32 network_start_timeout_milliseconds_default = 1;
 
    // Maximum number of Axis objects supported.
    uint32 axis_count_maximum = 2;
 
    // Maximum number of motion objects supported (One required for each Axis and MultiAxis).
    uint32 motion_count_maximum = 3;
 
    // Maximum number of nodes allowed on the network.
    uint32 network_node_count_maximum = 4;
 
    // maximum number of Recorder objects supported
    uint32 recorder_count_maximum = 5;
 
    // Maximum number of Position Compensator objects supported.
    uint32 compensator_count_maximum = 6;
 
    // Maximum number of 64-bit values that can be stored in the User Buffer.
    uint32 user_buffer_data_count_maximum = 7;
 
    // Default RMP sample rate in hertz.
    double sample_rate_default = 8;
 
    CreationParameters creation_parameters = 9;
 
    message CreationParameters {
      // MotionControllerAction::Create::rmp_path maximum string buffer length
      uint32 path_length_maximum = 1;
 
      // The default value of MotionControllerAction::Create::cpu_affinity
      uint32 cpu_affinity_default = 2;
 
      // The default value of MotionControllerAction::Create::rmp_thread_priority_max
      uint32 rmp_thread_priority_maximum_default = 3;
 
      // The range required for RMP and RMPNetwork threads. rmp_thread_priority_max must be greater than or equal to this value.
      uint32 rmp_thread_priority_range = 4;
    }
  }
 
  // The parameters that were used to create the MotionController.
  MotionControllerCreationParameters creation_parameters = 7;
}
 
 
 
message MotionControllerStatus {
  // The RMP sample counter. 
  int32 sample_counter = 1;
 
  // Network node count.
  uint32 network_node_count = 2;
 
  // The percentage of the firmware sample time used by the RMP.
  double processor_usage = 3;
 
  // The most recent time (in microseconds) between firmware samples
  uint32 firmware_timing_delta = 4;
 
  // The number of 32-bit words free in the RMP firmware memory.
  int32 external_memory_size = 9; 
}
 
 
 
message MotionControllerRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  optional MotionControllerConfig config = 2;
  optional MotionControllerAction action = 3;
}
 
 
message MotionControllerResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  optional MotionControllerConfig config = 2;
  optional MotionControllerAction action = 3;
  optional MotionControllerInfo info = 4;
  optional MotionControllerStatus status = 5;
}
 
message FirmwareValue {
  oneof value {
    bool bool_value = 1;
    int32 int8_value = 2;
    uint32 uint8_value = 3;
    int32 int16_value = 4;
    uint32 uint16_value = 5;
    int32 int32_value = 6;
    uint32 uint32_value = 7;
    float float_value = 8;
    double double_value = 9;
    int64 int64_value = 10;
    uint64 uint64_value = 11;
  }
}
 
message NetworkConfig {}
 
message NetworkAction {
  // Shutdown the network.  
  optional Shutdown shutdown = 1;
 
  // Start the network.
  optional Discover discover = 2;
  optional Start start = 3;
  optional DiscoverAndStart discover_and_start = 4;
 
  // Evaluate network timing.
  optional TimingMetricsEnable timing_metrics_enable = 5;
  optional TimingMetricsDisable timing_metrics_disable = 6;
  optional TimingMetricsClear timing_metrics_clear = 7;
 
  // Used to override firmware values with your custom outputs.
  repeated OutputOverride output_override = 8;
 
  // Generate ENI file
  optional EniGenerate eni_generate = 9;
 
  // Creating the object does the job.
  message Shutdown { }
 
  message Discover {
    // Default: MotionController::NetworkStartTimeoutMillisecondsDefault which is 30000 ms.
    optional uint32 timeout_milliseconds = 3;
  }
  message Start {
    // Default: RSINetworkStartModeOPERATIONAL.
    optional RSINetworkStartMode mode = 1;
    // Default: MotionController::NetworkStartTimeoutMillisecondsDefault which is 30000 ms.
    optional uint32 timeout_milliseconds = 2;
  }
 
  message DiscoverAndStart {
    // Default: RSINetworkStartModeOPERATIONAL.
    optional RSINetworkStartMode mode = 1;
    // Default: MotionController::NetworkStartTimeoutMillisecondsDefault which is 30000 ms.
    optional uint32 timeout_milliseconds = 2;
  }
 
  message TimingMetricsEnable {
    // Determines when low_count increases.
    optional uint32 low_threshold = 1;
    // Determines when high_count increases.
    optional uint32 high_threshold = 2;
  }
  message TimingMetricsDisable {}
  message TimingMetricsClear {}
 
  message OutputOverride {
    // Index of the output.
    int32 index = 1;
    // Turn on or off overriding of the firmware value with the override_value.
    optional bool override = 2;
    // Your custom value rather than our intended firmware value.
    optional int64 override_value = 3;
  }
 
  message EniGenerate {
    // result of the attempt to generate the ENI file.
    optional RSINetworkEniResult result = 1;
    // resulting output from rsiconfig (which is used to generate the ENI file)
    optional string output = 2;
  }
}
 
message NetworkRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  optional NetworkConfig config = 2;
 
  optional NetworkAction action = 3;
}
 
message NetworkResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  optional NetworkConfig config = 2;
  optional NetworkAction action = 3;
  optional NetworkInfo info = 4;
  optional NetworkStatus status = 5;
}
 
message NetworkStatus {
  RSINetworkState state = 1;
  int32 node_count = 2;
  int32 counter = 3;
  bool synchronized = 4;
  RSINetworkStartError last_start_error = 5;
  
  // output logged from RMPNetwork when it closes.
  string log_message = 6;
 
  // NetworkTiming in RapidCode.  Used to evaluate stability.
  TimingMetricsStatus timing_metrics = 7;
 
  // Collection of all Network PDO Inputs.
  repeated PdoInputStatus pdo_inputs = 8;
 
  // Collection of all Network PDO Outputs.
  repeated PdoOutputStatus pdo_outputs = 9;
 
  message TimingMetricsStatus {
    // Most recent value.
    uint32 delta = 1;
    // Lowest recorded since last clear.
    uint32 min_recorded = 2;
    // Highest recorded since last clear.
    uint32 max_recorded = 3;
    // Count below low_threshold since last clear.
    uint32 low_count = 4;
    // Count above high_threshold since last clear.
    uint32 high_count = 5;
  }
 
  message PdoInputStatus {
    // The index of this PDO in RMP firmware.
    int32 index = 1;
    // The raw 64-bit value of this PDO.
    int64 value = 2;
  }
 
  message PdoOutputStatus {
    // The index of this PDO in RMP firmware.
    int32 index = 1;
    // The raw 64-bit value that was sent on the network.
    int64 sent_value = 2;
    // The raw 64-bit override value that can be written by software.
    int64 override_value = 3;
    // The raw 64-bit value that the RMP is going to send, unless overridden.
    int64 firmware_value = 4;
    // Whether or not the override_value is being used.
    bool override_enabled = 5;
  }
}
 
message NetworkInfo {
  RSINetworkType type = 1;
  int32 pdo_input_count = 4;
  int32 pdo_output_count = 5;
 
  // Collection of all Network PDO Inputs.
  repeated PdoInputInfo pdo_inputs = 6;
 
  // Collection of all Network PDO Outputs.
  repeated PdoOutputInfo pdo_outputs = 7;
 
  message PdoInputInfo {
    string name = 1;
    AddressInfo address_info = 2;
    int32 bit_size = 3;
    int32 bit_offset = 4;
  }
 
  message PdoOutputInfo {
    string name = 1;
    AddressInfo sent_value_address = 2;
    AddressInfo override_value_address = 3;
    AddressInfo firmware_value_address = 4;
    int32 bit_size = 5;
    int32 bit_offset = 6;
  }
}
 
 
 
 
message AxisRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  // Axis index
  int32 index = 2;
 
  optional AxisConfig config = 3;
  optional AxisAction action = 4;
}
 
message AxisResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  // Axis index
  int32 index = 2;
 
  optional AxisConfig config = 3;
  optional AxisAction action = 4;
  optional AxisInfo info = 5;
  optional AxisStatus status = 6;
}
 
message AxisBatchRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated AxisRequest requests = 2;
}
 
message AxisBatchResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated AxisResponse responses = 2;
}
 
message AxisStatus {
  // Is the amp enabled?
  bool amp_enabled = 1;
 
  // The state (IDLE, MOVING, ERROR, etc.).
  RSIState state = 2;
 
  // The cause of the error (if in ERROR, STOPPED, STOPPING_ERROR state).
  RSISource source = 3;
 
  // Extra fault info from the drive
  string source_name = 4;
 
  // Positions.
  PositionStatus position = 5;
 
  // Command and actual velocity.
  VelocityStatus velocity = 6;
 
  // Command acceleration.
  AccelerationStatus acceleration = 7;
 
  // How many frames does the Axis have left to execute?
  int32 frames_to_execute = 8;
 
  // The motion id as stored in the Axis class (unsigned 16-bit integer).
  uint32 motion_id = 9;
 
  // The currently executing motion identifier (unsigned 16-bit integer).
  uint32 motion_id_executing = 10;
 
  // The currently exeucting motion element identifier (unsigned 16-bit integer).
  int32 element_id_executing = 11;
  
  // Is electronic gearing enabled?
  bool gear_enabled = 12;
 
  // Status bits related to the motor.
  MotorStatusBits motor_status_bits = 13;
 
  // Status bits related to motion.
  MotionStatusBits motion_status_bits = 14;
 
  // DS402 status bits, for drives that support DS402.
  Ds402StatusBits ds402_status_bits = 15;
 
  // Dedicated output bits.
  DedicatedOutputBits dedicated_output_bits = 16;
 
  // Dedicated input bits.
  DedicatedInputBits dedicated_input_bits = 17;
 
  // Homing status
  bool home_state = 18; 
  RSIHomeStage home_stage = 19;
 
  // The states of the general purpose input bits, DigitalInputsGet().
  uint32 general_input_bits = 20;
 
  // The states of the general purpose output bits, DigitalOutputsGet().
  uint32 general_output_bits = 21;
  
  message PositionStatus {
    double command = 1;
    double actual = 2;
    double error = 3;
    double target = 4;
    double origin = 5;
    double encoder_0 = 6;
    double encoder_1 = 7;
    double compensation = 8;
    double backlash = 9;
  }
 
  message VelocityStatus {
    double command = 1;
    double actual = 2;
  }
 
  message AccelerationStatus {
    double command = 1;
  }
 
  message MotorStatusBits {
    bool amp_fault = 1;
    bool amp_warning = 2;
    bool feedback_fault = 3;
    bool limit_position_error = 4;
    bool limit_torque = 5;
    bool limit_hardware_negative = 6;
    bool limit_hardware_positive = 7;
    bool limit_software_negative = 8;
    bool limit_software_positive = 9;
  }
 
  message MotionStatusBits {
    bool done = 1;
    bool start = 2;
    bool modify = 3;
    bool at_velocity = 4;
    bool out_of_frames = 5;
    bool near_target = 6;
    bool at_target = 7;
    bool settled = 8;
  }
 
   message Ds402StatusBits {
    bool ready_to_switch_on = 1;
    bool switched_on = 2;
    bool operation_enabled = 3;
    bool fault = 4;
    bool voltage_enabled = 5;
    bool quick_stop =  6;
    bool switch_on_disabled = 7;
    bool warning = 8;
    bool manufacturer_specific_8 = 9;
    bool remote = 10;
    bool target_reached = 11;
    bool internal_limit_active = 12;
    bool operation_mode_specific_12 = 13;
    bool operation_mode_specific_13 = 14;
    bool manufacturer_specific_14 = 15;
    bool manufacturer_specific_15 = 16;
  }
 
  message DedicatedOutputBits {
    bool amp_enable = 1;
    bool brake_release = 2;
  }
 
  message DedicatedInputBits {
    bool amp_fault = 1;
    bool brake_applied = 2;
    bool home = 3;
    bool limit_hardware_positive = 4;
    bool limit_hardware_negative = 5;
    bool index = 6;
    bool index_secondary = 7;
    bool feedback_fault = 8;
    bool captured = 9;
    bool hall_a = 10;
    bool hall_b = 11;
    bool hall_c = 12;
    bool amp_active = 13;
    bool warning = 14;
    bool drive_status_9 = 15;
    bool drive_status_10 = 16;
    bool feedback_fault_primary = 17;
    bool feedback_fault_secondary = 18;
  }
}
 
message AxisAction {  
  optional Abort abort = 1;
  optional EStopAbort e_stop_abort = 2;
  optional EStopModifyAbort e_stop_modify_abort = 3;
  optional EStopModify e_stop_modify = 4;
  optional EStop e_stop = 5;
  optional TriggeredModify triggered_modify = 6;
  optional Stop stop = 7;
  optional Resume resume = 8;
 
  optional ClearFaults clear_faults = 9;
  optional AmpEnable amp_enable = 10;
  optional AmpDisable amp_disable = 11;
  optional HoldGateSet hold_gate_set = 12;
  optional PositionSet position_set = 13;
  optional Move move = 14;
  optional GearEnable gear_enable = 15;
  optional GearDisable gear_disable = 16;
  optional Home home = 17;
  optional HomeCancel home_cancel = 18;
  optional OperationMode operation_mode_set = 19;
  optional OperationMode operation_mode_get = 20;
 
  message Abort {}
  message EStopAbort {}
  message EStopModifyAbort{}
  message EStopModify{}
  message EStop {}
  message TriggeredModify {}
  message Stop {}
  message Resume {}
 
  message ClearFaults {}
  
  message AmpEnable {
    optional int32 timeout_milliseconds = 1;
    optional int32 duration = 2; // read-only how long did it take to enable? only set if you specify a timeout to wait for AMP_ACTIVE
    optional bool override_restricted_state = 3; // if true, allows potentially dangerous enabling of an Amplifier even if it's in MOVING, STOPPING or STOPPED state
  }
  message AmpDisable {}
  message HoldGateSet {
    bool state = 1;
  }
  message PositionSet{
    double position = 1;
  }
 
  message Move {
    // Request one type of motion.
    oneof move {
        AxisMovePointToPoint point_to_point = 3;
        AxisMoveVelocity velocity = 4;
        MoveStreaming streaming = 5;
    }
 
    // Specify the MotionID for this move.  (If you don't specify one, it will be auto-incremented after each move.)
    optional uint32 motion_id = 6;
 
    // Specify MotionHold criteria, if you want the motion to hold execution until conditions are met.
    optional MotionHold motion_hold = 7;
 
    // Wait for motion to complete? (See ConfigSet settling criteria.)
    bool blocking = 8;
  }
 
  message GearEnable {
    optional int32 master_axis_number = 2;
    optional RSIAxisMasterType gearing_source = 3;
    int32 numerator = 4;
    int32 denominator = 5;
  }
  message GearDisable {}
 
  message Home {
    RSIHomeMethod method = 1;
    double velocity = 2;
    double slow_velocity = 3;
    double acceleration = 4;
    double deceleration = 5;
    optional double jerk_percent = 6;
    optional bool move_to_zero = 7;
    optional double offset = 8;
    optional RSIAction behavior = 9;
  }
 
  message HomeCancel {}
 
  message OperationMode {
    // For setting the operation mode in the request, or getting it from the response.
    optional RSIOperationMode operation_mode = 1;
  }
}
 
// Internal MoveRequest messages.
 message AxisMovePointToPoint {
  // Move to this position. Absolute, unless the relative boolean is true. (UserUnits)
  double position = 1;
 
  // Maximum velocity. (UserUnits/second).
  optional double velocity = 2;
 
  // Maximum acceleration. (UserUnits/second^2). If specified, velocity and deceleration must be specified.
  optional double acceleration = 3;
 
  // Maximum deceleration. (UserUnits/second^2). If specified, velocity and acceleration must be specified
  optional double deceleration = 4;
 
  // Percentage of acceleration that will be smoothed. (0-100)
  // Acceleration time will not change so if Jerk Percent is 100, maximum acceleration will be 2x the specified maximum.
  // If specified, velocity, acceleration, and deceleration must be specified.
  // A non-zero value makes the PointToPoint MoveSCurve
  optional double jerk_percent = 5;
 
  // Final velocity. 0.0 is default. (UserUnits/second)
  // If specified, velocity, acceleration, and deceleration must be specified.
  optional double final_velocity = 6;
 
  // Set true if you intend position to be a relative increment. If specified, jerk_percent must be specified.
  bool relative = 7;
}
 
message AxisMoveVelocity {
  // Move at this velocity. (UserUnits/second)
  double velocity = 1;
 
  // Maximum acceleration. (UserUnits/second^2)
  double acceleration = 2;
 
  // Percentage of acceleration that will be smoothed. (0-100)
  // Acceleration time will not change so if Jerk Percent is 100, maximum acceleration will be 2x the specified maximum.
  // A non-zero value uses MoveVelocitySCurve
  double jerk_percent = 3;
}
 
message MoveStreaming {
  repeated double positions = 1;
  repeated double velocities = 2;
  repeated double accelerations = 3;
  repeated double jerks = 4;
  repeated double times = 5;
  int32 empty_count = 6;
  bool retain = 7;
  bool final = 8;
 
  // Specify the interpolation algorithm to use when only providing positions and no velocities nor accelerations.
  // Uses the RapidCode method RapidCodeMotion::MovePT()
  // The three currently supported ones are:
  //  RSIMotionTypePT (no interpolation)
  //  RSIMotionTypeBSPLINE (default)
  //  RSIMotionTypePVT is used in the RapidCode method RapidCodeMotion::MovePVT(), i.e. when positions and velocities are given.
  optional RSIMotionType pt_motion_type = 9;
}
 
message MotionHoldGate{
  int32 number = 1;
}
 
message MotionHoldAxis {
  // If true, motion will hold for Actual Position. If false, it will hold for Command Position.
  bool actual = 1;
  
  // Greater than, less than, etc.
  RSIUserLimitLogic logic = 2;
 
  // The number of the Axis whose position we're waiting for.
  int32 hold_axis_number = 3;
 
  // The position of the hold axis which will trigger the hold to finish.
  double hold_axis_position = 4;
}
 
message MotionHoldUser {
  // The 64-bit host address on the server.
  uint64 address = 1;
 
  // The 32-bit mask that will be ANDed with the value stored at the User Address.
  int32 mask = 2;
 
  // The 32-bit mask that will compared for equality after the AND mask.
  int32 pattern = 3;
}
 
message MotionHold {
  // Choose the type of hold.
  oneof type {
    MotionHoldGate gate = 2;
    MotionHoldAxis axis = 3;
    MotionHoldUser user = 4;
  }
  
  // The motion will execute regardless of hold status after this amount of time.
  optional double hold_timeout_seconds = 6;
 
  // This optional delay will occur before motion starts.
  optional double delay_seconds = 7;
}
 
message AxisConfig {
  // The number of encoder counts to UserUnits.
  optional double user_units = 1;
 
  // The origin position, typically set when homing.
  optional double origin_position = 2;
 
  // Give the Axis a name, if you like.
  optional string user_label = 3;
 
  // Default trajectory values.
  optional TrajectoryDefaults defaults = 4;
  optional HardwareTrigger amp_fault = 5;
  optional HardwareTrigger home_switch = 6;
  optional ErrorLimit error_limit = 7;
  optional HardwareTrigger hardware_negative_limit = 8;
  optional HardwareTrigger hardware_positive_limit = 9;
  optional SoftwareTrigger software_negative_limit = 10;
  optional SoftwareTrigger software_positive_limit = 11;
  optional Settling settling = 12;
  optional MotionConfig motion = 13;
  optional Homing homing = 14;
  optional int32 frame_buffer_size = 15;
  optional RSIMotorDisableAction amp_disable_action = 16;
  optional double feed_rate = 17;
 
  // Internal messages.
  message TrajectoryDefaults
  {
    optional double velocity = 1;
    optional double acceleration = 2;
    optional double deceleration = 3;
    optional double jerk_percent = 4;
    optional double position1 = 5;
    optional double position2 = 6;
    optional double relative_increment = 7;
  }
 
  message HardwareTrigger {
    optional RSIAction action = 1;
    optional bool trigger_state = 2;
    optional double duration = 3;
  }
 
  message SoftwareTrigger {
    optional RSIAction action = 1;
    optional double trigger_value = 2;
  }
 
  message ErrorLimit {
    optional RSIAction action = 1;
    optional double trigger_value = 2;
    optional double duration = 3;
  }
 
  message Settling {
    optional double position_tolerance_fine = 1;
    optional double position_tolerance_coarse = 2;
    optional double velocity_tolerance = 3;
    optional double time_seconds = 4;
    optional bool on_stop = 5;
    optional bool on_estop = 6;
    optional bool on_estop_cmd_equals_actual = 7;
  }
 
  message MotionConfig {
    // Seconds.
    optional double stop_time = 1;
  
    // Seconds.
    optional double estop_time = 2;
  
    // UserUnits per second.
    optional double triggered_modify_deceleration = 3;
  
    // Jerk percent (0-100).
    optional double triggered_modify_jerk_percent = 4;
 
    // UserUnits per second.
    optional double estop_modify_deceleration = 5;
 
    // Jerk percent (0-100).
    optional double estop_modify_jerk_percent = 6;
  }
  message Homing {
    // placeholder for possible future homing configuration.  see Action for Home configuration.
  }
}
 
message AxisInfo {
  // Axis index.
  int32 index = 1;
    
  // Host and firmware addresses
  repeated AddressInfo addresses = 2;
 
  // NetworkNode information.
  NetworkNodeInfo node_info = 3;
  
  // Constants from the Axis object
  Constants constants = 4;
 
  // The internal motion supervisor index
  int32 motion_supervisor_index = 5;
  
  message Constants {
    // The value returned by NetworkIndexGet() when the index is invalid or nonexistent for this Axis.
    uint32 network_index_invalid = 1;
    
    // The default time an Axis waits before generating an AmpFault if the Axis does not enable after calling AmpEnableSet(true).
    double amp_enable_amp_fault_timeout_seconds_default = 2;
  }
 
}
 
 
message MultiAxisRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  // MultiAxis index
  int32 index = 2;
 
  optional MultiAxisConfig config = 3;
  optional MultiAxisAction action = 4;
}
 
message MultiAxisResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  // MultiAxis index
  int32 index = 2;
 
  optional MultiAxisConfig config = 3;
  optional MultiAxisAction action = 4;
  optional MultiAxisInfo info = 5;
  optional MultiAxisStatus status = 6;
}
 
message MultiAxisBatchRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated MultiAxisRequest requests = 2;
}
 
message MultiAxisBatchResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated MultiAxisResponse responses = 2;
}
 
 
message MultiAxisStatus {
  RSIState state = 1;
  RSISource source = 2;
  string source_name = 3;
  bool amp_enabled = 4;
  MotionStatusBits motion_status_bits = 5;
  repeated AxisStatus axis_statuses = 6;
  bool is_mapped = 7;
 
  message MotionStatusBits {
    bool done = 1;
    bool start = 2;
    bool modify = 3;
    bool at_velocity = 4;
    bool out_of_frames = 5;
  }
}
 
message MultiAxisAction {
  optional Abort abort = 1;
  optional EStopAbort e_stop_abort = 2;
  optional EStopModifyAbort e_stop_modify_abort = 3;
  optional EStopModify e_stop_modify = 4;
  optional EStop e_stop = 5;
  optional TriggeredModify triggered_modify = 6;
  optional Stop stop = 7;
  optional Resume resume = 8;
 
  optional ClearFaults clear_faults = 9;
  optional AmpEnable amp_enable = 10;
  optional AmpDisable amp_disable = 11;
  optional Move move = 12;
  optional RemoveAxes remove_axes = 13;
  optional Unmap unmap = 14;
  optional Map map = 15;
  optional AxisAdd axis_add = 16;
 
  message Abort {}
  message EStopAbort {}
  message EStopModifyAbort{}
  message EStopModify{}
  message EStop {}
  message TriggeredModify {}
  message Stop {}
  message Resume {}
 
  message ClearFaults {}
 
  message AmpEnable {
    optional int32 timeout_milliseconds = 1;
    optional int32 duration = 2; // read-only how long did it take to enable? only set if you specify a timeout to wait for AMP_ACTIVE
    optional bool override_restricted_state = 3; // if true, allows potentially dangerous enabling of an Amplifier even if it's in MOVING, STOPPING or STOPPED state
  }
  message AmpDisable {}
 
  message Move {
    oneof move {
        MultiAxisMovePointToPoint point_to_point = 3;
        MultiAxisMoveVelocity velocity = 4;
        MoveStreaming streaming = 5;
    }
    optional uint32 motion_id = 6;
 
    // Specify MotionHold criteria, if you want the motion to hold execution until conditions are met.
    optional MotionHold motion_hold = 7;
 
    bool blocking = 8;
 
    message MultiAxisMovePointToPoint {
      repeated AxisMovePointToPoint axis_move_point_to_points = 1;
      bool relative = 2;
    }
 
    message MultiAxisMoveVelocity {
      repeated AxisMoveVelocity axis_move_velocities = 1;
    }
  }
  message RemoveAxes {}
  message Unmap {}
  message Map {}
  message AxisAdd {
    int32 axis_index = 1;
  }
}
 
message MultiAxisConfig {
  repeated int32 axes_indices = 1;
  optional string user_label = 2;
  optional double feed_rate = 3;
  optional double stop_time = 4;
  optional double e_stop_time = 5;
}
 
message MultiAxisInfo {
  // The zero-based index for this MultiAxis.
  int32 index = 1;
 
  // The internal motion supervisor index.
  int32 motion_supervisor_index = 2;
 
  // Host and firmware addresses
  repeated AddressInfo addresses = 3;
}
 
message NetworkNodeInfo {
  // True if hardware exists.
  bool exists = 1;
 
  // The node index.
  int32 index = 2;
 
  // The number of Axis objects on this node.
  int32 axis_count = 3;
 
  // True if this node has I/O.
  bool has_io = 4;
 
  // The number of digital/analog inputs and outputs on this node.
  IOCounts io_counts = 5;
 
  // The bit masks and 64-bit host addresses for this node's I/O.
  IOAddresses io_addresses = 6;
 
  // The node type.
  RSINodeType type = 7;
 
  // 32-bit vendor identifier.
  uint32 vendor_id = 8;
 
  // 32-bit product code.
  uint32 product_code = 9;
 
  // 32-bit hardware revision.
  uint32 hardware_revision = 10;
  
  // Station alias.
  uint32 station_alias = 11;
 
  // Serial number.
  string serial_number = 12;
 
  // The node's name.
  string name = 13;
 
  // Product name.
  string product_name = 14;
 
  // Vendor name.
  string vendor_name = 15;
 
  Constants constants = 16;
 
 
  // Internal messages.
 
  // The number of digital/analog inputs and outputs.
  message IOCounts {
    // Number of digital inputs.
    int32 digital_inputs = 1;
 
    // Number of digital outputs.
    int32 digital_outputs = 2;
 
    // Number of analog inputs.
    int32 analog_inputs = 3;
 
    // Number of analog outputs.
    int32 analog_outputs = 4;
  }
 
  message IOAddresses {
    // Masks and 64-bit host addresses for each digital input.
    repeated AddressInfo digital_inputs = 1;
 
    // Masks and 64-bit host addresses for each digital output.
    repeated AddressInfo digital_outputs = 2;
 
    // Masks and 64-bit host addresses for each analog input.
    repeated AddressInfo analog_inputs = 3;
 
    // Masks and 64-bit host addresses for each analog output.
    repeated AddressInfo analog_outputs = 4;
  }
 
  message Constants {
    // Default time to wait when reading or writing an SDO with ServiceChannelRead() or ServiceChannelWrite()
    uint32 sdo_timeout_milliseconds_default = 1;
  }
}
 
message NetworkNodeStatus {
  // All the digital input states.
  repeated bool digital_input_states = 2;
 
  // All the digital output states.
  repeated bool digital_output_states = 3;
  
  // All the analog input values.
  repeated int32 analog_input_values = 4;
 
  // All the analog output values.
  repeated int32 analog_output_values = 5;
}
 
 
// The state of the digital output at the specified bit number.
message DigitalOutput {
  // The bit number.
  int32 bit_number = 1;
 
  // The state of the digital output. When this message is used as a request
  //  to set a digital output, the digital output will be set to this value.
  //  When this message is returned as an action response, this field holds the
  //  new state.
  bool state = 2;
}
 
// The value of the analog output at the specified channel.
message AnalogOutput {
  // The channel number.
  int32 channel = 1;
 
  // The value of the analog output. When this message is used as a request
  //  to set an analog output, the analog output will be set to this value.
  //  When this message is returned as an action response, this field holds the
  //  new value.
  int32 value = 2;
}
 
// The location, size, and value of a Service Data Object (SDO).
// This message is used to read or write SDOs on a network node.
// See NetworkNodeAction sdo_writes and sdo_reads.
message SDO {
  // The SDO index.
  int32 index = 1;
 
  // The SDO sub-index.
  int32 sub_index = 2;
 
  // The number of bytes.
  int32 byte_count = 3;
 
  // The types of data values we can read or write.
  enum ValueType {
    option allow_alias = true;
    UNKNOWN = 0;
    INTEGER = 0;
    STRING = 1;
    BYTES = 2;
  }
 
  // When reading an SDO, specify the read type.  Default is integer.
  optional ValueType read_type = 4;
 
  // Wait this long for a response, otherwise it will throw a timeout error.
  optional uint32 timeout_milliseconds = 5;
 
  // The SDO value. 
  // SDO write: This field is used to set the value to write.
  // SDO read: This field is ignored when SDO read action request, but will contain the
  //  value read from the SDO in the SDO read action response.
  oneof value {
    // Integer value used for all non-string types.
    int32 integer_value = 6;
 
    // String value.
    string string_value = 7;
 
    // Raw bytes value
    bytes bytes_value = 8;
  }
}
 
// An ASCII command to execute on an AKD drive.
message AKDASCII {  
  // The command as a string.
  string command = 1;
 
  // The returned result of the command. This field is ignored when requesting
  //  an AKDASCII command.
  optional string result = 2;
}
 
// A set of actions to perform on a network node. This message is used to 
//  request a set of actions. A new instance of this message will be returned
//  containing the results of the requested acitons.
message NetworkNodeAction {
 
  // Any number of digital outputs to set. Add instances of the DigitalOutput
  //  message to this field to set digital outputs. When this message is
  //  returned in the action response, this field contains the new states of
  //  the digital outputs.
  repeated DigitalOutput digital_output_sets = 1;
 
  // Any number of analog outputs to set. Add instances of the AnalogOutput
  //  message to this field to set analog outputs. When this message is 
  //  returned in the action response, this field contains the new values of
  //  the analog outputs.
  repeated AnalogOutput analog_output_sets = 2;
 
  // The requested SDO value(s) to write to the network. Add instances of the
  //  SDO message to this field to write to SDOs. When this message is returned
  //  in the action response, this field will be empty.
  repeated SDO sdo_writes = 3;
 
  // The SDO(s) to be read from the network. Add instances of the SDO message
  //  to this field to read SDO values. When this message is returned in the 
  //  action response, the SDO messages will contain the read values.
  repeated SDO sdo_reads = 4;
 
  // AKD ASCII command(s). Only used for Kollmorgen AKD drives. Add instances
  //  of the AKDASCII message to request an ASCII command. When this message
  //  is returned in the action response, the AKDASCII messages will contain
  //  both the command executed and the returned result as a string.
  repeated AKDASCII akd_asciis = 5;
}
 
message NetworkNodeConfig {}
 
message NetworkNodeRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  // Network Node index
  int32 index = 2;
 
  optional NetworkNodeConfig config = 3;
  optional NetworkNodeAction action = 4;
}
 
message NetworkNodeResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  // Network Node index
  int32 index = 2;
 
  optional NetworkNodeConfig config = 3;
  optional NetworkNodeAction action = 4;
  optional NetworkNodeInfo info = 5;
  optional NetworkNodeStatus status = 6;
}
 
message NetworkNodeBatchRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated NetworkNodeRequest requests = 2;
}
 
message NetworkNodeBatchResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated NetworkNodeResponse responses = 2;
}
 
 
message RecorderRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  // The Recorder index. (Check MotionController's Recorder count.)
  int32 index = 2;
 
  optional RecorderConfig config = 3;
  optional RecorderAction action = 4;
}
 
 
message RecorderResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  // Recorder index
  int32 index = 2;
 
  optional RecorderConfig config = 3;
  optional RecorderAction action = 4;
  optional RecorderInfo info = 5;
  optional RecorderStatus status = 6;
}
 
message RecorderBatchRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated RecorderRequest requests = 2;
}
 
message RecorderBatchResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated RecorderResponse responses = 2;
}
 
 
message RecorderInfo { }
 
message RecorderStatus {
  // Is the Recorder recording?
  bool is_recording = 1;
 
  // The number of records available for retrieval.
  int32 records_available = 2;
}
 
message RecorderAction {
  
  optional Reset reset = 1;
  optional Start start = 2;
  optional Stop stop = 3;
  optional RetrieveRecords retrieve_records = 4;
 
  message Reset {}
  message Start {}
  message Stop {}
  
  message RetrieveRecords {
    // New data records will be in the response, if any are available.
    repeated Record records = 1;
    
    // A data record from the recorder.
    message Record {
      // The number of these will depend on the number of addresses to record in the recorder configuration.
      repeated Data data = 1;
      
      // Type will depend on what is set in config for each address.
      message Data {
        // Keep the names short to keep packet sizes smaller.
        oneof data {
          double d = 1;
          int32 i32 = 2;
        }
      }
    }
  }
}
 
 
message RecorderConfig {
  // Recorder period, in samples.
  optional int32 period = 1;
 
  // If true, the recorder will use a circular buffer, overwriting old data (be sure to read it out).
  optional bool circular_buffer = 2;
 
  // The addresses to record. Get these from Controller/Axis/MultiAxis InfoGet rpcs.
  repeated AddressInfo addresses = 3;
  
  // Use this to start and end recording with motion.
  optional RecorderTriggerOnMotion trigger_on_motion = 4;
 
  // Configure the recorder to generate a RECORDER_HIGH interrupt when the buffer reaches this size.
  optional int32 buffer_high_count = 5;
 
  // Read-only, this tells us how many records fit inside the recorder's buffer (see MotionController config's recorder buffer size).
  optional int32 record_max_count = 6;
 
  // Internal messages.
 
  message RecorderTriggerOnMotion {
    // Use an Axis or MutliAxis's motion supervisor index.
    optional int32 motion_supervisor_index = 1;
    // Set true if you want the recorder to start when motion starts and stop when motion is done.
    optional bool enable = 2;
  }
}
 
 
message UserLimitStatus {
  // The UserLimit's index.
  int32 index = 1;
 
  // Is the UserLimit processing in the RMP firmware_version?
  bool enabled = 2; 
 
  // Is the UserLimit currently triggered?
  bool state = 3; 
}
 
message UserLimitAction {
  
  optional Reset reset = 1;
  optional Enable enable = 2;
  optional Disable disable = 3;
 
  message Reset {};
  message Enable {};
  message Disable {};
}
 
 
message UserLimitInfo {}
 
 
message UserLimitConfig {
 
  // The type of trigger.
  optional RSIUserLimitTriggerType trigger_type = 1;
 
  // The primary condition.
  optional UserLimitCondition condition_0 = 2;
 
  // The second condition. Condition 1 will not be set if trigger type is SINGLE_CONDITION or invalid
  optional UserLimitCondition condition_1 = 3; 
 
  // Optionally set some output when the UserLimit triggers.
  optional UserLimitOutput output = 4;
 
  // Optionally perform an action on an Axis when the UserLimit triggers.
  optional RSIAction action = 5;
 
  // Perform the optional action on this Axis.
  optional int32 action_axis = 6;
 
  // Duration the trigger state must be active before triggering.  (Seconds)
  optional double duration = 7;
 
  // True if the UserLimit should trigger once, then disable itself.
  optional bool is_single_shot = 8;
 
  // Configurable interrupt data.
  repeated UserLimitInterruptUserData user_data = 9;
 
  // Internal messages.
  message UserLimitCondition {
    // The data type to be evaluated.
    RSIDataType data_type = 1;
 
    // The logic of the UserLimit.
    RSIUserLimitLogic logic = 2;
 
    // A 64-bit host address, see InfoGet on MotionController, Axis, MultiAxis.
    uint64 address = 3;
 
    // A 32-bit AND mask.
    optional uint32 mask = 4;
 
    // The 32-bit trigger value. (for 32-bit data types)
    optional int32 integer_limit_value = 5;
 
    // The 64-bit double trigger value (for 64-bit doubles data types only).
    optional double double_limit_value = 6;
  }
 
  message UInt32Masks {
    // 32-bit AND mask.
    uint32 and_mask = 1;
 
    // 32-bit OR mask.
    uint32 or_mask = 2;
  }
 
  message UInt64Masks {
    // 64-bit AND mask.
    uint64 and_mask = 1;
  
    // 64-bit OR mask;
    uint64 or_mask = 2;
  }
 
  message UserLimitOutput {
    // True if enabled
    bool enabled = 2;
 
    // The type of data to output.
    RSIDataType data_type = 3;
 
    // A 64-bit host address, see InfoGet on MotionController, Axis, MultiAxis.
    uint64 address = 4;
 
    // The type of output.
    oneof output {
      // Perform an AND and OR on a 64-bit value.
      UInt32Masks uint32_masks = 6;
 
      // Output a 32-bit value.
      int32 int32_value = 7;
 
      // Perform an AND and OR on a 64-bit value.
      UInt64Masks uint64_masks = 8;
 
      // Output a 64-bit double.
      double double_value = 9;
 
      // A 64-bit host address, see InfoGet on MotionController, Axis, MultiAxis.
      // Use this field when you want the UserLimit to copy data from the input address to the output address.
      uint64 input_address = 10;
    }
  }
 
  message UserLimitInterruptUserData {
    // Interrupt data index (0-4).
    uint32 index = 1;
 
    // A 64-bit host address, see InfoGet on MotionController, Axis, MultiAxis.
    optional uint64 address = 2;
  }
}
 
message UserLimitRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  // UserLimit index.
  int32 index = 2;
 
  optional UserLimitConfig config = 3;
 
  optional UserLimitAction action = 4;
}
 
message UserLimitResponse {
  // Common response header. Always check the response header for errors.  
  RSI.RapidServer.ResponseHeader header = 1;
 
  // UserLimit index.
  int32 index = 2;
 
  optional UserLimitConfig config = 3;
  optional UserLimitAction action = 4;
  optional UserLimitInfo info = 5;
  optional UserLimitStatus status = 6;
}
 
message UserLimitBatchRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated UserLimitRequest requests = 2;
}
 
message UserLimitBatchResponse {
  // Common response header. Always check the response header for errors.  
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated UserLimitResponse responses = 2;
}
 
message RTOSConfig {}
 
message RTOSInfo {
  // The RMP process catalog.
  string rmp_catalog = 1;
 
  // The RMPNetwork process catalog.
  string rmp_network_catalog = 2;
 
  // The number of INtime nodes.
  uint32 node_count = 3;
}
 
message RTOSAction {
  optional Restart restart = 1;
  optional Stop stop = 2;
  optional Start start = 3;
 
  message Restart {}
  message Stop {}
  message Start {}
}
 
message RTOSStatus {
  // The status of the INtime node
  INtimeStatus status = 3;
}
 
message RTOSRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
  
  // Specify a specific INtime node by name.
  string name = 2;
 
  optional RTOSConfig config = 3;
  optional RTOSAction action = 4;
}
 
message RTOSResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  // Specify a specific INtime node by name.
  string name = 2;
 
  optional RTOSConfig config = 3;
  optional RTOSAction action = 4;
  optional RTOSInfo info = 5;
  optional RTOSStatus status = 6;
}
 
message RTOSBatchRequest {
  // Common request header
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated RTOSRequest requests = 2;
}
 
message RTOSBatchResponse {
  // Common response header. Always check the response header for errors.
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated RTOSResponse responses = 2;
}
 
enum RTTaskState {
  RTTaskStateUNKNOWN = 0;
  RTTaskStateDEAD = 1;
  RTTaskStateDISABLED = 2;
  RTTaskStateWAITING = 3;
  RTTaskStateRUNNING = 4;
}
 
enum RTTaskManagerState {
  RTTaskManagerStateUNKNOWN = 0;
  RTTaskManagerStateDEAD = 1;
  RTTaskManagerStateRUNNING = 2;
  RTTaskManagerStateSTOPPED = 3;
}
 
enum PlatformType {
  PlatformTypeUNKNOWN = 0;
  PlatformTypeNATIVE = 1;
  PlatformTypeINTIME = 2;
  PlatformTypeLINUX = 3;
  PlatformTypeWINDOWS = 4;
}
 
// TaskPriority enum for RTTaskManager/RTTask
// This is the ground truth for the RapidCodeRemote API.
enum TaskPriority {
  TaskPriorityNONREALTIME = 0;
  TaskPriorityLOWEST = 1;
  TaskPriorityLOW = 2;
  TaskPriorityMEDIUMLOW = 3;
  TaskPriorityMEDIUM = 4;
  TaskPriorityMEDIUMHIGH = 5;
  TaskPriorityHIGH = 6;
  TaskPriorityHIGHEST = 7;
}
 
message RTTaskCreationParameters {
  // The name of the function to run in the task
  string function_name = 1;
 
  // The task functions library directory and name.
  optional string library_name = 2;
  optional string library_directory = 3;
 
  // The task's user defined label.
  optional string user_label = 4;
 
  // The task's priority. 0 is the highest priority, 255 is the lowest.
  optional TaskPriority priority = 5;
 
  // Number of times to repeat the task. -1 means infinite.
  optional int32 repeats = 6;
 
  // How frequently to run the task in samples
  optional int32 period = 7;
 
  // Offset in samples for when to run the task. For example, if the task is set
  // to run every 10 samples, and the phase is set to 3, the task will run at
  // 3, 13, 23, etc.
  optional int32 phase = 8;
 
  // Whether to record execution time metrics for the task.
  optional bool enable_timing = 9;
}
 
message RTTaskConfig {}
 
 
message RTTaskAction {
  // Stop the task.
  optional Stop stop = 1;
 
  // Remove the current task from the task manager
  optional Remove remove = 2;
 
  // Reset the timing metrics for the task. (ExecutionTimeMax, Min, Mean, Last)
  optional TimingReset timing_reset = 3;
 
  // Wait until the task has executed this many times before returning.
  optional ExecutionCountAbsoluteWait execution_count_absolute_wait = 4;
 
  // Wait until the task has executed this many more times before returning.
  optional ExecutionCountRelativeWait execution_count_relative_wait = 5;
 
  message Stop {}
  message Remove {}
  message TimingReset {}
  
  message ExecutionCountAbsoluteWait {
    // Wait until the task has executed this many times total.
    optional int64 count = 1;
 
    // The maximum time to wait for the task to execute the specified number of times.
    optional int32 timeout_ms = 2;
  }
 
  message ExecutionCountRelativeWait {
    // Wait until the task has executed this many more times from the current count.
    optional int64 count = 1;
 
    // The maximum time to wait for the task to execute the specified number of times.
    optional int32 timeout_ms = 2;
  }
}
 
message RTTaskInfo {
  // The unique id of the task (not unique across task managers).
  int32 id = 1;
 
  // The id of the task manager that created this task.
  int32 manager_id = 2;
 
  // Constants related to the RTTask class.
  Constants constants = 3;
 
  // The parameters that were used to create the task.
  RTTaskCreationParameters creation_parameters = 4;
 
  message Constants {
    // Constants related to the RTTask creation parameters.
    CreationParameterConstants creation_parameters = 1;
 
    // Constants related to the RTTask status.
    StatusConstants status = 2;
    
    message CreationParameterConstants {
      // The maximum length of the library directory path.
      int32 directory_length_maximum = 1;
 
      // The maximum length of the library name and user label.
      int32 name_length_maximum = 2;
 
      // The default library name to use if none is specified.
      string library_name_default = 3;
      
      // The default task priority.
      int32 priority_default = 4;
 
      // The special value for the repeats field to indicate infinite repeats.
      int32 repeat_forever = 5;
 
      // The special value for the repeats field to indicate no repeats.
      int32 repeat_none = 6;
 
      // The default period for the task.
      int32 period_default = 7;
 
      // The default phase for the task.
      int32 phase_default = 8;
 
      // The default value for the enable_timing field.
      int32 enable_timing_default = 9;
    }
 
    message StatusConstants {
      // The special value for the execution count to indicate an invalid count.
      int64 invalid_execution_count = 1;
 
      // The special value for the execution time to indicate an invalid time.
      uint64 invalid_execution_time = 2;
 
      // The maximum size of the error message.
      uint64 error_message_size_maximum = 3;
    }
  }
}
 
message RTTaskStatus {
  // The current state of the task (running, waiting, etc.)
  RTTaskState state = 1;
 
  // The number of times the task has executed.
  optional int64 execution_count = 2;
 
  // The maximum execution time of the task (in nanoseconds).
  optional uint64 execution_time_max = 3;
 
  // The minimum execution time of the task (in nanoseconds).
  optional uint64 execution_time_min = 4;
 
  // The mean execution time of the task (in nanoseconds).
  optional double execution_time_mean = 5;
 
  // The most recent execution time for the task (in nanoseconds).
  optional uint64 execution_time_last = 6;
 
  // The time since the task was last started (in nanoseconds).
  optional uint64 start_time_delta_last = 7;
 
  // The maximum time difference between the start of one task execution and the next (in nanoseconds).
  optional uint64 start_time_delta_max = 8;
 
  // The mean time difference between the start of one task execution and the next (in nanoseconds).
  optional double start_time_delta_mean = 9;
 
  // If the task is in an error state, this will contain the error message.
  optional string error_message = 10;
}
 
message RTTaskRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  // The id of the task. This is the id assigned to the task when it was created.
  int32 id = 2;
 
  // The id of the task manager that the task was submitted to.
  int32 manager_id = 3;
 
  optional RTTaskConfig config = 4;
  optional RTTaskAction action = 5;
}
 
message RTTaskResponse {
  // Common response header. Always check the response header for errors.  
  RSI.RapidServer.ResponseHeader header = 1;
 
  // The id of the task. This is the id assigned to the task when it was created.
  int32 id = 2;
 
  // The id of the task manager that the task was submitted to.
  int32 manager_id = 3;
 
  optional RTTaskConfig config = 4;
  optional RTTaskAction action = 5;
  optional RTTaskInfo info = 6;
  optional RTTaskStatus status = 7;
}
 
message RTTaskBatchRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated RTTaskRequest requests = 2;
}
 
message RTTaskBatchResponse {
  // Common response header. Always check the response header for errors.  
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated RTTaskResponse responses = 2;
}
 
message RTTaskManagerCreationParameters {
  // Where the rttaskmanager executable is located (usually the RSI installation directory).
  optional string rt_task_directory = 1;
 
  // The platform to run the task manager on. Not needed on Linux. On Windows/INtime,
  // use INTIME for real time performance. Only use WINDOWS for debugging.
  optional PlatformType platform = 2;
 
  // For INtime managers, the name of the INtime node to run on (usually NodeA).
  optional string node_name = 3;
  
  // On Linux, the CPU core to pin the task manager to.
  optional int32 cpu_core = 4;
 
  // The task manager's user defined label.
  optional string user_label = 5;
 
  // Disable the initialization of the RMP and RapidCode objects on task manager startup and their use in synchronizing task manager cycles.
  optional bool no_rmp = 6;
}
 
message RTTaskManagerConfig {}
 
 
message RTTaskManagerAction {
  // Start a new task manager.
  optional Create create = 1;
 
  // Discover the task managers that are currently running.
  optional Discover discover = 2;
 
  // Shutdown the task manager.
  optional Shutdown shutdown = 3;
 
  // Submit and start a new task.
  optional TaskSubmit task_submit = 4;
 
  // Remove a task from the task manager.
  optional TaskRemove task_remove = 5;
 
  // Set the values of global variables
  repeated GlobalValueSet global_value_sets = 6;
 
  message Create {
    // The task manager's creation parameters.
    RTTaskManagerCreationParameters creation_parameters = 1;
 
    // The id of the created task manager.
    int32 id = 2; // read-only
  }
 
  message Discover {
    // The ids of all the task managers that were discoverd
    repeated int32 manager_ids = 1;  // read-only
  }
 
  message Shutdown {}
 
  message TaskSubmit {
    // The parameters for the task to create.
    RTTaskCreationParameters task_creation_parameters = 1;
 
    // The id of the created task
    optional int32 task_id = 2; // read-only
  }
 
  message TaskRemove {
    // The id of the task to remove.
    int32 task_id = 1;
  }
 
  message GlobalValueSet {
    // The value to set the global variable to. See FirmwareValue for details.
    FirmwareValue value = 1;
 
    // The name of the global variable to set.
    string name = 2;
 
    // The name and directory of the library that contains the global variable.
    // (The task functions library)
    optional string library_name = 3;
    optional string library_directory = 4;
  }
}
 
message RTTaskManagerInfo {
  // The unique id of the task manager.
  int32 id = 1;
 
  // Constants related to the RTTaskManager class.
  Constants constants = 2;
  
  // The creation parameters that were used to create the task manager.
  RTTaskManagerCreationParameters creation_parameters = 3;
 
  message Constants {
    // The maximum number of RTTaskManagers that can be created.
    int32 rt_task_manager_count_maximum = 1;
    
    // The maximum number of RTTasks that can be created in a single RTTaskManager.
    int32 rt_task_count_maximum = 2;
 
    // The name of the RTTaskManager executable.
    string rt_task_manager_executable_name = 3;
 
    // Constants related to the RTTaskManager's creation parameters.
    CreationParameterConstants creation_parameters = 4;
 
    message CreationParameterConstants {
      // The maximum length of the RTTaskManager's directory name.
      int32 directory_length_maximum = 1;
 
      // The maximum length of the RTTaskManager's library name and user label.
      int32 name_length_maximum = 2;
 
      // The default user label for the RTTaskManager if none is specified.
      string user_label_default = 3;
    }
  }
}
 
message RTTaskManagerStatus {
  // The ids of the tasks that are currently registered with the task manager.
  // (Includes tasks that are not running.)
  repeated int32 task_ids = 1;
 
  // The names and values of the global variables that the task manager has access to.
  map<string, FirmwareValue> global_values = 2;
 
  // The state of the RTTaskManager (dead, running, etc.) 
  optional RTTaskManagerState state = 3;
 
  // The total number of tasks that have been submitted to the task manager (even if they are no longer running).
  optional uint64 task_submission_count = 4;
 
  // The number of cycles (iterations) the task manager has run.
  optional int64 cycle_count = 5;
 
  // The time it took for the longest cycle to complete (in nanoseconds).
  optional uint64 cycle_time_max = 6;
 
  // The time it took for the shortest cycle to complete (in nanoseconds).
  optional uint64 cycle_time_min = 7;
 
  // The mean of the cycle times (in nanoseconds).
  optional double cycle_time_mean = 8;
 
  // The time it took for the last cycle to complete (in nanoseconds).
  optional uint64 cycle_time_last = 9;
 
  // The time since the last cycle started (in nanoseconds).
  optional uint64 start_time_delta_last = 10;
 
  // The maximum time difference between the start of one cycle and the next (in nanoseconds).
  optional uint64 start_time_delta_max = 11;
 
  // The mean time difference between the start of one cycle and the next (in nanoseconds).
  optional double start_time_delta_mean = 12;
}
 
message RTTaskManagerRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  // RTTaskManager id.
  optional int32 id = 2; // Required for all actions except Create and Discover.
 
  optional RTTaskManagerConfig config = 3;
  optional RTTaskManagerAction action = 4;
}
 
message RTTaskManagerResponse {
  // Common response header. Always check the response header for errors.  
  RSI.RapidServer.ResponseHeader header = 1;
 
  // RTTaskManager id.
  optional int32 id = 2; // When creating a RTTaskManager, this will be the new RTTaskManager's id.
 
  optional RTTaskManagerConfig config = 3;
  optional RTTaskManagerAction action = 4;
  optional RTTaskManagerInfo info = 5;
  optional RTTaskManagerStatus status = 6;
}
 
message RTTaskManagerBatchRequest {
  // Common request header.
  RSI.RapidServer.RequestHeader header = 1;
 
  repeated RTTaskManagerRequest requests = 2;
}
 
message RTTaskManagerBatchResponse {
  // Common response header. Always check the response header for errors.  
  RSI.RapidServer.ResponseHeader header = 1;
 
  repeated RTTaskManagerResponse responses = 2;
}