UnderAutomation.ABB 1.0.2.0__py3-none-any.whl

underautomation/abb/__init__.py

@@ -0,0 +1,7 @@
+import clr
+import os
+
+_dll_path = os.path.realpath(os.path.join(os.path.dirname(__file__), 'lib', 'UnderAutomation.Abb.dll'))
+clr.AddReference(_dll_path)
+
+__author__ = 'UnderAutomation'

underautomation/abb/abb_controller.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+import typing
+from underautomation.abb.connection_parameters import ConnectionParameters
+from underautomation.abb.rws.internal.rws_client_internal import RwsClientInternal
+from underautomation.abb.discovery.discovered_controller import DiscoveredController
+from underautomation.abb.license.license_info import LicenseInfo
+from UnderAutomation.ABB import AbbController as abb_controller
+
+class AbbController:
+	'''Main class of the SDK that represents a connection to an ABB robot controller'''
+	def __init__(self, _internal = 0):
+		'''Instantiate a new ABB robot controller connection'''
+		if(_internal == 0):
+			self._instance = abb_controller()
+		else:
+			self._instance = _internal
+
+	def connect(self, ip_or_parameters: str | ConnectionParameters) -> None:
+		'''Connect to robot by IP with default connection parameters
+		Initialize a connection to the robot with specified parameters
+
+		:param ip_or_parameters: IP address or hostname of the robot controller — or — Connection parameters
+		'''
+		self._instance.Connect(getattr(ip_or_parameters, '_instance', ip_or_parameters))
+
+	def disconnect(self) -> None:
+		'''Disconnect from the robot controller'''
+		self._instance.Disconnect()
+
+	@staticmethod
+	def discover(timeoutMilliseconds: int=2000) -> typing.List[DiscoveredController]:
+		'''Search the local network for ABB robot controllers, during the given time. Two ways of finding a controller run together: the announcements the controllers of the network send, and a test of the ports this machine serves, which is what finds the virtual controllers of RobotStudio whatever port they were given. No license is needed.
+
+		:param timeoutMilliseconds: How long the search lasts, in milliseconds. Below 1000 ms a slow controller may be missed. Default is 2000 ms.
+		:returns: The controllers that answered, or an empty array when none did
+		'''
+		return [DiscoveredController(x) for x in abb_controller.Discover(timeoutMilliseconds)]
+
+	@staticmethod
+	def register_license(licensee: str, key: str) -> LicenseInfo:
+		'''If you have a license and a key, please call this static method to register the product and exit the trial period. You can register a product even if the trial period has ended.
+
+		:param licensee: Your organization name
+		:param key: The associated key supplied by UnderAutomation
+		:returns: Information about the supplied license
+		'''
+		return LicenseInfo(None, None, abb_controller.RegisterLicense(licensee, key))
+
+	@property
+	def address(self) -> str:
+		'''IP or robot name'''
+		return self._instance.Address
+
+	@property
+	def enabled(self) -> bool:
+		'''Check if the robot controller is connected'''
+		return self._instance.Enabled
+
+	@property
+	def rws(self) -> RwsClientInternal:
+		'''RWS client providing access to Robot Web Services API (controller, panel, IO, RAPID, file system, subscriptions)'''
+		return RwsClientInternal(self._instance.Rws)
+
+	@property
+	def license_info(self) -> LicenseInfo:
+		'''Return information about your license'''
+		return LicenseInfo(None, None, self._instance.LicenseInfo)
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, AbbController):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/external_joints.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+import typing
+from UnderAutomation.ABB.Common import ExternalJoints as external_joints
+
+class ExternalJoints:
+	'''The six external axis values that travel with a robot position. An axis the robot system does not define comes back as 9E9, which is how the controller says "not in use" rather than an actual position.'''
+	def __init__(self, axisA: float, axisB: float, axisC: float, axisD: float, axisE: float, axisF: float, _internal = 0):
+		'''Initializes the six external axes
+
+		:param axisA: Value of external axis A
+		:param axisB: Value of external axis B
+		:param axisC: Value of external axis C
+		:param axisD: Value of external axis D
+		:param axisE: Value of external axis E
+		:param axisF: Value of external axis F
+		'''
+		if(_internal == 0):
+			self._instance = external_joints(axisA, axisB, axisC, axisD, axisE, axisF)
+		else:
+			self._instance = _internal
+
+	@property
+	def axis_a(self) -> float:
+		'''Value of external axis A'''
+		return self._instance.AxisA
+
+	@axis_a.setter
+	def axis_a(self, value: float):
+		self._instance.AxisA = value
+
+	@property
+	def axis_b(self) -> float:
+		'''Value of external axis B'''
+		return self._instance.AxisB
+
+	@axis_b.setter
+	def axis_b(self, value: float):
+		self._instance.AxisB = value
+
+	@property
+	def axis_c(self) -> float:
+		'''Value of external axis C'''
+		return self._instance.AxisC
+
+	@axis_c.setter
+	def axis_c(self, value: float):
+		self._instance.AxisC = value
+
+	@property
+	def axis_d(self) -> float:
+		'''Value of external axis D'''
+		return self._instance.AxisD
+
+	@axis_d.setter
+	def axis_d(self, value: float):
+		self._instance.AxisD = value
+
+	@property
+	def axis_e(self) -> float:
+		'''Value of external axis E'''
+		return self._instance.AxisE
+
+	@axis_e.setter
+	def axis_e(self, value: float):
+		self._instance.AxisE = value
+
+	@property
+	def axis_f(self) -> float:
+		'''Value of external axis F'''
+		return self._instance.AxisF
+
+	@axis_f.setter
+	def axis_f(self, value: float):
+		self._instance.AxisF = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, ExternalJoints):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0
+
+# Value the controller reports for an external axis that is not in use
+ExternalJoints.NotInUse = external_joints.NotInUse

