Motion system, position & kinematics

public class Position {
 
    // Initializes a new position at the origin
    public Position()
 
    // Initializes a new position
    public Position(double x, double y, double z)
 
    // Returns a string representation of this position
    public override string ToString()
 
    // Coordinate along the X axis
    public double X { get; set; }
 
    // Coordinate along the Y axis
    public double Y { get; set; }
 
    // Coordinate along the Z axis
    public double Z { get; set; }
}

public class Quaternion {
 
    // Initializes a new quaternion with no rotation at all (1, 0, 0, 0)
    public Quaternion()
 
    // Initializes a new quaternion
    public Quaternion(double q1, double q2, double q3, double q4)
 
    // Real component of the quaternion
    public double Q1 { get; set; }
 
    // First imaginary component of the quaternion
    public double Q2 { get; set; }
 
    // Second imaginary component of the quaternion
    public double Q3 { get; set; }
 
    // Third imaginary component of the quaternion
    public double Q4 { get; set; }
 
    // Returns a string representation of this orientation
    public override string ToString()
}

public class Pose : Position {
 
    // Initializes a new pose at the origin, with no rotation
    public Pose()
 
    // Initializes a new pose
    public Pose(double x, double y, double z, double q1, double q2, double q3, double q4)
 
    // Initializes a new pose
    public Pose(double x, double y, double z, Quaternion orientation)
 
    // Orientation held at this position. Never null: a pose built without one carries the identity rotation.
    public Quaternion Orientation { get; set; }
 
    // Returns a string representation of this pose
    public override string ToString()
}

public class RobotConfiguration {
 
    // Initializes a new configuration with every quarter revolution set to zero
    public RobotConfiguration()
 
    // Initializes a new configuration
    public RobotConfiguration(int quarter1, int quarter4, int quarter6, int quarterX)
 
    // Quarter revolution axis 1 sits in
    public int Quarter1 { get; set; }
 
    // Quarter revolution axis 4 sits in
    public int Quarter4 { get; set; }
 
    // Quarter revolution axis 6 sits in
    public int Quarter6 { get; set; }
 
    // Index of the arm configuration, which tells the remaining joint combinations apart
    public int QuarterX { get; set; }
 
    // Returns a string representation of this configuration
    public override string ToString()
}

public class RobotJoints {
 
    // Initializes the six axes to zero
    public RobotJoints()
 
    // Initializes the six axes
    public RobotJoints(double axis1, double axis2, double axis3, double axis4, double axis5, double axis6)
 
    // Value of axis 1
    public double Axis1 { get; set; }
 
    // Value of axis 2
    public double Axis2 { get; set; }
 
    // Value of axis 3
    public double Axis3 { get; set; }
 
    // Value of axis 4
    public double Axis4 { get; set; }
 
    // Value of axis 5
    public double Axis5 { get; set; }
 
    // Value of axis 6
    public double Axis6 { get; set; }
 
    // Returns a string representation of these joint values
    public override string ToString()
}

public class ExternalJoints {
 
    // Initializes the six external axes to zero
    public ExternalJoints()
 
    // Initializes the six external axes
    public ExternalJoints(double axisA, double axisB, double axisC, double axisD, double axisE, double axisF)
 
    // Value of external axis A
    public double AxisA { get; set; }
 
    // Value of external axis B
    public double AxisB { get; set; }
 
    // Value of external axis C
    public double AxisC { get; set; }
 
    // Value of external axis D
    public double AxisD { get; set; }
 
    // Value of external axis E
    public double AxisE { get; set; }
 
    // Value of external axis F
    public double AxisF { get; set; }
 
    // Value the controller reports for an external axis that is not in use
    public const double NotInUse = 9000000000
 
    // Returns a string representation of these external axis values
    public override string ToString()
}

public class RobTarget : Pose {
 
    // Initializes a new target at the origin, with no rotation
    public RobTarget()
 
    // Initializes a new target
    public RobTarget(double x, double y, double z, Quaternion orientation, RobotConfiguration configuration, ExternalJoints externalAxes)
 
    // Axis configuration used to reach the pose. Never null.
    public RobotConfiguration Configuration { get; set; }
 
    // Values of the six external axes, null when the reading does not report them
    public ExternalJoints ExternalAxes { get; set; }
 
