The RMP Motion Controller APIs
cartesianrobot.h
1 #pragma once
2 #ifndef _CARTESIANROBOT_H
3 #define _CARTESIANROBOT_H
4 
5 #include "rsi.h" // HAS_CARTESIAN_ROBOT defined in rsi.h
6 #if defined(HAS_CARTESIAN_ROBOT)
7 #include <cmath>
8 
9 
10 #if defined(__cplusplus)
11 extern "C"
12 {
13 #endif
14 
15 // doxygen requires these stacked namespaces, you CANNOT use RSI::RapidCode::Cartesian {
16 namespace RSI
17 {
18 namespace RapidCode
19 {
21 namespace Cartesian
22 {
23 
24  static constexpr uint32_t MotionFrameBufferSizeMinimum=50;// Minimum size the trajectory executor buffer must be
25 
28 
30  enum class PathState
31  {
32  Uninitialized,
33  Idle,
34  Moving,
35  Stopping,
36  };
37 
38  constexpr double pi = 3.1415926535897932384626433832795028841971693993751;
39 
41  enum class PathMode
42  {
43  Absolute,
44  Relative,
45  };
46 
48  enum class RotationDirection
49  {
50  Clockwise,
52  };
53 
55  enum class Plane
56  {
57  None,
58  XY,
59  XZ,
60  YZ,
61  };
62 
64  enum class GCodeWorkOffset {
65  Machine = 0,
66  G54 = 54,
67  G55 = 55,
68  G56 = 56,
69  G57 = 57,
70  G58 = 58,
71  G59 = 59,
72  };
73 
75  enum class LinearUnits
76  {
77  None,
78  Millimeters,
79  Inches,
80  Feet,
81  Centimeters,
82  Meters,
83 
84  };
85 
94  enum class CartesianAxis
95  {
96  X = 0,
97  Y = 1,
98  Z = 2,
99  Roll = 3,
100  Pitch = 4,
101  Yaw = 5,
102  };
103 
105 
108 
110  class RSI_API Vector3d
111  {
112  public:
114  double X;
115 
117  double Y;
118 
120  double Z;
121 
124 
126  Vector3d(double x, double y, double z);
127 
129  Vector3d(const Vector3d& rhs);
130 
132  double Dot(const Vector3d& rhs) const;
133 
138  Vector3d Cross(const Vector3d& rhs) const;
139 
141  Vector3d& Set(double x, double y, double z);
142 
144  Vector3d& Set(const Vector3d& rhs);
145 
148  bool Equals(const Vector3d& rhs, const double tolerance) const;
149 
151  double SumSquares() const;
152 
154  double Length() const;
155 
157  Vector3d Normal() const;
158 
161 
165  bool operator==(const Vector3d& rhs) const;
167  bool operator!=(const Vector3d& rhs) const;
169  Vector3d operator*(double scalar) const;
171  Vector3d& operator*=(double scalar);
173  Vector3d operator+(const Vector3d& rhs) const;
177  Vector3d operator-(const Vector3d& rhs) const;
183  Vector3d operator/(double scalar) const;
185  Vector3d& operator/=(double scalar);
187  Vector3d Inverse() const;
188  };
189 
191  class RSI_API Quaternion
192  {
193  public:
196 
198  double W;
199 
202 
208  Quaternion(double w, double x, double y, double z);
209 
212  Quaternion(const Quaternion& rhs);
213 
217  Quaternion(double w, const Vector3d& v);
218 
223  Quaternion(double x, double y, double z);
224 
227  Quaternion(const Vector3d& rpy);
228 
232  bool operator==(const Quaternion& rhs) const;
233 
237  bool operator!=(const Quaternion& rhs) const;
238 
243 
247  Quaternion operator+(const Quaternion& rhs) const;
248 
253 
257  Quaternion operator-(const Quaternion& rhs) const;
258 
263 
267  Quaternion operator*(const Quaternion& rhs) const;
268 
272  Quaternion operator*(double s) const;
273 
277  Quaternion& operator*=(double s);
278 
282  Vector3d operator*(const Vector3d& rhs) const;
283 
287 
291  double Dot(const Quaternion& rhs) const;
292 
296  Quaternion& Set(const Quaternion& rhs);
297 
304  Quaternion& Set(double w, double x, double y, double z);
305 
310  Quaternion& Set(double w, const Vector3d& vec);
311 
318  Quaternion& Set(double x, double y, double z);
319 
323  Quaternion& Set(const Vector3d& vec);
324 
329  bool Equals(const Quaternion& rhs, const double tolerance) const;
330 
334 
338 
339 
342  double SumSquares() const;
343 
346  double Magnitude() const;
347 
351 
355 
356 
357 
362  static Quaternion FromAngleAxis(double angle, const Vector3d& axis);
363 
367  void ToAngleAxis(double& out_angle, Vector3d& out_axis) const;
368 
371  Vector3d ToEuler() const;
372 
373 
380  static Quaternion FromMatrix(const double* const mat);
381 
382 
388  void ToMatrix(double* mat) const;
389 
390 
396  //Quaternion& lerp(const Quaternion& q0, const Quaternion& q1, double time);
397 
404  //static Quaternion slerp(const Quaternion& q0, const Quaternion& q1, double time, bool forceShortArc = true);
405 
406 
411  //static Quaternion rotationFromTo(const Vector3d& from, const Vector3d& to);
412  };
413 
415  class RSI_API Pose {
416  public:
419 
422 
424  Pose();
425 
428  Pose(const Pose& pose);
429 
433  Pose(const Vector3d position, const Quaternion& quaternion);
434 
437  Pose(const Vector3d& position);
438 
443  Pose(double x, double y, double z);
444 
447  Pose(const Quaternion& quaternion);
448 
453  bool Equals(const Pose& rhs, double tolerance) const;
454 
458  Pose Rotate(const Pose& rhs) const;
459 
463  Vector3d operator*(const Vector3d& rhs) const;
464 
468  Pose operator*(const Pose& rhs) const;
469 
472  Pose Inverse() const;
473  };
474 
476  class RSI_API KinematicModel
477  {
478  public:
479  virtual const char* const NameGet() const = 0;
480  virtual uint32_t AxisCountGet() const = 0;
481 
482  virtual LinearUnits UnitsGet() const = 0;
483 
484  virtual bool IsConfigured() const = 0;
485 
486  virtual const char* const* const ExpectedAxisNamesGet() const = 0;
487  virtual uint32_t ExpectedAxisNamesCountGet() const = 0;
488 
489  // input function
490  // inputPose requires this to be in robot centric coordinates.
491  // remove tool offset and robot base offset
492  virtual bool SolveInverse(const Pose& inputPose, void* outputPointerSolutionVector) const = 0;
493 
494  // ouput function
495  // inputJointPositions requires this to be in robot centric coordinates.
496  // apply tool offset and robot base offset
497  virtual void SolveForward(const double* inputJointPositions, Pose& outputPose) const = 0;
498  };
499 
500 
505  class RSI_API KinematicModelBuilder
506  {
507  private:
508  struct Storage;
509  Storage* storage;
510 
511  protected:
516  KinematicModelBuilder(const char* const label);
517  virtual ~KinematicModelBuilder();
518 
519  // Disabled copy constructors
521  KinematicModelBuilder& operator=(const KinematicModelBuilder&) = delete;
522 
523  Storage* StorageGet();
524  const Storage* StorageGet() const;
525  void StorageSet(Storage*);
526 
527  public:
528 
533  virtual const KinematicModel& ModelBuild() = 0;
534 
539 
542  void UnitsSet(LinearUnits units);
543 
546  void LabelSet(const char* const label);
547 
549  void TransformFromKinematicOriginToRobotOriginSet(const Pose& KinematicOriginToRobotOrigin);
550 
551  // Move constructors
553  KinematicModelBuilder& operator=(KinematicModelBuilder&&) noexcept;
554 
555 
556 
557 
558  };
559 
574  struct RSI_API LinearJointMapping
575  {
576  public:
580 
584 
586  double Scaling;
587  static constexpr double DEFAULT_SCALING = 1.0;
588 
590  double Offset;
591  static constexpr double DEFAULT_OFFSET = 0.0;
592 
594  static constexpr int MAX_LABEL_SIZE = 16;
595  static constexpr int EXPECTED_LABEL_BUFFER_SIZE = MAX_LABEL_SIZE + 1;
596 
600  char ExpectedLabel[EXPECTED_LABEL_BUFFER_SIZE];
601 
602  LinearJointMapping(int jointIndex, CartesianAxis cartesianCoordinate);
603  };
604 
605 
609  {
610  public:
611 
616  const KinematicModel& ModelBuild() override;
617 
619  void JointAdd(const LinearJointMapping& joint);
620 
623  LinearModelBuilder(const char* const label);
625 
626  // Move constructors
627  LinearModelBuilder(LinearModelBuilder&& other) noexcept;
628  LinearModelBuilder& operator=(LinearModelBuilder&&) noexcept;
629 
630  // Disable copy constructors
631  LinearModelBuilder(const LinearModelBuilder&) = delete;
632  LinearModelBuilder& operator=(const LinearModelBuilder&) = delete;
633 
634  struct Storage;
635  Storage* storage;
636  };
637 
638  // UNSUPPORTED
639  class RSI_API ArticulatedModelBuilder : public KinematicModelBuilder
640  {
641  public:
642  const KinematicModel& ModelBuild() override;
643  ArticulatedModelBuilder();
644  ~ArticulatedModelBuilder();
645 
646  struct Storage;
647  Storage* storage;
648  };
649 
650 
651 
654  class RSI_API Robot : public virtual RapidCodeObject
655  {
656  public:
657 
662 
667  // RSI RA5 (Hans) "RSI_RA5";
668  static Robot* RobotCreate(MotionController* controller, MultiAxis* multiAxis, const char* const modelIdentifier, uint32_t motionFrameBufferSize);
669 
671  static Robot* RobotCreate(MotionController* controller, MultiAxis* multiAxis, const char* const modelIdentifier);
672 
677  static Robot* RobotCreate(MotionController* controller, MultiAxis* multiAxis, KinematicModelBuilder* builder, uint32_t motionFrameBufferSize);
678 
679 
681  static void RobotDelete(MotionController* controller, Robot* robot);
682 
683 
684 
686 
687 
692 
694  static constexpr uint64_t TimeoutForever = 0xFFFFFFFFFFFFFFFF;
695 
697 
698 
703 
706  virtual PathState PathStateGet() = 0;
707 
712  virtual bool PathStateWait(PathState stateWaitFor, uint64_t timeoutMilliseconds) = 0;
713 
718  virtual bool PathStateWaitChange(PathState stateWaitChange, uint64_t timeoutMilliseconds) = 0;
719 
720 
725  virtual uint64_t MotionCounterGet() = 0;
726 
731  virtual bool MotionCounterWait(uint64_t motionWaitFor, uint64_t timeoutMilliseconds) = 0;
732 
737  virtual bool MotionCounterWaitChange(uint64_t motionWaitChange, uint64_t timeoutMilliseconds) = 0;
738 
739 
740 
744  virtual bool IsRunning() = 0;
745 
749  virtual bool PathIsRunning() = 0;
750 
757  virtual bool MotionDoneGet() = 0;
758 
765  virtual uint64_t MotionDoneWait() = 0;
766 
774  virtual uint64_t MotionDoneWait(uint64_t timeoutMilliseconds) = 0;
775 
781  virtual bool HasError() = 0;
782 
787  virtual const char* const ErrorMessageGet() = 0;
788 
790 
791 
795 
798  virtual void Resume() = 0;
799 
802  virtual void Stop() = 0;
803 
806  virtual void EStopAbort() = 0;
807 
810  virtual void Abort() = 0;
811 
814  virtual void AmpEnableSet(bool enable, int32_t ampActiveTimoutMilliseconds) = 0;
815 
822  virtual void EStop() = 0;
823 
825  virtual void ClearFaults() = 0;
826 
827 
828 
832 
837  virtual Pose ActualPoseGet() = 0;
838 
843  virtual Pose CommandPoseGet() = 0;
844 
845 
850  virtual void JointsActualPositionsGet(double* positions, uint16_t sz) = 0;
851 
856  virtual void JointsCommandPositionsGet(double* positions, uint16_t sz) = 0;
857 
862  virtual void InverseKinematics(Pose pose, double* outJoints, uint16_t outJointsSize) = 0;
863 
869  virtual Pose ForwardKinematics(double* inJoints, uint16_t inJointsSize) = 0;
870 
871 
875 
878  virtual const KinematicModel& ModelGet() = 0;
879 
883  virtual void EndEffectorTransformSet(const Pose& transform) = 0;
884 
888  virtual void OriginTransformSet(const Pose& transform) = 0;
889 
892  virtual const Pose& EndEffectorTransformGet() = 0;
893 
896  virtual const Pose& OriginTransformGet() = 0;
897 
898 
903  virtual const double ScaleFactorBetweenUnitsGet(LinearUnits from, LinearUnits to) = 0;
904 
905 
909 
918  virtual void MoveAbsolute(const Pose& absolutePose) = 0;
919 
920 
930  virtual void MoveRelative(const Pose& relativePose) = 0;
931 
932 
936 
940  virtual void PathClear() = 0;
941 
946  virtual void PathVelocitySet(double unitsPerSecond) = 0;
947 
952  virtual double PathVelocityGet() = 0;
953 
958  virtual void PathAccelerationSet(double unitsPerSecondSquared) = 0;
959 
965  virtual double PathAccelerationGet() = 0;
966 
973  virtual void PathProgrammingModeSet(PathMode mode) = 0;
974 
981 
988  virtual void PathArc(const Pose& target, double radius, RotationDirection direction) = 0;
989 
994  virtual void PathArc(const Pose& target, const Vector3d& center, RotationDirection direction) = 0;
995 
996  // @brief Appends a line on the current path
1000  virtual void PathLine(const Pose& target) = 0;
1001 
1005  virtual void PathPlaneSet(Plane plane) = 0;
1006 
1010  virtual Plane PathPlaneGet() = 0;
1011 
1012 
1018  virtual void PathLinearScalingSet(double scaleFactor) = 0;
1019 
1026  virtual double PathLinearScalingGet()const = 0;
1027 
1032  virtual void PathUnitsSet(LinearUnits units) = 0;
1033 
1037  virtual LinearUnits PathUnitsGet()const = 0;
1038 
1039 
1042  virtual double PathProcessLoadedMoves() = 0;
1043 
1056  virtual uint64_t PathPlannedPointsGet(double* points, double* times, uint64_t startFrame, uint64_t frameCount) = 0;
1057 
1062  virtual double PathDurationGet() = 0;
1063 
1071  virtual void Run() = 0;
1072 
1078  virtual uint32_t MotionFrameBufferSizeGet()=0;
1079 
1083 
1093  virtual bool GcodeFileLoad(const char* const filePath) = 0;
1094 
1104  virtual bool GcodeStringLoad(const char* const text) = 0;
1105 
1111  virtual const char* const GcodeProgramGet() = 0;
1112 
1118  virtual void GcodeFeedRateSet(double unitsPerMinute) = 0;
1119 
1127  virtual double GcodeFeedRateGet() = 0;
1128 
1134  virtual void GcodeAccelerationRateSet(double unitsPerMinuteSquared) = 0;
1135 
1142  virtual double GcodeAccelerationRateGet() = 0;
1143 
1152  virtual int32_t GcodeExecutingLineNumberGet() = 0;
1153 
1154 
1163  virtual void GcodeUnitsSet(LinearUnits units) = 0;
1164 
1173 
1181  virtual void GcodeProgrammingModeSet(PathMode mode) = 0;
1182 
1189 
1198  virtual int32_t GcodeErrorLineNumberGet() = 0;
1199 
1206  virtual int32_t GcodeNumberOfLinesGet() = 0;
1207 
1213  virtual void GcodeReload() = 0;
1214 
1220  virtual void GcodeReload(int32_t startLine, int32_t endLine) = 0;
1221 
1227  virtual void GcodeReload(int32_t startLine) = 0;
1228 
1237  virtual const char* const GcodeLineTextGet(uint32_t lineNumber) = 0;
1238 
1245  virtual void GcodePlaneSet(Plane plane) = 0;
1246 
1253  virtual void GcodeWorkOffsetConfigure(GCodeWorkOffset offset, Vector3d offsetValues) = 0;
1254 
1261  virtual void GcodeWorkOffsetSelect(GCodeWorkOffset offset) = 0;
1262 
1270 
1277  virtual const Pose& GcodeWorkOffsetValuesGet() = 0;
1278 
1279  };
1280 
1281 
1282 
1283 
1285 
1286 } // Cartesian namespace
1287 } // RapidCode namespace
1288 } // RSI namespace
1289 #if defined(__cplusplus)
1290 } // extern C
1291 #endif // defined(__cplusplus)
1292 #endif // defined(HAS_CARTESIAN_ROBOT)
1293 #endif // _CARTESIANROBOT_H
1294 
RSI::RapidCode::Cartesian::Robot::PathAccelerationSet
void PathAccelerationSet(double unitsPerSecondSquared)=0
Sets the target acceleration for the machine (UserUnits/second^2). Should be set apprpriately based o...
RSI::RapidCode::Cartesian::Robot::PathLinearScalingSet
void PathLinearScalingSet(double scaleFactor)=0
Sets scaling between the input to path motion and output of path motion to the kinematic model.
RSI::RapidCode::Cartesian::Robot::PathIsRunning
bool PathIsRunning()=0
Returns whether or not a planned path is being executed. All G-Code gets converted to path....
RSI::RapidCode::Cartesian::Robot::GcodeWorkOffsetGet
GCodeWorkOffset GcodeWorkOffsetGet()=0
Gets the enum representing the location where the current offset is saved.
RSI::RapidCode::MultiAxis
The MultiAxis object allows you to map two or more axes together and command synchronized motion.
Definition: rsi.h:11271
RSI::RapidCode::Cartesian::Quaternion::ToMatrix
void ToMatrix(double *mat) const
Quaternion To Matrix.
RSI::RapidCode::Cartesian::Robot
The Robot class for Path, G-Code and RapidRobot motion for any actuator. Use RobotCreate() to make on...
Definition: cartesianrobot.h:655
RSI::RapidCode::Cartesian::Robot::GcodeProgrammingModeGet
PathMode GcodeProgrammingModeGet()=0
Gets the G-Code programming mode (Relative/Absolute).
RSI::RapidCode::Cartesian::Quaternion::operator!=
bool operator!=(const Quaternion &rhs) const
Exact inequality check. See equals for approximately equal to.
RSI::RapidCode::Cartesian::Robot::Resume
void Resume()=0
Resume an axis.
RSI::RapidCode::Cartesian::Pose::Orientation
Quaternion Orientation
The orientation component of the Pose.
Definition: cartesianrobot.h:421
RSI::RapidCode::Cartesian::Quaternion::Conjugate
Quaternion Conjugate() const
Negates the imaginary component of the Quaternion.
RSI::RapidCode::Cartesian::Robot::PathProcessLoadedMoves
double PathProcessLoadedMoves()=0
Processes our loaded moves. Used internally and to check whether loaded moves are valid,...
RSI::RapidCode::Cartesian::RotationDirection
RotationDirection
Rotational directions about an axis.
Definition: cartesianrobot.h:49
RSI::RapidCode::Cartesian::Robot::GcodeFileLoad
bool GcodeFileLoad(const char *const filePath)=0
Open a file at the specified file path. Calls GcodeStringLoad() with the contents of the file.
RSI::RapidCode::Cartesian::LinearJointMapping::Offset
double Offset
The offset value that will be added to the scaled joint position.
Definition: cartesianrobot.h:590
RSI::RapidCode::Cartesian::Quaternion::operator*
Quaternion operator*(double s) const
Multiplication (scalar) operator. w*s, v*s.
RSI::RapidCode::Cartesian::Vector3d::SumSquares
double SumSquares() const
Returns the sum of squares. X*X+Y*Y+Z*Z.
RSI::RapidCode::Cartesian::Pose::Position
Vector3d Position
The position component of the Pose.
Definition: cartesianrobot.h:418
RSI::RapidCode::Cartesian::Robot::GcodeReload
void GcodeReload(int32_t startLine, int32_t endLine)=0
Reloads the lines from the last call to GcodeStringLoad() but only between start and end line numbers...
RSI::RapidCode::Cartesian::Robot::ModelGet
const KinematicModel & ModelGet()=0
Get the model this robot was created with Visit our Topic Page for more information.
RSI::RapidCode::Cartesian::Robot::Abort
void Abort()=0
Abort an axis.
RSI::RapidCode::Cartesian::Robot::PathVelocityGet
double PathVelocityGet()=0
Gets the target velocity for the machine (UserUnits/second).
RSI::RapidCode::Cartesian::Quaternion::Dot
double Dot(const Quaternion &rhs) const
Returns the dot product of each element. w*rhs.w+v.dot(rhs.v)
RSI::RapidCode::Cartesian::Vector3d::operator/
Vector3d operator/(double scalar) const
Returns a Vector3d scaled scaled by. X/scalar, Y/scalar, Z/scalar.
RSI::RapidCode::Cartesian::Quaternion::Quaternion
Quaternion(const Quaternion &rhs)
Constructor.
RSI::RapidCode::Cartesian::Robot::GcodeProgrammingModeSet
void GcodeProgrammingModeSet(PathMode mode)=0
Sets the programming mode (Relative/Absolute).
RSI::RapidCode::Cartesian::Quaternion::operator+
Quaternion operator+(const Quaternion &rhs) const
Adds two quaternions together. this.w + rhs.w, this.v+rhs.v.
RSI::RapidCode::Cartesian::KinematicModelBuilder::ModelGet
const KinematicModel & ModelGet()
Get a constant reference to the Kinematic model that is currently built. The builder instance maintai...
RSI::RapidCode::Cartesian::LinearModelBuilder::JointAdd
void JointAdd(const LinearJointMapping &joint)
adds a joint to the model using the configuration specified within the LinearJoint structure.
RSI::RapidCode::Cartesian::Robot::EndEffectorTransformSet
void EndEffectorTransformSet(const Pose &transform)=0
Transform that defines the control point relative to the end end of the current kinematic model For e...
RSI::RapidCode::Cartesian::Pose::Pose
Pose(double x, double y, double z)
Constructor from X,Y,Z with an identity "no rotation" default Quaternion.
RSI::RapidCode::Cartesian::Robot::Stop
void Stop()=0
Stop an axis.
RSI::RapidCode::Cartesian::Quaternion::ToEuler
Vector3d ToEuler() const
Gets the Euler Angle representation of this quaternion.
RSI::RapidCode::Cartesian::LinearJointMapping::Scaling
double Scaling
The scaling value that the joint position will be multiplied by.
Definition: cartesianrobot.h:586
RSI::RapidCode::Cartesian::Quaternion::Magnitude
double Magnitude() const
Gets the magnitude of this. sqrt(SumSquares())
RSI::RapidCode::Cartesian::Robot::PathArc
void PathArc(const Pose &target, const Vector3d &center, RotationDirection direction)=0
Appends an arc on to the current path with end pose about a specific center point.
RSI::RapidCode::Cartesian::KinematicModelBuilder::LabelSet
void LabelSet(const char *const label)
Set the model name.
RSI::RapidCode::Cartesian::Vector3d::X
double X
The X coordinate.
Definition: cartesianrobot.h:114
RSI::RapidCode::Cartesian::Vector3d::operator/=
Vector3d & operator/=(double scalar)
Scales each element by scalar. X/=scalar, Y/=scalar, Z/=scalar.
RSI::RapidCode::Cartesian::LinearJointMapping::JointIndex
int JointIndex
Definition: cartesianrobot.h:579
RSI::RapidCode::Cartesian::Vector3d::Set
Vector3d & Set(const Vector3d &rhs)
Sets X=rhs.X, Y=rhs.Y, Z=rhs.Z.
RSI::RapidCode::Cartesian::Plane
Plane
Rotational directions about and axis.
Definition: cartesianrobot.h:56
RSI::RapidCode::Cartesian::Quaternion::operator*
Quaternion operator*(const Quaternion &rhs) const
Multiplication (rotation) operator. Rotates other by this.
RSI::RapidCode::Cartesian::Quaternion
Quaternion for representing rotations.
Definition: cartesianrobot.h:192
RSI::RapidCode::Cartesian::Vector3d::operator!=
bool operator!=(const Vector3d &rhs) const
Returns whether this is not exactly equal to rhs.
RSI::RapidCode::Cartesian::KinematicModelBuilder::ModelBuild
const KinematicModel & ModelBuild()=0
Construct the model using the information the builder currently has. The builder will maintain a refe...
RSI::RapidCode::Cartesian::Robot::AmpEnableSet
void AmpEnableSet(bool enable, int32_t ampActiveTimoutMilliseconds)=0
Enable all amplifiers.
RSI::RapidCode::Cartesian::KinematicModel
Describes the mathematical kinematic model of a robot.
Definition: cartesianrobot.h:477
RSI::RapidCode::Cartesian::Robot::PathVelocitySet
void PathVelocitySet(double unitsPerSecond)=0
Sets the target linear cartesian velocity for each move (UserUnits/second).
RSI::RapidCode::Cartesian::Vector3d::operator*=
Vector3d & operator*=(double scalar)
Scales each element by scalar. X*=scalar, Y*=scalar, Z*=scalar.
RSI::RapidCode::Cartesian::Robot::MotionDoneWait
uint64_t MotionDoneWait(uint64_t timeoutMilliseconds)=0
Waits for a move to complete.
RSI::RapidCode::Cartesian::Robot::PathPlaneSet
void PathPlaneSet(Plane plane)=0
Sets the plane for the purposes of ambigous cases (arcs >= 180deg). Last set plane or XY plane is def...
RSI::RapidCode::Cartesian::Vector3d::Y
double Y
The Y coordinate.
Definition: cartesianrobot.h:117
RSI::RapidCode::Cartesian::LinearModelBuilder::LinearModelBuilder
LinearModelBuilder(const char *const label)
constructs a LinearModelBuilder instance.
RSI::RapidCode::Cartesian::Robot::GcodeReload
void GcodeReload()=0
Reloads the all lines from the last call to GcodeStringLoad(). Automatically called by GcodeStringLoa...
RSI::RapidCode::Cartesian::KinematicModelBuilder::UnitsSet
void UnitsSet(LinearUnits units)
Set the units the built model will use.
RSI::RapidCode::Cartesian::Vector3d::Length
double Length() const
Returns the length of the vector. Aka the magnitude =sqrt(SumSquares)
RSI::RapidCode::Cartesian::Quaternion::Quaternion
Quaternion(double w, double x, double y, double z)
Constructor.
RSI::RapidCode::Cartesian::Quaternion::Quaternion
Quaternion(const Vector3d &rpy)
Euler Constructor (Alternate)
RSI::RapidCode::Cartesian::Vector3d::operator+
Vector3d operator+(const Vector3d &rhs) const
Returns a copy of rhs added to this. this.X+rhs.X, this.Y+rhs.Y, this.Z+rhs.Z.
RSI::RapidCode::Cartesian::Quaternion::ToAngleAxis
void ToAngleAxis(double &out_angle, Vector3d &out_axis) const
Gets the axis angle representation of this quaternion.
RSI::RapidCode::Cartesian::Quaternion::operator-=
Quaternion & operator-=(const Quaternion &rhs)
Subtraction assignment. Subtracts other from this. See operator-.
RSI::RapidCode::Cartesian::Pose::Inverse
Pose Inverse() const
Returns an inverted copy of this. this * this.inverse() = I.
RSI::RapidCode::Cartesian::Quaternion::operator*
Vector3d operator*(const Vector3d &rhs) const
Multiplication (vector rotation) operator. Rotates vector by this.
RSI::RapidCode::Cartesian::Robot::MotionDoneGet
bool MotionDoneGet()=0
Check to see if motion is done and settled.
RSI::RapidCode::Cartesian::Robot::GcodeWorkOffsetConfigure
void GcodeWorkOffsetConfigure(GCodeWorkOffset offset, Vector3d offsetValues)=0
Save an XYZ offset to be used with specified G-Code work offset.
RSI::RapidCode::Cartesian::Vector3d::Inverse
Vector3d Inverse() const
Returns an inverted copy of this. this * this.inverse() = I.
RSI::RapidCode::Cartesian::Robot::ForwardKinematics
Pose ForwardKinematics(double *inJoints, uint16_t inJointsSize)=0
Get the Actual pose of the robot from the the joint MultiAxis positions.
RSI::RapidCode::Cartesian::Robot::PathUnitsSet
void PathUnitsSet(LinearUnits units)=0
Defines the units Cartesian Path Motion is in.
RSI::RapidCode::Cartesian::Quaternion::V
Vector3d V
Vector3d (imaginary) component of Quaternion. 1->x, 2->y, 3->z. Do not modify this unless you know wh...
Definition: cartesianrobot.h:195
RSI::RapidCode::Cartesian::Robot::PathArc
void PathArc(const Pose &target, double radius, RotationDirection direction)=0
Appends an arc on to the current on the PathPlaneGet() plane XY by default.
RSI::RapidCode::Cartesian::Vector3d::operator=
Vector3d & operator=(const Vector3d &rhs)
Sets this = rhs.
RSI::RapidCode::Cartesian::Robot::OriginTransformSet
void OriginTransformSet(const Pose &transform)=0
Transform that defines the origin of the robot in the world. For example if you have a gantry that is...
RSI::RapidCode::Cartesian::Robot::GcodeExecutingLineNumberGet
int32_t GcodeExecutingLineNumberGet()=0
Returns the line number of the currently executing G-Code line or -1 if there is none.
RSI::RapidCode::Cartesian::Pose::Pose
Pose(const Pose &pose)
Constructor from an existing Pose.
RSI::RapidCode::Cartesian::Robot::EndEffectorTransformGet
const Pose & EndEffectorTransformGet()=0
End of Robot to TCP.
RSI::RapidCode::Cartesian::Vector3d::Dot
double Dot(const Vector3d &rhs) const
Dot Product. this.X*rhs.X + this.Y*rhs.Y + this.Z*rhs.Z.
RSI::RapidCode::Cartesian::Robot::Run
void Run()=0
Run the loaded path lines/arcs. The behavior is non-blocking. Use Robot.MotionDoneWait() to block....
RSI::RapidCode::Cartesian::Quaternion::operator-
Quaternion operator-(const Quaternion &rhs) const
Subtraction operator. this.w - rhs.w, this.v-rhs.v.
RSI::RapidCode::Cartesian::Quaternion::operator*=
Quaternion & operator*=(double s)
Multiplication (scalar) assignment operator. See operator*(double)
RSI::RapidCode::Cartesian::Vector3d::Vector3d
Vector3d()
Default constructor. X=Y=Z=0.
RSI::RapidCode::Cartesian::Robot::OriginTransformGet
const Pose & OriginTransformGet()=0
Offset for the origin location.
RSI::RapidCode::Cartesian::RotationDirection::Clockwise
@ Clockwise
RSI::RapidCode::RapidCodeObject
The RapidCode base class. All non-error objects are derived from this class.
Definition: rsi.h:173
RSI::RapidCode::Cartesian::Robot::EStopAbort
void EStopAbort()=0
E-Stop, then abort an axis.
RSI::RapidCode::Cartesian::KinematicModelBuilder
The abstract class for Kinematic Model builders. Constructs a single Kinematic Model to use when crea...
Definition: cartesianrobot.h:506
RSI::RapidCode::Cartesian::Robot::ClearFaults
void ClearFaults()=0
Clears the MultiAxis fault then the Robot's error bit.
RSI::RapidCode::Cartesian::Vector3d::operator*
Vector3d operator*(double scalar) const
Returns a Vector3d scaled scaled by. X*scalar, Y*scalar, Z*scalar.
RSI::RapidCode::Cartesian::Robot::GcodeNumberOfLinesGet
int32_t GcodeNumberOfLinesGet()=0
Returns the total line number count in the last loaded item.
RSI::RapidCode::Cartesian::Vector3d::Equals
bool Equals(const Vector3d &rhs, const double tolerance) const
Checks whether this.X==rhs.X && this.Y==rhs.Y && this.Z==rhs.Z within tolerance abs(a-b) < tolerance.
RSI::RapidCode::Cartesian::Robot::PathStateWait
bool PathStateWait(PathState stateWaitFor, uint64_t timeoutMilliseconds)=0
Waits for a specific path state.
RSI::RapidCode::Cartesian::KinematicModelBuilder::TransformFromKinematicOriginToRobotOriginSet
void TransformFromKinematicOriginToRobotOriginSet(const Pose &KinematicOriginToRobotOrigin)
Set the kin origin to robot origin tf.
RSI::RapidCode::Cartesian::Vector3d::operator==
bool operator==(const Vector3d &rhs) const
Returns whether this is exactly equal to rhs.
RSI::RapidCode::Cartesian::Quaternion::Set
Quaternion & Set(double w, double x, double y, double z)
Assigns each component into this.
RSI::RapidCode::Cartesian::Robot::MotionFrameBufferSizeGet
uint32_t MotionFrameBufferSizeGet()=0
Gets the frame buffer size that is set at creation.
RSI::RapidCode::Cartesian::Robot::JointsActualPositionsGet
void JointsActualPositionsGet(double *positions, uint16_t sz)=0
Get the actual position of the axes in the underlying MultiAxis.
RSI::RapidCode::Cartesian::Pose
Pose.
Definition: cartesianrobot.h:415
RSI::RapidCode::Cartesian::Robot::RobotCreate
static Robot * RobotCreate(MotionController *controller, MultiAxis *multiAxis, const char *const modelIdentifier, uint32_t motionFrameBufferSize)
Create a Robot object to use G-Code, path motion, etc.
RSI::RapidCode::Cartesian::Vector3d::Z
double Z
The Z coordinate.
Definition: cartesianrobot.h:120
RSI::RapidCode::Cartesian::Robot::RobotDelete
static void RobotDelete(MotionController *controller, Robot *robot)
Delete a Robot.
RSI::RapidCode::Cartesian::GCodeWorkOffset::Machine
@ Machine
RSI::RapidCode::Cartesian::Pose::operator*
Vector3d operator*(const Vector3d &rhs) const
Transforms rhs by this. Rotates rhs by this, and adds this.position to it.
RSI::RapidCode::Cartesian::Quaternion::operator==
bool operator==(const Quaternion &rhs) const
Exact equality check. See equals for approximately equal to.
RSI::RapidCode::Cartesian::Robot::MotionCounterWait
bool MotionCounterWait(uint64_t motionWaitFor, uint64_t timeoutMilliseconds)=0
Waits for the counter to be greater than or euqal to the specified state.
RSI::RapidCode::Cartesian::Quaternion::Normalize
Quaternion & Normalize()
Normalizes this. Scales each component by 1 / magnitude.
RSI::RapidCode::Cartesian::Quaternion::Set
Quaternion & Set(double x, double y, double z)
Assigns the quaternion defined by the Euler angles into this. If you get unexpected values,...
RSI::RapidCode::Cartesian::Vector3d::operator-=
Vector3d & operator-=(const Vector3d &rhs)
Subtracts rhs from this. this.X-=rhs.X, this.Y-=rhs.Y, this.Z-=rhs.Z.
RSI::RapidCode::Cartesian::Robot::RobotCreate
static Robot * RobotCreate(MotionController *controller, MultiAxis *multiAxis, const char *const modelIdentifier)
This is an overloaded member function, provided for convenience. It differs from the above function o...
RSI::RapidCode::Cartesian::Robot::ActualPoseGet
Pose ActualPoseGet()=0
Get the actual pose of the robot from the trajectory exectutor.
RSI::RapidCode::Cartesian::Robot::MoveAbsolute
void MoveAbsolute(const Pose &absolutePose)=0
Executes a point-to-point absolute motion in cartesian space.
RSI::RapidCode::Cartesian::Robot::PathLine
void PathLine(const Pose &target)=0
RSI::RapidCode::Cartesian::Vector3d::operator-
Vector3d operator-(const Vector3d &rhs) const
Returns a copy of rhs subtracted from this. this.X-rhs.X, this.Y-rhs.Y, this.Z-rhs....
RSI::RapidCode::Cartesian::Quaternion::operator-
Quaternion operator-() const
Negates this quaternion (w, and v)
RSI::RapidCode::Cartesian::Vector3d::Normal
Vector3d Normal() const
Returns a normalized copy of this.
RSI::RapidCode::Cartesian::Robot::GcodeWorkOffsetValuesGet
const Pose & GcodeWorkOffsetValuesGet()=0
Gets the actual values of the currently applied offset.
RSI::RapidCode::Cartesian::LinearModelBuilder
The Builder for a linear kinematic model. Constructs a single Linear Kinematic Model to use when crea...
Definition: cartesianrobot.h:609
RSI::RapidCode::Cartesian::Robot::PathStateWaitChange
bool PathStateWaitChange(PathState stateWaitChange, uint64_t timeoutMilliseconds)=0
Waits for the path state to not be the specified state.
RSI::RapidCode::Cartesian::Quaternion::Equals
bool Equals(const Quaternion &rhs, const double tolerance) const
Equality check within tolerance.
RSI::RapidCode::Cartesian::Robot::GcodeErrorLineNumberGet
int32_t GcodeErrorLineNumberGet()=0
Gets the line number of any errors in the G-Code syntax.
RSI::RapidCode::Cartesian::CartesianAxis
CartesianAxis
This enum specifies which Cartesian axis a LinearJointMapping maps a robot joint to.
Definition: cartesianrobot.h:95
RSI::RapidCode::Cartesian::Robot::GcodeLineTextGet
const char *const GcodeLineTextGet(uint32_t lineNumber)=0
Gives you the text of a specific line from the last loaded program excluding all comments and with on...
RSI::RapidCode::Cartesian::Vector3d::Vector3d
Vector3d(double x, double y, double z)
Constructor. X=x, Y=y, Z=z.
RSI::RapidCode::Cartesian::Robot::EStop
void EStop()=0
Commands a joint EStop and clears the loaded moves.
RSI::RapidCode::Cartesian::Quaternion::Set
Quaternion & Set(const Vector3d &vec)
Assigns the quaternion defined by the Euler Angles into this.
RSI::RapidCode::Cartesian::Robot::GcodePlaneSet
void GcodePlaneSet(Plane plane)=0
Set the plane for arcs (same as calling G17/G18/G19)
RSI::RapidCode::Cartesian::Robot::ErrorMessageGet
const char *const ErrorMessageGet()=0
Get the text of any error in the Trajectory Executor.
RSI::RapidCode::Cartesian::Robot::GcodeFeedRateGet
double GcodeFeedRateGet()=0
Gets the target feed rate for the machine (GcodeUnitsGet()/minute).
RSI::RapidCode::Cartesian::Quaternion::SumSquares
double SumSquares() const
Gets the sum of the components squared (w*w+this.dot(this))
RSI::RapidCode::Cartesian::Robot::PathLinearScalingGet
double PathLinearScalingGet() const =0
Gets scaling between input to path motion and output of path motion to the kinematic model.
RSI::RapidCode::Cartesian::Robot::RobotCreate
static Robot * RobotCreate(MotionController *controller, MultiAxis *multiAxis, KinematicModelBuilder *builder, uint32_t motionFrameBufferSize)
Create a Robot object to use G-Code, path motion, etc.
RSI::RapidCode::Cartesian::PathState::Uninitialized
@ Uninitialized
Library is loading. Wait until it is idle.
RSI::RapidCode::Cartesian::Vector3d::Vector3d
Vector3d(const Vector3d &rhs)
Constructor. X=rhs.X, Y=rhs.Y, Z=rhs.Z.
RSI::RapidCode::Cartesian::CartesianAxis::X
@ X
RSI::RapidCode::Cartesian::Robot::GcodeProgramGet
const char *const GcodeProgramGet()=0
Gets the raw file contents of the last loaded program.
RSI::RapidCode::MotionController
The MotionController object represents the RMP INtime soft motion controller.
Definition: rsi.h:770
RSI::RapidCode::Cartesian::PathMode::Absolute
@ Absolute
RSI::RapidCode::Cartesian::Robot::PathPlaneGet
Plane PathPlaneGet()=0
Gets the plane some arcs will be forced to be on.
RSI::RapidCode::Cartesian::Quaternion::W
double W
W (real component) of Quaternion. Do not modify this unless you know what you are doing.
Definition: cartesianrobot.h:198
RSI::RapidCode::Cartesian::LinearUnits::None
@ None
RSI::RapidCode::Cartesian::Robot::GcodeFeedRateSet
void GcodeFeedRateSet(double unitsPerMinute)=0
Sets the target feed rate for the machine (units/minute). Same as the "F" Command in a G-Code file.
RSI::RapidCode::Cartesian::Quaternion::Quaternion
Quaternion(double x, double y, double z)
Euler constructor.
RSI::RapidCode::Cartesian::Vector3d
Vector3d is used for three-dimensional points and vectors.
Definition: cartesianrobot.h:111
RSI
RSI::RapidCode::Cartesian::Quaternion::Normalized
Quaternion Normalized() const
Retunrs a normalized copy of this.
RSI::RapidCode::Cartesian::Vector3d::operator-
Vector3d operator-() const
Returns a copy of this with elements negated. -X, -Y, -Z.
RSI::RapidCode::Cartesian::Robot::ScaleFactorBetweenUnitsGet
const double ScaleFactorBetweenUnitsGet(LinearUnits from, LinearUnits to)=0
Gets scaling for scale factor needed to convert from -> to units by multiplying
RSI::RapidCode::Cartesian::Vector3d::operator+=
Vector3d & operator+=(const Vector3d &rhs)
Adds rhs to this. this.X+=rhs.X, this.Y+=rhs.Y, this.Z+=rhs.Z.
RSI::RapidCode::Cartesian::Quaternion::operator+=
Quaternion & operator+=(const Quaternion &rhs)
Addition assignment. Adds rhs into this. See operator+.
RSI::RapidCode::Cartesian::Pose::Pose
Pose(const Vector3d &position)
Constructor from an existing position Vector3d.
RSI::RapidCode::Cartesian::Pose::operator*
Pose operator*(const Pose &rhs) const
Transforms rhs by this. Rotates rhs.position by this, adds this.position to it, and rotates rhs....
RSI::RapidCode::Cartesian::Robot::MotionDoneWait
uint64_t MotionDoneWait()=0
Waits for a move to complete.
RSI::RapidCode::Cartesian::Robot::PathStateGet
PathState PathStateGet()=0
Gets the path state of the Robot.
RSI::RapidCode::Cartesian::Quaternion::operator=
Quaternion & operator=(const Quaternion &rhs)
Assignment operator. Copies underlying.
RSI::RapidCode::Cartesian::CartesianAxis::Y
@ Y
RSI::RapidCode::Cartesian::LinearJointMapping
Definition: cartesianrobot.h:575
RSI::RapidCode::Cartesian::Pose::Rotate
Pose Rotate(const Pose &rhs) const
Rotates rhs by the rotation component of this (ONLY the rotation component)
RSI::RapidCode::Cartesian::Quaternion::Set
Quaternion & Set(const Quaternion &rhs)
Assigns other into this.
RSI::RapidCode::Cartesian::Robot::PathClear
void PathClear()=0
Clears out all loaded lines and arcs from the path.
RSI::RapidCode::Cartesian::Quaternion::Set
Quaternion & Set(double w, const Vector3d &vec)
Assigns other into this.
RSI::RapidCode::Cartesian::Vector3d::Normalize
Vector3d & Normalize()
Normalizes this.
RSI::RapidCode::Cartesian::Robot::IsRunning
bool IsRunning()=0
Returns whether or not the robot is in motion (from executor or other source). Can be used to determi...
RSI::RapidCode::Cartesian::Robot::PathDurationGet
double PathDurationGet()=0
Get total (seconds) duration of the planned motion that will happen when run is called.
RSI::RapidCode::Cartesian::Robot::PathPlannedPointsGet
uint64_t PathPlannedPointsGet(double *points, double *times, uint64_t startFrame, uint64_t frameCount)=0
Get points representing the planned motion in cartesian space that will happen when run is called.
RSI::RapidCode::Cartesian::Robot::MoveRelative
void MoveRelative(const Pose &relativePose)=0
Executes a point-to-point motion relative to the current end effector Pose.
RSI::RapidCode::Cartesian::CartesianAxis::Z
@ Z
RSI::RapidCode::Cartesian::Robot::GcodeUnitsSet
void GcodeUnitsSet(LinearUnits units)=0
Set the currently active unit (same as calling G20/G21)
RSI::RapidCode::Cartesian::Robot::PathUnitsGet
LinearUnits PathUnitsGet() const =0
Gets the units of path motion.
RSI::RapidCode::Cartesian::Quaternion::Inverse
Quaternion Inverse() const
Conjugate scaled by 1 / SumSquares()
RSI::RapidCode::Cartesian::Pose::Pose
Pose(const Vector3d position, const Quaternion &quaternion)
Constructor.
RSI::RapidCode::Cartesian::Robot::PathAccelerationGet
double PathAccelerationGet()=0
Gets the target acceleration for the machine (UserUnits/second^2).
RSI::RapidCode::Cartesian::Quaternion::Quaternion
Quaternion()
Default Constructor. W=1, X=Y=Z=0.
RSI::RapidCode::Cartesian::Robot::GcodeReload
void GcodeReload(int32_t startLine)=0
Reloads the lines from the last call to GcodeStringLoad() but only between start line and end of file...
RSI::RapidCode::Cartesian::LinearUnits
LinearUnits
Unit types. For G-code use.
Definition: cartesianrobot.h:76
RSI::RapidCode::Cartesian::Quaternion::FromAngleAxis
static Quaternion FromAngleAxis(double angle, const Vector3d &axis)
Creates a quaternion from an axis angle representation.
RSI::RapidCode::Cartesian::Robot::PathProgrammingModeSet
void PathProgrammingModeSet(PathMode mode)=0
Sets the programming mode (Relative/Absolute).
RSI::RapidCode::Cartesian::Plane::None
@ None
RSI::RapidCode::Cartesian::Robot::InverseKinematics
void InverseKinematics(Pose pose, double *outJoints, uint16_t outJointsSize)=0
Run the given pose through the current inverse kinematic model to see the joint positions the robot w...
RSI::RapidCode::Cartesian::Robot::GcodeStringLoad
bool GcodeStringLoad(const char *const text)=0
Interpret a string as contents of a G-Code file and prepare it for execution.
RSI::RapidCode::Cartesian::Robot::CommandPoseGet
Pose CommandPoseGet()=0
Get the commanded pose of the robot from the trajectory exectutor.
RSI::RapidCode::Cartesian::Vector3d::Cross
Vector3d Cross(const Vector3d &rhs) const
Cross Product. Vector.X = this.Y*rhs.z - this.Z*rhs.Y Vector.Y = this.Z*rhs.X - this....
RSI::RapidCode::Cartesian::Robot::PathProgrammingModeGet
PathMode PathProgrammingModeGet()=0
Gets the programming mode (Relative/Absolute).
RSI::RapidCode::Cartesian::Pose::Pose
Pose(const Quaternion &quaternion)
Constructor.
RSI::RapidCode::Cartesian::Robot::MotionCounterWaitChange
bool MotionCounterWaitChange(uint64_t motionWaitChange, uint64_t timeoutMilliseconds)=0
Waits for the state to change off the specified counter value.
RSI::RapidCode::Cartesian::Robot::GcodeUnitsGet
LinearUnits GcodeUnitsGet()=0
Get the currently active unit as set by G20/G21.
RSI::RapidCode::Cartesian::Robot::JointsCommandPositionsGet
void JointsCommandPositionsGet(double *positions, uint16_t sz)=0
Get the commanded position of the axes in the underlying MultiAxis.
RSI::RapidCode::Cartesian::LinearModelBuilder::ModelBuild
const KinematicModel & ModelBuild() override
Construct the model using the information the builder currently has. The builder will maintain a refe...
RSI::RapidCode::Cartesian::Robot::GcodeWorkOffsetSelect
void GcodeWorkOffsetSelect(GCodeWorkOffset offset)=0
Apply the offset saved under the specified location.
RSI::RapidCode::Cartesian::Quaternion::FromMatrix
static Quaternion FromMatrix(const double *const mat)
Matrix to Quaternion.
RSI::RapidCode::Cartesian::PathState
PathState
State of the Robot.
Definition: cartesianrobot.h:31
RSI::RapidCode::Cartesian::KinematicModelBuilder::KinematicModelBuilder
KinematicModelBuilder(const char *const label)
The KinematicModelBuilder constructor is protected so that only derived classes can use it....
RSI::RapidCode::Cartesian::LinearJointMapping::CartesianCoordinate
CartesianAxis CartesianCoordinate
Definition: cartesianrobot.h:583
RSI::RapidCode::Cartesian::PathMode
PathMode
Motion types. For G-code use and Cartesian path motion.
Definition: cartesianrobot.h:42
RSI::RapidCode::Cartesian::Quaternion::Quaternion
Quaternion(double w, const Vector3d &v)
Constructor.
RSI::RapidCode::Cartesian::Robot::HasError
bool HasError()=0
Get the error state of the underlying Trajectory Executor.
RSI::RapidCode::Cartesian::Robot::GcodeAccelerationRateSet
void GcodeAccelerationRateSet(double unitsPerMinuteSquared)=0
Sets the target acceleration for the machine (units/minute^2). Should be set apprpriately based on yo...
RSI::RapidCode::Cartesian::Pose::Pose
Pose()
Default constructor. Vector(0,0,0) Quaterion(1,0,0,0)
RSI::RapidCode::Cartesian::GCodeWorkOffset
GCodeWorkOffset
Register names for G-Code work offsets.
Definition: cartesianrobot.h:64
RSI::RapidCode::Cartesian::Robot::MotionCounterGet
uint64_t MotionCounterGet()=0
Gets the current motion counter of the Robot.
RSI::RapidCode::Cartesian::Vector3d::Set
Vector3d & Set(double x, double y, double z)
Sets X=x, Y=y, Z=z.
RSI::RapidCode::Cartesian::Robot::GcodeAccelerationRateGet
double GcodeAccelerationRateGet()=0
Gets the target acceleration for the machine (GcodeUnitsGet()/minute^2).
RSI::RapidCode::Cartesian::Pose::Equals
bool Equals(const Pose &rhs, double tolerance) const
Approximate equality check. Checks whether all components are within the tolerance of each other.