Due to the size of data types across platforms, the C++ version of the library required type aliasing of some primitives. These aliases are not needed and therefore not present in the C# version of the library.
¶ ControlGroupId
Selection of control groups. Encompasses robots, bases, and stations.
public enum ControlGroupId
{
R1 = 1, R2 = 2, R3 = 3, R4 = 4, R5 = 5, R6 = 6, R7 = 7, R8 = 8,
B1 = 11, B2 = 12, B3 = 13, B4 = 14, B5 = 15, B6 = 16, B7 = 17, B8 = 18,
S1 = 21, S2 = 22, S3 = 23, S4 = 24, S5 = 25, S6 = 26, S7 = 27, S8 = 28,
S9 = 29, S10 = 30, S11 = 31, S12 = 32, S13 = 33, S14 = 34, S15 = 35, S16 = 36,
S17 = 37, S18 = 38, S19 = 39, S20 = 40, S21 = 41, S22 = 42, S23 = 43, S24 = 44
};
¶ SystemInfoId
The type of information to be requested from the controller by the GetSystemInfo function.
This includes robots, stations and application number.
public enum SystemInfoId
{
R1 = 11, R2 = 12, R3 = 13, R4 = 14, R5 = 15, R6 = 16, R7 = 17, R8 = 18, // Robot number
S1 = 21, S2 = 22, S3 = 23, S4 = 24, S5 = 25, S6 = 26, S7 = 27, S8 = 28, // Station number
S9 = 29, S10 = 30, S11 = 31, S12 = 32, S13 = 33, S14 = 34, S15 = 35, S16 = 36,
S17 = 37, S18 = 38, S19 = 39, S20 = 40, S21 = 41, S22 = 42, S23 = 43, S24 = 44,
A1 = 101, A2 = 102, A3 = 103, A4 = 104, A5 = 105, A6 = 106, A7 = 107, A8 = 108 //Application number.
};
¶ AlarmCategory
Type of alarm to retrieve. Used by the GetActiveAlarms and GetAlarmHistory functions
public enum AlarmCategory { Major = 0, Minor = 1000, UserSystem = 2000, User = 3000, Offline = 4000 };
¶ CoordinateType
public enum CoordinateType { Pulse = 0, BaseCoordinate = 16, RobotCoordinate = 17, ToolCoordinate = 18, UserCoordinate = 19, MasterTool = 20, Undefined = 55, Angle = 56 };
¶ ControlMode
Specifies whether the controller is set to Teach, Play, or Remote mode.
public enum ControlMode { Teach, Play, Remote };
¶ FrontOrBack
The location of the B axis rotation when viewed from the right side of the robot.
Front: center of the B-axis is to the right of the S-axis rotation center.
Back: center of the B-axis is to the left of the S-axis rotation center.
public enum FrontOrBack { Front, Back };
¶ UpperOrLower
The angle of the elbow (L and U axis) when viewed by the right side. Upper is less than 180 degrees, lower is greater than 180 degrees.
public enum UpperOrLower { Upper, Lower };
¶ FlipOrNoFlip
Flip: B axis is in positive direction (Theta B > = 0 degrees).
NoFlip = B axis is in negative direction (Theta B < 0 degrees).
public enum FlipOrNoFlip { Flip, NoFlip };
¶ AxisAngle
Specify if an angle is less than or greater than 180 degrees.
public enum AxisAngle { LessThan180, GreaterThanOrEqual180 };
¶ CycleMode
public enum CycleMode { Step = 0, Cycle, Automatic };
¶ TimeType
Type of time to request when calling GetOperatingTime.
public enum TimeType
{
ControllerOnTime = 1,
ServoPowerOnTimeTotal = 10,
ServoPowerOnTimeRobot = 11,
ServoPowerOnTimeStation = 20,
PlayBackTimeTotal = 110,
PlayBackTimeRobot = 111,
PlayBackTimeStation = 120,
MovingTimeTotal = 210,
MovingTimeRobot = 211,
MovingTimeStation = 221,
ApplicationOperationTime = 300
};
¶ ApplicationNumber
Application ex. Arc Welding, Spot Welding, Painting, General Purpose.
On standard pendant, assignments can be found from the main menu under
[System Information]>[Controller Information] under the APPLICATION section.
public enum ApplicationNumber
{
ApplicationOne = 1,
ApplicationTwo,
ApplicationThree,
ApplicationFour,
ApplicationFive,
ApplicationSix,
ApplicationSeven,
ApplicationEight
};
¶ SystemParameterType
Used to specify the type of system parameter to be retrieved by the GetSystemParameter function.
public enum SystemParameterType
{
S1CG = 0, /* S1CxG requires group number.*/
S2C = 1, /* S2C */
S3C = 2, /* S3C */
S4C = 3, /* S4C */
RS = 4, /* RS */
AP = 5, /* AxP requires group number*/
SE = 6, /* SxE requires group number*/
};
¶ InformTaskNumber
Specifies the task to reference when getting the executing job information and job stack.
public enum InformTaskNumber
{
Master, Subtask1, Subtask2, Subtask3, Subtask4, Subtask5, Subtask6,
Subtask7, Subtask8, Subtask9, Subtask10, Subtask11, Subtask12, Subtask13, Subtask14, Subtask15
};
¶ FileType
Specifies file types for file interface operations.
public enum FileType { Job_JBI, Data_DAT, Condition_CND, Parameter_PRM, System_SYS, Ladder_LST, Log_LOG };
¶ IOType
Category of I/O signal. All signal categories are readable. Writing is limited to NetworkInput.
Additionally, GeneralOutput can be written on YRC1000 or newer controllers.
public enum IOType
{
GeneralInput, GeneralOutput, ExternalInput, NetworkInput, ExternalOutput, NetworkOutput,
SpecificInput, SpecificOutput, InterfacePanelInput, AuxiliaryRelay, RobotControlStatus, PsuedoInput
};
¶ MoveInterpolationType
public enum MoveInterpolationType { NoneSelected, MoveJoint, MoveLinear, MoveCircular };
¶ SignalStatus
Activate or deactivate Hold, Servo.
public enum SignalStatus { ON = 1, OFF = 2 };
¶ KinematicConversions
When converting between coordinate types using the KinematicsInterface, specifies the conversion to use.
public enum KinematicConversions
{
JointAngleToCartesianPos, // Convert Joint Angles(in degrees) To Cartesian Position.
PulseToJointAngle, // Convert Pulse position To Joint Angles(in degrees).
JointAngleToPulse, // Convert Joint Angles(in degrees) To Pulse.
PulseToCartesianPos, // Convert Pulse position To Cartesian Position.
CartesianPosToJointAngle,
CartesianPosToPulse
};
¶ KinematicType
Specifies how to solve inverse kinematics when converting from cartesian position. Used when calling ConvertPosition in the Kinematics interface.
public enum KinematicType
{
Default,// Calculate using parameter S2C430 value. 2:Delta, 1:Figure
Delta,// Calculate by prevAngle. If this type is selected, prevAngle must be provided.
Figure //Calculate by the figure set in the position to convert.
};
¶ AxisIndex
The index of each axis in the CoordinateArray.
namespace AxisIndex
{
public enum PulseAxis { S = 0, L, U, R, B, T, E, W };
public enum CartesianAxis { X = 0, Y, Z, Rx, Ry, Rz, Re, Rw };
};
¶ Figure
¶ Members
| Name | Description |
|---|---|
| FrontOrBack | The location of the B axis rotation when viewed from the right side of the robot. See FrontOrBack. |
| UpperOrLower | The angle of the elbow (L and U axis) when viewed from the right side. See UpperOrLower. |
| FlipOrNoFlip | Indicates whether the B axis is in positive (Flip) or negative (NoFlip) direction. See FlipOrNoFlip. |
| AxisAngles | Array specifying if each axis angle is less than or greater than 180 degrees. See AxisAngle. |
public struct Figure
{
public FrontOrBack FrontOrBack{ get; set;}
public UpperOrLower UpperOrLower{ get; set;}
public FlipOrNoFlip FlipOrNoFlip{ get; set;}
public AxisAngle[] AxisAngles { get; set; }
public Figure()
{
AxisAngles = new AxisAngle[8];
}
public Figure(FrontOrBack frontOrBack, UpperOrLower upperOrLower, FlipOrNoFlip flipOrNoFlip, AxisAngle[] axisAngles)
{
this.FrontOrBack = frontOrBack;
this.UpperOrLower = upperOrLower;
this.FlipOrNoFlip = flipOrNoFlip;
this.AxisAngles = axisAngles;
}
public override string ToString()
{
StringBuilder sb = new();
sb.Append($"FrontOrBack: {FrontOrBack}\nUpperOrLower: {UpperOrLower}\nFlipOrNoFlip: {FlipOrNoFlip}\nAxisAngles: \n");
for (int i = 0; i < 7; i++)
{
sb.Append((PulseAxis)i + ": ");
sb.Append($"{AxisAngles[i]}\n");
}
sb.Append(PulseAxis.W + ": ");
sb.Append($"{AxisAngles[7]}");
return sb.ToString();
}
}
¶ PositionData
¶ Members
| Name | Description |
|---|---|
| CoordinateType | The type of coordinate system in which the axis data is represented. See CoordinateType. |
| Figure | Used to represent a robot configuration when the coordinate system is cartesian. See Figure. |
| ToolNumber | 0 if the coordinate type is anything other than ToolCoordinate. |
| UserCoordinateNumber | 0 if the coordinate type is anything other than UserCoordinate. |
| AxisData | Pulse counts for coordinate type pulse, millimeters and joint angles otherwise. |
public struct PositionData
{
public CoordinateType CoordinateType { get; set; }
public Figure Figure { get; set; }//Used to represent a robot configuration when the coordinate system is cartesian.
public UInt32 ToolNumber { get; set; } //|0 if the coordinate type is anything other than ToolCoordinate.
public UInt32 UserCoordinateNumber { get; set; } //Only used when coordinateType is UserCoordinate. Otherwise it is 0. Only used with robot position variables.
public CoordinateArray AxisData { get; set; }//Pulse counts for coordinate type pulse, millimeters and joint angles otherwise.
public PositionData()
{
Figure = new Figure();
AxisData = new double[8];
}
public PositionData(CoordinateType coordinateType, Figure figure, UInt32 toolNumber, UInt32 userCoordinateNumber, CoordinateArray axisData)
{
this.CoordinateType = coordinateType;
this.Figure = figure;
this.ToolNumber = toolNumber;
this.UserCoordinateNumber = userCoordinateNumber;
this.AxisData = axisData;
}
public override string ToString()
{
StringBuilder sb = new();
if (CoordinateType == CoordinateType.Pulse)
{
sb.Append($"CoordinateType: {CoordinateType}\nToolNumber: {ToolNumber}\nAxisData:\n");
for(int i = 0; i < 8; i++)
{
sb.Append((PulseAxis)i + ": ");
sb.Append($"{AxisData[i]} pulse\n");
}
}
else
{
sb.Append($"CoordinateType: {CoordinateType}\nFigure:\n{Figure}\nToolNumber: {ToolNumber}\nUserCoordinateNumber: {UserCoordinateNumber}\nAxisData:\n");
//first 3 axes are measured in mm, the rest are joint angles.
for (int i = 0; i < 3; i++)
{
sb.Append((CartesianAxis)i + ": ");
sb.Append($"{AxisData[i]} mm\n");
}
for (int i = 3; i < 8; i++)
{
sb.Append((CartesianAxis)i + ": ");
sb.Append($"{AxisData[i]} deg\n");
}
}
return sb.ToString();
}
}
¶ AxisConfigurationData
¶ Members
| Name | Description |
|---|---|
| AxisConfiguration | Array representing axis configuration characters. |
public struct AxisConfigurationData
{
public char[] AxisConfiguration { get; set; } = new char[8];
public AxisConfigurationData()
{
}
public override string ToString()
{
StringBuilder sb = new();
sb.Append("AxisConfiguration:\n");
foreach (var axis in AxisConfiguration)
{
sb.Append($"{axis}\n");
}
return sb.ToString();
}
}
¶ AlarmData
¶ Members
| Name | Description |
|---|---|
| Code | Alarms main code. |
| Subcode | Alarm subcode. |
| Time | Time when the alarm occurred. |
| Name | Name or description of the alarm. |
public struct AlarmData(int code, int subcode, string? time, string? name)
{
public Int32 Code { get; set; } = code;
public Int32 Subcode { get; set; } = subcode;
public string? Time { get; set; } = time;
public string? Name { get; set; } = name;
public override readonly string ToString()
{
return $"Code: {Code}\nSubcode: {Subcode}\nTime: {Time}\nName: {Name}";
}
};
¶ ActiveAlarms
A structure containing all of the active alarms on the controller. There can be four alarms at a time.
¶ Members
| Name | Description |
|---|---|
| Count | Number of active alarms. |
| Alarms | Array of active alarm data. See AlarmData. |
public struct ActiveAlarms
{
public const Int32 MaxActiveAlarms = 4;
public ActiveAlarms(int count, AlarmData[] alarms)
{
Count = count;
Alarms = new AlarmData[MaxActiveAlarms];
for (int i = 0; i < MaxActiveAlarms; i++)
{
Alarms[i] = alarms[i];
}
}
public ActiveAlarms()
{
Count = 0;
Alarms = new AlarmData[MaxActiveAlarms];
}
public Int32 Count { get; set; }
public AlarmData[] Alarms { get; set; }
public override string ToString()
{
StringBuilder sb = new();
sb.Append($"Count: {Count}\nAlarms:\n");
foreach (var alarm in Alarms)
{
sb.Append($"{alarm}\n");
}
return sb.ToString();
}
};
¶ AlarmHistory
The previous n alarms of the controller. n = numberOfAlarmsFetched. Also includes any active alarms.
¶ Members
| Name | Description |
|---|---|
| NumberOfAlarmsFetched | Number of alarms in the array. |
| Alarms | Array of alarms. See AlarmData. |
public struct AlarmHistory
{
public const Int32 AlarmHistorySize = 100;
public AlarmHistory(int count, AlarmData[] alarms)
{
NumberOfAlarmsFetched = count;
Alarms = new AlarmData[AlarmHistorySize];
for (int i = 0; i < AlarmHistorySize; i++)
{
Alarms[i] = alarms[i];
}
}
public AlarmHistory()
{
NumberOfAlarmsFetched = 0;
Alarms = new AlarmData[AlarmHistorySize];
}
public Int32 NumberOfAlarmsFetched { get; set; }
public AlarmData[] Alarms { get; set; }
public override string ToString()
{
StringBuilder sb = new();
sb.Append($"NumberOfAlarmsFetched: {NumberOfAlarmsFetched}\nAlarms: ");
for (int i = 0; i < NumberOfAlarmsFetched; i++)
{
sb.Append($"{Alarms[i]}\n");
}
return sb.ToString();
}
};
¶ PositionErrorData
¶ Members
| Name | Description |
|---|---|
| AxisData | Array of position error values for each axis. |
public struct PositionErrorData
{
public Int32[] AxisData { get; set; } = new Int32[8];
public PositionErrorData()
{
}
public PositionErrorData(Int32[] axisData)
{
this.AxisData = axisData;
}
public override string ToString()
{
StringBuilder sb = new();
sb.Append("AxisData:\n");
for(int i = 0; i < 8; i++)
{
sb.Append("Axis " + i + ": ");
sb.Append($"{AxisData[i]}\n");
}
return sb.ToString();
}
}
¶ TorqueData
Torque data of a control group. Includes the control group ID and the axis torques. Expressed as a percentage.
¶ Members
| Name | Description |
|---|---|
| ControlGroupId | Control group ID of the requested data. See ControlGroupId. |
| AxisData | Torque values for each axis. |
public struct TorqueData
{
public ControlGroupId ControlGroupId { get; set; }
public Int32[] AxisData { get; set; } = new Int32[8];
public TorqueData()
{
}
public override string ToString()
{
StringBuilder sb = new();
for (int i = 0; i < 8; i++)
{
sb.Append("Axis " + i + ": ");
sb.Append($"{AxisData[i]}\n");
}
return sb.ToString();
}
}
¶ ControllerStateData
All of the information about the controller's state. Includes the running mode, control mode, and hold status.
¶ Members
| Name | Description |
|---|---|
| CycleMode | Current cycle mode of the controller. See CycleMode. |
| IsRunning | True if the controllers equipment is in motion. |
| ControlMode | Current control mode of the controller. See ControlMode |
| IsInHold | True if controller is in a hold status. |
| IsAlarming | True if controller has an active alarm. |
| IsErroring | True if an error is happening. |
| IsServoOn | True if the servo is on. |
public struct ControllerStateData
{
public CycleMode CycleMode { get; set; }
public bool IsRunning { get; set; }
public ControlMode ControlMode { get; set; }
public bool IsInHold { get; set; }
public bool IsAlarming { get; set; }
public bool IsErroring{ get; set; }
public bool IsServoOn{ get; set; }
public ControllerStateData(CycleMode cycleMode, bool isRunning, ControlMode controlMode, bool isInHold, bool isAlarming, bool isErroring, bool isServoOn)
{
this.CycleMode = cycleMode;
this.IsRunning = isRunning;
this.ControlMode = controlMode;
this.IsInHold = isInHold;
this.IsAlarming = isAlarming;
this.IsErroring = isErroring;
this.IsServoOn = isServoOn;
}
public ControllerStateData()
{
CycleMode = CycleMode.Step;
IsRunning = false;
ControlMode = ControlMode.Teach;
IsInHold = false;
IsAlarming = false;
IsErroring = false;
IsServoOn = false;
}
public override readonly string ToString()
{
return $"CycleMode: {CycleMode}\n" +
$"IsRunning: {IsRunning}\n" +
$"ControlMode: {ControlMode}\n" +
$"IsInHold: {IsInHold}\n" +
$"IsAlarming: {IsAlarming}\n" +
$"IsErroring: {IsErroring}\n" +
$"IsServoOn: {IsServoOn}";
}
}
¶ XyzVector
Type of position vector.
¶ Members
| Name | Description |
|---|---|
| X | X-coordinate value. |
| Y | Y-coordinate value. |
| Z | Z-coordinate value. |
public struct XyzVector
{
public double X { get; set; } = 0.0;
public double Y { get; set; } = 0.0;
public double Z { get; set; } = 0.0;
public XyzVector() { }
public XyzVector(double x, double y, double z)
{
X = x;
Y = y;
Z = z;
}
public override readonly string ToString()
{
return $"X: {X}\nY: {Y}\nZ: {Z}";
}
};
¶ EulerMatrix
Representation of the pose in 3D space. Includes the position and orientation. Orientation is represented as ZYX-intrinsic (roll, pitch, yaw).
https://en.wikipedia.org/wiki/Rotation_matrix
¶ Members
| Name | Description |
|---|---|
| Nx, Ny, Nz | Components of the N (normal) vector. |
| Ox, Oy, Oz | Components of the O (orientation) vector. |
| Ax, Ay, Az | Components of the A (approach) vector. |
| Px, Py, Pz | Position coordinates. |
public struct EulerMatrix
{
public double Nx { get; set; } = 0.0;
public double Ny { get; set; } = 0.0;
public double Nz { get; set; } = 0.0;
public double Ox { get; set; } = 0.0;
public double Oy { get; set; } = 0.0;
public double Oz { get; set; } = 0.0;
public double Ax { get; set; } = 0.0;
public double Ay { get; set; } = 0.0;
public double Az { get; set; } = 0.0;
public double Px { get; set; } = 0.0;
public double Py { get; set; } = 0.0;
public double Pz { get; set; } = 0.0;
public EulerMatrix()
{
}
public EulerMatrix(double nx, double ny, double nz, double ox, double oy, double oz, double ax, double ay, double az, double px, double py, double pz)
{
this.Nx = nx;
this.Ny = ny;
this.Nz = nz;
this.Ox = ox;
this.Oy = oy;
this.Oz = oz;
this.Ax = ax;
this.Ay = ay;
this.Az = az;
this.Px = px;
this.Py = py;
this.Pz = pz;
}
public override readonly string ToString()
{
return $"Nx: {Nx}\nNy: {Ny}\nNz: {Nz}\nOx: {Ox}\nOy: {Oy}\nOz: {Oz}\nAx: {Ax}\nAy: {Ay}\nAz: {Az}\nPx: {Px}\nPy: {Py}\nPz: {Pz}";
}
}
¶ ByteVariableData
The value and index of a byte(B) variable.
¶ Members
| Name | Description |
|---|---|
| Value | Byte value of the variable. |
| VariableIndex | Index of the byte variable. |
public struct ByteVariableData
{
public Byte Value { get; set; }
public UInt16 VariableIndex { get; set; }
public ByteVariableData(Byte variableData, UInt16 variableIndex)
{
Value = variableData;
VariableIndex = variableIndex;
}
public ByteVariableData()
{
Value = 0;
VariableIndex = 0;
}
public override readonly string ToString()
{
return $"B{VariableIndex.ToString().PadLeft(3,'0')}={Value}";
}
}
¶ IntegerVariableData
The value and index of an integer(I) variable.
¶ Members
| Name | Description |
|---|---|
| Value | Integer value of the variable. |
| VariableIndex | Index of the integer variable. |
public struct IntegerVariableData
{
public Int16 Value { get; set; }
public UInt16 VariableIndex { get; set; }
public IntegerVariableData(Int16 variableData, UInt16 variableIndex)
{
Value = variableData;
VariableIndex = variableIndex;
}
public IntegerVariableData()
{
Value = 0;
VariableIndex = 0;
}
public override readonly string ToString()
{
return $"I{VariableIndex.ToString().PadLeft(3, '0')}={Value}";
}
}
¶ DoubleIntVariableData
The value and index of an double(D) variable.
¶ Members
| Name | Description |
|---|---|
| Value | Double integer value of the variable. |
| VariableIndex | Index of the double integer variable. |
public struct DoubleIntVariableData
{
public Int32 Value { get; set; }
public UInt16 VariableIndex { get; set; }
public DoubleIntVariableData(Int32 variableData, UInt16 variableIndex)
{
Value = variableData;
VariableIndex = variableIndex;
}
public DoubleIntVariableData()
{
Value = 0;
VariableIndex = 0;
}
public override readonly string ToString()
{
return $"D{VariableIndex.ToString().PadLeft(3, '0')}={Value}";
}
}
¶ RealVariableData
The value and index of a real(R) variable.
¶ Members
| Name | Description |
|---|---|
| Value | Real (floating-point) value of the variable. |
| VariableIndex | Index of the real variable. |
public struct RealVariableData
{
public float Value { get; set; }
public UInt16 VariableIndex { get; set; }
public RealVariableData(float variableData, UInt16 variableIndex)
{
Value = variableData;
VariableIndex = variableIndex;
}
public RealVariableData()
{
Value = 0;
VariableIndex = 0;
}
public override readonly string ToString()
{
return $"R{VariableIndex.ToString().PadLeft(3,'0')}={Value}";
}
}
¶ StringVariableData
The value and index of a string(S) variable. Max length is 32 characters.
¶ Members
| Name | Description |
|---|---|
| Value | String value of the variable. |
| VariableIndex | Index of the string variable. |
public struct StringVariableData
{
public string Value { get; set; }
public UInt16 VariableIndex { get; set; }
public StringVariableData(string variableData, UInt16 variableIndex)
{
Value = variableData;
VariableIndex = variableIndex;
}
public StringVariableData()
{
Value = "";
VariableIndex = 0;
}
public override readonly string ToString()
{
return $"S{VariableIndex.ToString().PadLeft(3,'0')}={Value}";
}
}
¶ RobotPositionVariableData
The value and index of a robot position(P) variable.
¶ Members
| Name | Description |
|---|---|
| PositionData | Position data for the robot. |
| VariableIndex | Index of the robot position variable. |
public struct RobotPositionVariableData
{
public PositionData PositionData { get; set; }
public UInt16 VariableIndex { get; set; }
public RobotPositionVariableData()
{
PositionData = new PositionData();
VariableIndex = 0;
}
public RobotPositionVariableData(PositionData positionData, UInt16 variableIndex)
{
PositionData = positionData;
VariableIndex = variableIndex;
}
public override readonly string ToString()
{
return $"P{VariableIndex.ToString().PadLeft(3,'0')}:\n{PositionData}";
}
}
¶ BaseAxisPositionVariableData
The values and index of a base axis position variable. If the coordinate type is pulse, the pulse counts will be in X.
¶ Members
| Name | Description |
|---|---|
| PositionData | Position data for the base axis. |
| VariableIndex | Index of the base axis position variable. |
public struct BaseAxisPositionVariableData
{
public PositionData PositionData { get; set; }
public UInt16 VariableIndex { get; set; }
public BaseAxisPositionVariableData()
{
PositionData = new PositionData();
VariableIndex = 0;
}
public BaseAxisPositionVariableData(PositionData positionData, UInt16 variableIndex)
{
PositionData = positionData;
VariableIndex = variableIndex;
}
public override readonly string ToString()
{
return $"BP{VariableIndex.ToString().PadLeft(3,'0')}:\n{PositionData}";
}
}
¶ StationPositionVariableData
The value and index of a station position variable.
¶ Members
| Name | Description |
|---|---|
| PositionData | Position data for the station. |
| VariableIndex | Index of the station position variable. |
public struct StationPositionVariableData
{
public PositionData PositionData { get; set; }
public UInt16 VariableIndex { get; set; }
public StationPositionVariableData()
{
PositionData = new PositionData();
VariableIndex = 0;
}
public StationPositionVariableData(PositionData positionData, UInt16 variableIndex)
{
PositionData = positionData;
VariableIndex = variableIndex;
}
public override readonly string ToString()
{
return $"BP{VariableIndex.ToString().PadLeft(3,'0')}:\n{PositionData}";
}
}
¶ SystemInfoData
The software version running on the controller. Also includes the model of the system
or application name requested by ReadSystemInformation.
¶ Members
| Name | Description |
|---|---|
| SoftwareVersion | Version of the controller software. |
| ModelName | Model name of the system or application name if requested. |
public struct SystemInfoData
{
public string SoftwareVersion { get; set; }
public string ModelName { get; set; }
public override readonly string ToString()
{
return $"SoftwareVersion: {SoftwareVersion}\nModelName: {ModelName}";
}
}
¶ ElapsedTime
¶ Members
| Name | Description |
|---|---|
| Hours | Number of hours. |
| Minutes | Number of minutes. |
| Seconds | Number of seconds. |
public struct ElapsedTime(UInt32 hours, UInt32 minutes, UInt32 seconds)
{
public UInt32 Seconds => seconds;
public UInt32 Minutes => minutes;
public UInt32 Hours => hours;
public ElapsedTime() : this(0, 0, 0) { }
public override string ToString()
{
return $"Hours: {Hours}\nMinutes: {Minutes}\nSeconds: {Seconds}";
}
}
¶ TimeData
Includes the start time and elapsed. Since this structure is used in GetOperatingTime, the elapsed time cooresponds to the TimeType Selected.
¶ Members
| Name | Description |
|---|---|
| StartTime | Start time for the requested data. |
| ElapsedTime | Total elapsed time period for the requested data. |
public struct TimeData
{
public DateTime StartTime { get; set; }
public ElapsedTime ElapsedTime { get; set; }
public TimeData(DateTime startTime, ElapsedTime elapsedTime)
{
this.StartTime = startTime;
this.ElapsedTime = elapsedTime;
}
public TimeData()
{
StartTime = new DateTime();
ElapsedTime = new ElapsedTime();
}
public override readonly string ToString()
{
return $"StartTime: {StartTime}\nElapsedTime: {ElapsedTime}";
}
}
¶ JobData
The name, line, step number, and speed override of a job. Line cooresponds to the line number of the job. Step number cooresponds to the motion step in the job.
SpeedOverride is expressed as a percentage. 100% is programmed speed. Ranges from 10% to 150%.
¶ Members
| Name | Description |
|---|---|
| Name | Current active job. |
| Line | Active line in active job. |
| StepNumber | Current motion step in the active job. |
| SpeedOverride | Speed override for the active job. |
public struct JobData
{
public string Name { get; set; }
public UInt32 Line { get; set; }
public UInt32 StepNumber { get; set; }
public Double SpeedOverride { get; set; }
public JobData(string name, UInt32 line, UInt32 stepNumber, Double speedOverride)
{
this.Name = name;
this.Line = line;
this.StepNumber = stepNumber;
this.SpeedOverride = speedOverride;
}
public JobData()
{
Name = "";
Line = 0;
StepNumber = 0;
SpeedOverride = 0;
}
public override readonly string ToString()
{
return $"Name: {Name}\nLine: {Line}\nStepNumber: {StepNumber}\nSpeedOverride: {SpeedOverride}";
}
};
¶ IOData
The IOData class present in the C# version is designed to act with the same conveniences as the std::bitset used for the type of the same name in the C++ version.
¶ Members
| Name | Description |
|---|---|
| Data | BitArray representing I/O data. |
public abstract class IOData(int size)
{
protected BitArray Data = new BitArray(size);
public bool this[int index]
{
get { return Data[index]; }
set { Data[index] = value; }
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
//print the bits in reverse order
for (int i = Data.Length - 1; i >= 0; i++)
{
sb.Append(Data[i] ? "1" : "0");
}
return sb.ToString();
}
public IOData SetAll(bool value)
{
Data.SetAll(value);
return this;
}
public bool HasAllSet()
{
return Data.HasAllSet();
}
public bool HasAnySet()
{
return Data.HasAnySet();
}
public IOData And(IOData other)
{
Data = Data.And(other.Data);
return this;
}
public IOData Or(IOData other)
{
Data = Data.Or(other.Data);
return this;
}
public IOData Xor(IOData other)
{
Data = Data.Xor(other.Data);
return this;
}
public IOData Not()
{
Data = Data.Not();
return this;
}
public IOData RightShift(int count)
{
Data = Data.RightShift(count);
return this;
}
public IOData LeftShift(int count)
{
Data = Data.LeftShift(count);
return this;
}
public bool Get(int index)
{
return Data.Get(index);
}
public void Set(int index, bool value)
{
Data.Set(index, value);
}
public Byte ToByte()
{
byte[] bytes = new byte[1];
Data.CopyTo(bytes, 0);
return bytes[0];
}
public UInt16 ToWord()
{
byte[] bytes = new byte[2];
Data.CopyTo(bytes, 0);
return BitConverter.ToUInt16(bytes, 0);
}
}
¶ IOByteData Class
IOData as a byte.
¶ Members
| Name | Description |
|---|---|
| (Inherits members from IOData) | Represents I/O data as a byte. |
public class IOByteData : IOData
{
public IOByteData() : base(8)
{
}
public IOByteData(byte data) : base(8)
{
Data = new BitArray(new byte[] { data });
}
public void Set(byte data)
{
Data = new BitArray(new byte[] { data });
}
}
¶ IOWordData Class
IOData as a word.
¶ Members
| Name | Description |
|---|---|
| (Inherits members from IOData) | Represents I/O data as a word (UInt16). |
public class IOWordData : IOData
{
public IOWordData() : base(16)
{
}
public IOWordData(UInt16 data) : base(16)
{
Data = new BitArray(new byte[] { (byte)(data & 0xFF), (byte)(data >> 8) });
}
//function to set the data from a UInt16
public void Set(UInt16 data)
{
Data = new BitArray(new byte[] { (byte)(data & 0xFF), (byte)(data >> 8) });
}
}
¶ RegisterData Class
Represents register data.
¶ Members
| Name | Description |
|---|---|
| (Inherits members from IOData) | Represents register data. |
public class RegisterData : IOData
{
public RegisterData() : base(16)
{
}
public RegisterData(UInt16 data) : base(16)
{
Data = new BitArray(new byte[] { (byte)(data & 0xFF), (byte)(data >> 8) });
}
public void Set(UInt16 data)
{
Data = new BitArray(new byte[] { (byte)(data & 0xFF), (byte)(data >> 8) });
}
}
¶ MotionAccelDecel
Contains the acceleration and deceleration ratios for a motion. These ratios reduce the amount of acceleration and/or deceleration that occurs during a motion. For example, if the acceleration ratio is set to 50%, the robot will accelerate at half of the programmed acceleration rate. If the deceleration ratio is set to 50%, the robot will decelerate at half of the programmed deceleration rate.
¶ Members
| Name | Description |
|---|---|
| AccelRatio | Acceleration ratio. Valid range is 20.00%-100.00%. |
| DecelRatio | Deceleration ratio. Valid range is 20.0%-100.00% |
public struct MotionAccelDecel
{
//Will change the acceleration ratio of subsequent motions until changed again. Valid range is 20.00%-100.00%.
double AccelRatio { get; set; }
//Will change the deceleration ratio of subsequent motions until changed again. Valid range is 20.0%-100.00%
double DecelRatio { get; set; }
public MotionAccelDecel(double accelRatio, double decelRatio)
{
this.AccelRatio = accelRatio;
this.DecelRatio = decelRatio;
}
public MotionAccelDecel()
{
AccelRatio = double.MaxValue;
DecelRatio = double.MaxValue;
}
public override readonly string ToString()
{
return $"AccelRatio: {AccelRatio}, DecelRatio: {DecelRatio}";
}
};
¶ Motion
¶ Members
| Name | Description |
|---|---|
| groupId | Group to move. See ControlGroupId. |
| speed | Speed of the motion. |
| attributes | Acceleration and deceleration rate. See MotionAccelDecel |
| interpolationType | Motion interpolation. Note that changing this instead of using the proper derived class can cause undefined behavior. |
| position | Target position of the motion. Note that tool frame coordinate type is not supported at this time. See PositionData. |
Note that changing interpolationType instead of using the proper derived class can cause undefined behavior.
public class Motion
{
public ControlGroupId GroupId { get; set; } //The control group to move.
public double Speed { get; set; } //Speed of the motion. This value is a percentage (0.00 - 100.00) for JointMotion. For LinearMotion and CircularMotion, the value is in mm/sec (0.0 - 1500.0)
public MotionAccelDecel Attributes { get; set; } //The acceleration and deceleration ratios for the motion.
public MoveInterpolationType InterpolationType { get; set; } //The interpolation type of the motion.
public PositionData Position { get; set; } //The position data of the motion.
public override string ToString()
{
return $"GroupId: {GroupId}, Speed: {Speed}, Attributes: {Attributes}, InterpolationType: {InterpolationType}, Position: {Position}";
}
};
¶ LinearMotion Class
¶ Members
| Name | Description |
|---|---|
| (Inherits members from Motion) | Represents linear motion commands. |
public class LinearMotion : Motion
{
public LinearMotion()
{
InterpolationType = MoveInterpolationType.MoveLinear;
Attributes = new MotionAccelDecel();
Position = new PositionData();
}
/// <summary>
/// Constructor for a linear motion target.
/// </summary>
/// <param name="groupId">ControlGroupId for the motion.</param>
/// <param name="destinationCoords">Data for the target position.</param>
/// <param name="speed">Speed for this motion target.</param>
/// <param name="attributes">Optional Motion attributes.</param>
public LinearMotion(ControlGroupId groupId, PositionData destinationCoords, double speed, MotionAccelDecel attributes)
{
GroupId = groupId;
Speed = speed;
Attributes = attributes;
InterpolationType = MoveInterpolationType.MoveLinear;
Position = destinationCoords;
}
public LinearMotion(ControlGroupId groupId, PositionData destinationCoords, double speed)
{
GroupId = groupId;
Speed = speed;
Attributes = new MotionAccelDecel();
InterpolationType = MoveInterpolationType.MoveLinear;
Position = destinationCoords;
}
};
¶ JointMotion Class
Use this struct to create a joint motion target. See Motion.
¶ Members
| Name | Description |
|---|---|
| (Inherits members from Motion) | Represents joint motion commands. |
public class JointMotion : Motion
{
public JointMotion()
{
InterpolationType = MoveInterpolationType.MoveJoint;
Attributes = new MotionAccelDecel();
Position = new PositionData();
}
/// <summary>
/// Constructor for a joint motion target.
/// </summary>
/// <param name="groupId">ControlGroupId for the motion.</param>
/// <param name="destinationCoords">Data for the target position</param>
/// <param name="speed">Speed for this motion target.</param>
/// <param name="attributes">Optional Motion attributes.</param>
public JointMotion(ControlGroupId groupId, PositionData destinationCoords, double speed, MotionAccelDecel attributes)
{
GroupId = groupId;
Speed = speed;
Attributes = attributes;
InterpolationType = MoveInterpolationType.MoveJoint;
Position = destinationCoords;
}
public JointMotion(ControlGroupId groupId, PositionData destinationCoords, double speed)
{
GroupId = groupId;
Speed = speed;
Attributes = new MotionAccelDecel();
InterpolationType = MoveInterpolationType.MoveJoint;
Position = destinationCoords;
}
};
¶ CircularMotion Class
Use this struct to create a Circular motion target. This motion target requires an auxillary set of coordinates. This is the passing point used to calculate the arc. See Motion.
¶ Members
| Name | Description |
|---|---|
| AuxCoords | Auxiliary coordinates (passing point) for circular motion. |
public class CircularMotion : Motion
{
public CoordinateArray AuxCoords { get; set; } //The passing point for the motion.
public CircularMotion()
{
InterpolationType = MoveInterpolationType.MoveCircular;
Attributes = new MotionAccelDecel();
AuxCoords = new double[8];
Position = new PositionData();
}
/// <summary>
/// Constructor for a circular motion target.
/// </summary>
/// <param name="groupId">ControlGroupId for the motion.</param>
/// <param name="destinationCoords">Data for the target position.</param>
/// <param name="auxCoords">Pass in pulse counts for coordinate type pulse, millimeters and joint angles otherwise. Used as a passing point.
/// e.g if you want to move from point A to point C, but you want to pass through point B, then point B would be the auxCoords.
/// </param>
public CircularMotion(ControlGroupId groupId, PositionData destinationCoords, CoordinateArray auxCoords, double speed, MotionAccelDecel attributes)
{
GroupId = groupId;
Speed = speed;
Attributes = attributes;
InterpolationType = MoveInterpolationType.MoveCircular;
Position = destinationCoords;
AuxCoords = auxCoords;
}
public CircularMotion(ControlGroupId groupId, PositionData destinationCoords, CoordinateArray auxCoords, double speed)
{
GroupId = groupId;
Speed = speed;
Attributes = new MotionAccelDecel();
InterpolationType = MoveInterpolationType.MoveCircular;
Position = destinationCoords;
AuxCoords = auxCoords;
}
};
¶ StatusInfo
¶ Members
| Name | Description |
|---|---|
| StatusCode | Error code returned from function calls. |
| Message | Error message associated with the status code. |
public class StatusInfo
{
public int StatusCode { get; set; }// The error code returned from the function call. 0 indicates no error.
public string? Message { get; set; }// The error message associated with the error code.
/// <summary>
/// A convenience function to return the StatusCode and Message as a string.
/// </summary>
/// <returns>StatusInfo represented as a string.</returns>
public override string ToString()
{
return $"Code ({StatusCode}): {Message}";
}
}