underautomation/abb/common/joint_target.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+import typing
+from underautomation.abb.common.robot_joints import RobotJoints
+from underautomation.abb.common.external_joints import ExternalJoints
+from UnderAutomation.ABB.Common import JointTarget as joint_target
+
+class JointTarget:
+	'''A robot position expressed joint by joint: the six axes of the arm and the six external axes.'''
+	def __init__(self, robotAxes: RobotJoints, externalAxes: ExternalJoints, _internal = 0):
+		'''Initializes a new joint target
+
+		:param robotAxes: Values of the six axes of the robot arm, zero when null
+		:param externalAxes: Values of the six external axes, zero when null
+		'''
+		if(_internal == 0):
+			self._instance = joint_target(robotAxes._instance if robotAxes else None, externalAxes._instance if externalAxes else None)
+		else:
+			self._instance = _internal
+
+	@property
+	def robot_axes(self) -> RobotJoints:
+		'''Values of the six axes of the robot arm. Never null.'''
+		return RobotJoints(None, None, None, None, None, None, self._instance.RobotAxes)
+
+	@robot_axes.setter
+	def robot_axes(self, value: RobotJoints):
+		self._instance.RobotAxes = value._instance if value else None
+
+	@property
+	def external_axes(self) -> ExternalJoints:
+		'''Values of the six external axes. Never null.'''
+		return ExternalJoints(None, None, None, None, None, None, self._instance.ExternalAxes)
+
+	@external_axes.setter
+	def external_axes(self, value: ExternalJoints):
+		self._instance.ExternalAxes = value._instance if value else None
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, JointTarget):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/pose.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import typing
+from underautomation.abb.common.quaternion import Quaternion
+from underautomation.abb.common.position import Position
+from UnderAutomation.ABB.Common import Pose as pose
+
+class Pose(Position):
+	'''A position and the orientation the robot holds there: a Position extended with a Quaternion.'''
+	def __init__(self, x: float, y: float, z: float, q1: float, q2: float, q3: float, q4: float, _internal = 0):
+		'''Initializes a new pose
+
+		:param x: Coordinate along the X axis
+		:param y: Coordinate along the Y axis
+		:param z: Coordinate along the Z axis
+		:param q1: Real component of the orientation
+		:param q2: First imaginary component of the orientation
+		:param q3: Second imaginary component of the orientation
+		:param q4: Third imaginary component of the orientation
+		'''
+		if(_internal == 0):
+			self._instance = pose(x, y, z, q1, q2, q3, q4)
+		else:
+			self._instance = _internal
+
+	@property
+	def orientation(self) -> Quaternion:
+		'''Orientation held at this position. Never null: a pose built without one carries the identity rotation.'''
+		return Quaternion(None, None, None, None, self._instance.Orientation)
+
+	@orientation.setter
+	def orientation(self, value: Quaternion):
+		self._instance.Orientation = value._instance if value else None
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, Pose):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/position.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import typing
+from UnderAutomation.ABB.Common import Position as position
+
+class Position:
+	'''A point in space, expressed in the coordinate system of whoever produced it. Most readings of the controller express a position in millimetres, while the kinematics calculations work in metres. The method that returns or takes a position says which one it uses.'''
+	def __init__(self, x: float, y: float, z: float, _internal = 0):
+		'''Initializes a new position
+
+		:param x: Coordinate along the X axis
+		:param y: Coordinate along the Y axis
+		:param z: Coordinate along the Z axis
+		'''
+		if(_internal == 0):
+			self._instance = position(x, y, z)
+		else:
+			self._instance = _internal
+
+	@property
+	def x(self) -> float:
+		'''Coordinate along the X axis'''
+		return self._instance.X
+
+	@x.setter
+	def x(self, value: float):
+		self._instance.X = value
+
+	@property
+	def y(self) -> float:
+		'''Coordinate along the Y axis'''
+		return self._instance.Y
+
+	@y.setter
+	def y(self, value: float):
+		self._instance.Y = value
+
+	@property
+	def z(self) -> float:
+		'''Coordinate along the Z axis'''
+		return self._instance.Z
+
+	@z.setter
+	def z(self, value: float):
+		self._instance.Z = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, Position):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/quaternion.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+import typing
+from UnderAutomation.ABB.Common import Quaternion as quaternion
+
+class Quaternion:
+	'''An orientation in space, expressed as a unit quaternion. The controller rejects a quaternion that is not normalized, so keep ² + ² + ² + ² equal to 1.'''
+	def __init__(self, q1: float, q2: float, q3: float, q4: float, _internal = 0):
+		'''Initializes a new quaternion
+
+		:param q1: Real component
+		:param q2: First imaginary component
+		:param q3: Second imaginary component
+		:param q4: Third imaginary component
+		'''
+		if(_internal == 0):
+			self._instance = quaternion(q1, q2, q3, q4)
+		else:
+			self._instance = _internal
+
+	@property
+	def q1(self) -> float:
+		'''Real component of the quaternion'''
+		return self._instance.Q1
+
+	@q1.setter
+	def q1(self, value: float):
+		self._instance.Q1 = value
+
+	@property
+	def q2(self) -> float:
+		'''First imaginary component of the quaternion'''
+		return self._instance.Q2
+
+	@q2.setter
+	def q2(self, value: float):
+		self._instance.Q2 = value
+
+	@property
+	def q3(self) -> float:
+		'''Second imaginary component of the quaternion'''
+		return self._instance.Q3
+
+	@q3.setter
+	def q3(self, value: float):
+		self._instance.Q3 = value
+
+	@property
+	def q4(self) -> float:
+		'''Third imaginary component of the quaternion'''
+		return self._instance.Q4
+
+	@q4.setter
+	def q4(self, value: float):
+		self._instance.Q4 = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, Quaternion):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/rob_target.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+import typing
+from underautomation.abb.common.robot_configuration import RobotConfiguration
+from underautomation.abb.common.external_joints import ExternalJoints
+from underautomation.abb.common.quaternion import Quaternion
+from underautomation.abb.common.pose import Pose
+from UnderAutomation.ABB.Common import RobTarget as rob_target
+
+class RobTarget(Pose):
+	'''A complete robot target: a Pose extended with the axis configuration used to reach it and the external axis values that travel with it.'''
+	def __init__(self, x: float, y: float, z: float, orientation: Quaternion, configuration: RobotConfiguration, externalAxes: ExternalJoints, _internal = 0):
+		'''Initializes a new target
+
+		:param x: Coordinate along the X axis
+		:param y: Coordinate along the Y axis
+		:param z: Coordinate along the Z axis
+		:param orientation: Orientation held at that position, the identity rotation when null
+		:param configuration: Axis configuration used to reach the pose, all zero when null
+		:param externalAxes: Values of the six external axes
+		'''
+		if(_internal == 0):
+			self._instance = rob_target(x, y, z, orientation._instance if orientation else None, configuration._instance if configuration else None, externalAxes._instance if externalAxes else None)
+		else:
+			self._instance = _internal
+
+	@property
+	def configuration(self) -> RobotConfiguration:
+		'''Axis configuration used to reach the pose. Never null.'''
+		return RobotConfiguration(None, None, None, None, self._instance.Configuration)
+
+	@configuration.setter
+	def configuration(self, value: RobotConfiguration):
+		self._instance.Configuration = value._instance if value else None
+
+	@property
+	def external_axes(self) -> ExternalJoints:
+		'''Values of the six external axes, null when the reading does not report them'''
+		return ExternalJoints(None, None, None, None, None, None, self._instance.ExternalAxes)
+
+	@external_axes.setter
+	def external_axes(self, value: ExternalJoints):
+		self._instance.ExternalAxes = value._instance if value else None
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, RobTarget):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/robot_configuration.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+import typing
+from UnderAutomation.ABB.Common import RobotConfiguration as robot_configuration
+
+class RobotConfiguration:
+	'''The axis configuration the robot uses to reach a pose. Several joint combinations reach the same tool position and orientation. The configuration names the one to use, as the quarter revolution each of the deciding axes sits in.'''
+	def __init__(self, quarter1: int, quarter4: int, quarter6: int, quarterX: int, _internal = 0):
+		'''Initializes a new configuration
+
+		:param quarter1: Quarter revolution axis 1 sits in
+		:param quarter4: Quarter revolution axis 4 sits in
+		:param quarter6: Quarter revolution axis 6 sits in
+		:param quarterX: Index of the arm configuration
+		'''
+		if(_internal == 0):
+			self._instance = robot_configuration(quarter1, quarter4, quarter6, quarterX)
+		else:
+			self._instance = _internal
+
+	@property
+	def quarter1(self) -> int:
+		'''Quarter revolution axis 1 sits in'''
+		return self._instance.Quarter1
+
+	@quarter1.setter
+	def quarter1(self, value: int):
+		self._instance.Quarter1 = value
+
+	@property
+	def quarter4(self) -> int:
+		'''Quarter revolution axis 4 sits in'''
+		return self._instance.Quarter4
+
+	@quarter4.setter
+	def quarter4(self, value: int):
+		self._instance.Quarter4 = value
+
+	@property
+	def quarter6(self) -> int:
+		'''Quarter revolution axis 6 sits in'''
+		return self._instance.Quarter6
+
+	@quarter6.setter
+	def quarter6(self, value: int):
+		self._instance.Quarter6 = value
+
+	@property
+	def quarter_x(self) -> int:
+		'''Index of the arm configuration, which tells the remaining joint combinations apart'''
+		return self._instance.QuarterX
+
+	@quarter_x.setter
+	def quarter_x(self, value: int):
+		self._instance.QuarterX = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, RobotConfiguration):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/common/robot_joints.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+import typing
+from UnderAutomation.ABB.Common import RobotJoints as robot_joints
+
+class RobotJoints:
+	'''The six joint values of a robot arm. Readings of the controller express them in degrees, while the kinematics calculations work in radians. The method that returns or takes them says which one it uses.'''
+	def __init__(self, axis1: float, axis2: float, axis3: float, axis4: float, axis5: float, axis6: float, _internal = 0):
+		'''Initializes the six axes
+
+		:param axis1: Value of axis 1
+		:param axis2: Value of axis 2
+		:param axis3: Value of axis 3
+		:param axis4: Value of axis 4
+		:param axis5: Value of axis 5
+		:param axis6: Value of axis 6
+		'''
+		if(_internal == 0):
+			self._instance = robot_joints(axis1, axis2, axis3, axis4, axis5, axis6)
+		else:
+			self._instance = _internal
+
+	@property
+	def axis1(self) -> float:
+		'''Value of axis 1'''
+		return self._instance.Axis1
+
+	@axis1.setter
+	def axis1(self, value: float):
+		self._instance.Axis1 = value
+
+	@property
+	def axis2(self) -> float:
+		'''Value of axis 2'''
+		return self._instance.Axis2
+
+	@axis2.setter
+	def axis2(self, value: float):
+		self._instance.Axis2 = value
+
+	@property
+	def axis3(self) -> float:
+		'''Value of axis 3'''
+		return self._instance.Axis3
+
+	@axis3.setter
+	def axis3(self, value: float):
+		self._instance.Axis3 = value
+
+	@property
+	def axis4(self) -> float:
+		'''Value of axis 4'''
+		return self._instance.Axis4
+
+	@axis4.setter
+	def axis4(self, value: float):
+		self._instance.Axis4 = value
+
+	@property
+	def axis5(self) -> float:
+		'''Value of axis 5'''
+		return self._instance.Axis5
+
+	@axis5.setter
+	def axis5(self, value: float):
+		self._instance.Axis5 = value
+
+	@property
+	def axis6(self) -> float:
+		'''Value of axis 6'''
+		return self._instance.Axis6
+
+	@axis6.setter
+	def axis6(self, value: float):
+		self._instance.Axis6 = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, RobotJoints):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/abb/connection_parameters.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+import typing
+from underautomation.abb.rws.rws_connect_parameters import RwsConnectParameters
+from UnderAutomation.ABB import ConnectionParameters as connection_parameters
+
+class ConnectionParameters:
+	'''Connection parameters for an ABB robot controller'''
+	def __init__(self, address: str, _internal = 0):
+		'''Instantiate new connection parameters with a specified address
+
+		:param address: IP address or hostname of the robot controller
+		'''
+		if(_internal == 0):
+			self._instance = connection_parameters(address)
+		else:
+			self._instance = _internal
+
+	@property
+	def address(self) -> str:
+		'''Address of the robot controller (IP or host name), default value is 127.0.0.1'''
+		return self._instance.Address
+
+	@address.setter
+	def address(self, value: str):
+		self._instance.Address = value
+
+	@property
+	def ping_before_connect(self) -> bool:
+		'''Send a ping command before initializing any connections'''
+		return self._instance.PingBeforeConnect
+
+	@ping_before_connect.setter
+	def ping_before_connect(self, value: bool):
+		self._instance.PingBeforeConnect = value
+
+	@property
+	def rws(self) -> RwsConnectParameters:
+		'''RWS2 (Robot Web Services 2) connection parameters'''
+		return RwsConnectParameters(self._instance.Rws)
+
+	@rws.setter
+	def rws(self, value: RwsConnectParameters):
+		self._instance.Rws = value._instance if value else None
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, ConnectionParameters):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0