    // Returns a string representation of this target
    public override string ToString()
}

public class JointTarget {
 
    // Initializes a new joint target with every axis at zero
    public JointTarget()
 
    // Initializes a new joint target
    public JointTarget(RobotJoints robotAxes, ExternalJoints externalAxes)
 
    // Values of the six external axes. Never null.
    public ExternalJoints ExternalAxes { get; set; }
 
    // Values of the six axes of the robot arm. Never null.
    public RobotJoints RobotAxes { get; set; }
 
    // Returns a string representation of this joint target
    public override string ToString()
}

// Gets the state of one axis of a mechanical unit (synchronous)
AxisInfo GetAxis(string mechanicalUnit, int axis);

// Gets how many axes a mechanical unit has (synchronous)
int GetAxisCount(string mechanicalUnit);

// Gets where one axis of a mechanical unit sits (synchronous) The position is expressed in millimetres.
Pose GetAxisPose(string mechanicalUnit, int axis);

// Gets where the base of a mechanical unit sits (synchronous) The position is expressed in millimetres.
BaseFrame GetBaseFrame(string mechanicalUnit);

// Gets everything the controller knows about one mechanical unit (synchronous)
MechanicalUnitInfo GetMechanicalUnit(string mechanicalUnit);

// Lists the mechanical units of the motion system (synchronous)
MechanicalUnitItem[] GetMechanicalUnits();

// Declares where one axis of a mechanical unit sits (synchronous) The position is expressed in millimetres.
void SetAxisPose(string mechanicalUnit, int axis, Pose pose);

// Declares where the base of a mechanical unit sits (synchronous) The position is expressed in millimetres.
void SetBaseFrame(string mechanicalUnit, Pose baseFrame);

// Changes one or several properties of a mechanical unit (synchronous) Every argument but the unit name is optional; leave the ones you do not want to touch null. At least one of them has to be given.
void SetMechanicalUnit(string mechanicalUnit, string tool = null, string workObject = null, string payload = null, string totalPayload = null, MechanicalUnitMode? mode = null, JogMode? jogMode = null, CoordinateSystem? coordinateSystem = null);

// Places a mechanical unit at the given joint values without moving it there (synchronous) Only a virtual controller accepts this: it teleports the simulated robot, which a real one cannot do.
void SetMechanicalUnitPosition(string mechanicalUnit, JointTarget position);

public class MechanicalUnitItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.MechanicalUnitItem" data-throw-if-not-resolved="false"></xref> class
    public MechanicalUnitItem()
 
    // Whether the unit can be activated, null when the controller did not report it
    public bool? ActivationAllowed { get; set; }
 
    // Number of the drive module the unit is connected to, null when the controller did not report it
    public int? DriveModule { get; set; }
 
    // Whether the unit is activated
    public MechanicalUnitMode Mode { get; set; }
 
    // Name of the mechanical unit, for example "ROB_1"
    public string Name { get; set; }
 
    // Returns a string representation of this mechanical unit
    public override string ToString()
}

public class MechanicalUnitInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.MechanicalUnitInfo" data-throw-if-not-resolved="false"></xref> class
    public MechanicalUnitInfo()
 
    // Number of axes of the unit, null when the controller did not report it
    public int? Axes { get; set; }
 
    // Reference frame the cartesian positions of the unit are expressed in
    public CoordinateSystem CoordinateSystem { get; set; }
 
    // Name of the mechanical unit integrated into this one. A unit that integrates no other one is
    // reported with a placeholder name rather than an empty value.
    public string HasIntegratedUnit { get; set; }
 
    // Name of the mechanical unit this one is integrated into. A unit that is integrated into no other
    // one is reported with a placeholder name rather than an empty value.
    public string IsIntegratedUnit { get; set; }
 
    // How the jogging commands sent to the unit are interpreted
    public JogMode JogMode { get; set; }
 
    // Whether the unit is activated
    public MechanicalUnitMode Mode { get; set; }
 
    // Name of the mechanical unit, for example "ROB_1"
    public string Name { get; set; }
 
    // Name of the active payload
    public string PayloadName { get; set; }
 
    // Calibration and synchronization state of the unit
    public MechanicalUnitStatus Status { get; set; }
 
    // Name of the RAPID task that drives the unit
    public string TaskName { get; set; }
 
    // Returns a string representation of this mechanical unit
    public override string ToString()
 
    // Name of the active tool
    public string ToolName { get; set; }
 
    // Number of axes of the unit and of the units integrated with it,
    // null when the controller did not report it
    public int? TotalAxes { get; set; }
 
    // Name of the active total payload, which is the payload plus the load of the tool
    public string TotalPayloadName { get; set; }
 
    // Kind of mechanical unit
    public MechanicalUnitType Type { get; set; }
 
    // Name of the active work object
    public string WorkObjectName { get; set; }
}

public enum MechanicalUnitMode {
 
    // The mechanical unit is activated and takes part in the motion
    Activated = 1
 
    // The mechanical unit is deactivated and stays where it is
    Deactivated = 2
 
    // The controller reported a mode this library does not know
    Unknown = 0
}

public enum MechanicalUnitType {
 
    // No mechanical unit
    None = 1
 
    // A robot arm without a tool center point, which can only be moved axis by axis
    Robot = 3
 
    // A single external axis, such as a track or a positioner
    Single = 4
 
    // A robot arm holding a tool center point, which can be moved in cartesian coordinates
    TcpRobot = 2
 
    // The controller knows the unit but does not report what it is
    Undefined = 5
 
    // The controller reported a type this library does not know
    Unknown = 0
}

public enum MechanicalUnitStatus {
 
    // The unit is starting up
    Initiated = 1
 
    // The unit is locked and refuses to move
    Locked = 7
 
    // The unit is locked, and the controller shows it as such
    LockedShow = 8
 
    // One or several absolute measurement axes are not synchronized
    NotAbsoluteSynchronized = 4
 
    // The unit has never been calibrated
    NotCalibrated = 3
 
    // One or several motors have not been commutated
    NotCommutated = 2
 
    // One or several relative measurement axes are not synchronized
    NotRelativeSynchronized = 5
 
    // The unit is calibrated and synchronized, and can be moved
    Synchronized = 6
 
    // The controller knows the unit but does not report its state
    Undefined = 9
 
    // The controller reported a state this library does not know
    Unknown = 0
}

public class AxisInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.AxisInfo" data-throw-if-not-resolved="false"></xref> class
    public AxisInfo()
 
    // Logical joint number of the axis, null when the controller did not report it
    public int? LogicalAxis { get; set; }
 
    // Number of the axis inside its mechanical unit, starting at 1
    public int Number { get; set; }
 
    // Calibration and synchronization state of the axis
    public MechanicalUnitStatus Status { get; set; }
 
    // Returns a string representation of this axis
    public override string ToString()
}

public class BaseFrame : Pose {
 
    // Initializes a new base frame at the origin, with no rotation
    public BaseFrame()
 
    // Returns a string representation of this base frame
    public override string ToString()
 
    // Kind of base frame the controller reports, for example "IRBRobot"
    public string Type { get; set; }
}

public enum CoordinateSystem {
 
    // The base frame of the mechanical unit
    Base = 2
 
    // The frame of the active tool
    Tool = 3
 
    // The controller reported a frame this library does not know
    Unknown = 0
 
    // The frame of the active work object
    WorkObject = 4
 
    // The world frame, shared by every mechanical unit of the system
    World = 1
}

public enum JogMode {
 
    // The tool is aligned with the closest axis of the active coordinate system
    Align = 4
 
    // Each command moves one axis of the first axis group
    AxisGroup1 = 1
 
    // Each command moves one axis of the second axis group
    AxisGroup2 = 2
 
    // The tool is moved along the axes of the active coordinate system
    Cartesian = 3
 
    // The robot changes axis configuration without moving the tool center point
    ConfigurationJog = 6
 
    // The robot moves to a given position
    GoToPosition = 5
 
    // The controller reported a mode this library does not know
    Unknown = 0
}

// Gets where the tool of a mechanical unit currently is, without the external axes (synchronous) The position is expressed in millimetres.
RobTarget GetCartesianPosition(string mechanicalUnit, CoordinateSystem coordinateSystem = CoordinateSystem.Base, string tool = null, string workObject = null, bool logErrors = false);

// Gets the joint values a mechanical unit currently stands at (synchronous) The robot axes are expressed in degrees.
JointTarget GetJointTarget(string mechanicalUnit, bool alwaysRead = false);

// Gets the physical joint values of a mechanical unit, as its measurement system reads them (synchronous)
RobotJoints GetPhysicalJoints(string mechanicalUnit);

// Gets where the tool of a mechanical unit currently is (synchronous) The position is expressed in millimetres.
RobTarget GetRobTarget(string mechanicalUnit, CoordinateSystem coordinateSystem = CoordinateSystem.Base, string tool = null, string workObject = null);

// Gets what each of the six external joints of a task is doing (synchronous) This is what says how to read the corresponding value of GetJointTarget(System.String): a joint reported as not active carries no meaningful position.
RapidExternalJointStates GetExternalJointStates(string task);

// Gets the joint values of the robot of a task (synchronous)
JointTarget GetJointTarget(string task);

// Gets the mechanical units the positions of a task are expressed in (synchronous)
RapidMechanicalUnitItem[] GetMechanicalUnits(string task);

// Gets where the tool of a task currently stands, as a position and an orientation (synchronous)
RobTarget GetRobTarget(string task, string tool = null, string workObject = null);

public class RapidExternalJointStates {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidExternalJointStates" data-throw-if-not-resolved="false"></xref> class
    public RapidExternalJointStates()
 
    // State of the first external joint
    public RapidJointState Joint1 { get; set; }
 
    // State of the second external joint
    public RapidJointState Joint2 { get; set; }
 
    // State of the third external joint
    public RapidJointState Joint3 { get; set; }
 
    // State of the fourth external joint
    public RapidJointState Joint4 { get; set; }
 
    // State of the fifth external joint
    public RapidJointState Joint5 { get; set; }
 
    // State of the sixth external joint
    public RapidJointState Joint6 { get; set; }
 
    // Returns a string representation of these joint states
    public override string ToString()
}

public enum RapidJointState {
 
    // The joint moves along a line
    Linear = 1
 
    // The joint is active but has no position
    NoPosition = 4
 
    // The joint is not active
    NotActive = 3
 
    // The joint turns
    Rotating = 2
 
    // The controller reported a state this library does not know
    Unknown = 0
}

public class RapidMechanicalUnitItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidMechanicalUnitItem" data-throw-if-not-resolved="false"></xref> class
    public RapidMechanicalUnitItem()
 
    // Whether the unit is activated
    public MechanicalUnitMode Mode { get; set; }
 
    // Name of the unit, for example "ROB_1"
    public string Name { get; set; }
 
    // Returns a string representation of this unit
    public override string ToString()
 
    // Kind of unit
    public MechanicalUnitType Type { get; set; }
}

// Places a mechanical unit at the given joint values without moving it there (synchronous) Only a virtual controller accepts this: it teleports the simulated robot, which a real one cannot do.
void SetMechanicalUnitPosition(string mechanicalUnit, JointTarget position);

// Sends the robot to a cartesian target (synchronous) The position is expressed in millimetres, in the coordinate system currently active for the mechanical unit selected for jogging.
void SetPositionTarget(RobTarget target);

// Moves the mechanical unit currently selected for jogging (synchronous) The unit is the one SetJoggingMechanicalUnit(System.String) chose, and how the six values are interpreted depends on its jog mode: axis by axis, along the axes of a coordinate system, and so on.
void Jog(RobotJoints axes, int changeCount, JogIncrementMode incrementMode = JogIncrementMode.None);

// Chooses which mechanical unit the jogging commands apply to (synchronous)
void SetJoggingMechanicalUnit(string mechanicalUnit);

public enum JogIncrementMode {
 
    // One large step
    Large = 4
 
    // One medium step
    Medium = 3
 
    // The robot moves for as long as the command is repeated, with no fixed step
    None = 0
 
    // One small step
    Small = 2
 
    // One step of the size configured in the system parameters
    User = 1
}

// Asks the controller for every joint combination that puts the tool at the given pose (synchronous) A six axis robot usually reaches the same pose in eight different ways, each one in a different axis configuration.
JointSolution[] GetAllJointSolutions(string mechanicalUnit, Pose pose, ExternalJoints externalAxes, Pose toolFrame, RobotConfiguration configuration, bool robotHoldsWorkObject = false);

// Asks the controller which joint values put the tool at the given pose, staying close to the joint values the robot is already in (synchronous)
JointTarget GetJointsFromCartesian(string mechanicalUnit, Pose pose, ExternalJoints externalAxes, Pose toolFrame, JointTarget previousJoints, RobotConfiguration configuration, bool robotHoldsWorkObject = false, bool logErrors = false);

// Asks the controller which joint values put the tool at the given pose (synchronous)
JointTarget GetJointsFromPose(string mechanicalUnit, Pose pose, ExternalJoints externalAxes, Pose toolFrame, JointTarget previousJoints, RobotConfiguration configuration, bool robotHoldsWorkObject = false, bool logErrors = false);

// Asks the controller where the tool would be if the robot stood at the given joint values, without moving it there (synchronous)
RobTarget GetPoseFromJoints(string mechanicalUnit, Pose toolFrame, JointTarget joints, bool robotHoldsWorkObject = false, bool logErrors = false);

public class JointSolution : JointTarget {
 
    // Initializes a new solution with every axis at zero
    public JointSolution()
 
    // Axis configuration this solution corresponds to. Never null.
    public RobotConfiguration Configuration { get; set; }
 
    // Returns a string representation of this solution
    public override string ToString()
}

// Tells whether the controller predicts collisions before they happen (synchronous) Collision prediction stops the robot before it hits something it knows about, where the motion supervision only reacts once the arm meets an unexpected resistance.
bool GetCollisionPredictionMode();

// Gets the collision detection settings that apply while a mechanical unit is jogged (synchronous)
MotionSupervision GetMotionSupervision(string mechanicalUnit);

// Tells whether the controller runs RAPID programs without moving the robot (synchronous) In that mode the program executes normally but every motion instruction is skipped, which is how a program is tested without the robot leaving its position.
bool GetNonMotionExecutionMode();

// Gets the collision detection settings that apply while a mechanical unit follows a programmed path (synchronous)
PathSupervision GetPathSupervision(string mechanicalUnit);

// Switches collision prediction on or off (synchronous)
void SetCollisionPredictionMode(bool enabled);

// Sets how sensitive the jogging collision detection of a mechanical unit is (synchronous)
void SetMotionSupervisionLevel(string mechanicalUnit, int sensitivity);

// Switches the jogging collision detection of a mechanical unit on or off (synchronous)
void SetMotionSupervisionMode(string mechanicalUnit, bool enabled);

// Chooses whether the controller runs RAPID programs without moving the robot (synchronous)
void SetNonMotionExecutionMode(bool enabled);

// Sets how sensitive the path collision detection of a mechanical unit is (synchronous)
void SetPathSupervisionLevel(string mechanicalUnit, int level);

// Switches the path collision detection of a mechanical unit on or off (synchronous)
void SetPathSupervisionMode(string mechanicalUnit, bool enabled);

public class MotionSupervision {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.MotionSupervision" data-throw-if-not-resolved="false"></xref> class
    public MotionSupervision()
 
    // Whether the supervision is switched on, null when the controller did not report it
    public bool? Enabled { get; set; }
 
    // Sensitivity of the supervision, as a percentage: the lower the value, the sooner a collision is
    // reported. Null when the controller did not report it.
    public int? Level { get; set; }
 
    // Returns a string representation of these settings
    public override string ToString()
}

public class PathSupervision {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.PathSupervision" data-throw-if-not-resolved="false"></xref> class
    public PathSupervision()
 
    // Whether the supervision is switched on, null when the controller did not report it
    public bool? Enabled { get; set; }
 
    // Sensitivity of the supervision, as a percentage: the lower the value, the sooner a collision is
    // reported. Null when the controller did not report it.
    public int? Level { get; set; }
 
    // Returns a string representation of these settings
    public override string ToString()
}

// Tells whether an operator can push the arm of a mechanical unit around by hand (synchronous)
LeadThroughStatus GetLeadThrough(string mechanicalUnit);

// Lets an operator push the arm of a mechanical unit around by hand, or stops letting them (synchronous)
void SetLeadThrough(string mechanicalUnit, bool active);

public enum LeadThroughStatus {
 
    // The arm gives way when pushed
    Active = 1
 
    // The arm holds its position
    Inactive = 2
 
    // The controller reported a state this library does not know
    Unknown = 0
}