UnderAutomation.Fanuc 2.3.0.0__py3-none-any.whl → 3.1.1.0__py3-none-any.whl

underautomation/fanuc/kinematics/arm_kinematic_models.py

@@ -0,0 +1,88 @@
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import ArmKinematicModels as arm_kinematic_models
+
+class ArmKinematicModels(int):
+	ARCMate0iA = arm_kinematic_models.ARCMate0iA
+	ARCMate0iB = arm_kinematic_models.ARCMate0iB
+	ARCMate0iB_2 = arm_kinematic_models.ARCMate0iB_2
+	ARCMate100iD = arm_kinematic_models.ARCMate100iD
+	ARCMate100iD10L = arm_kinematic_models.ARCMate100iD10L
+	ARCMate100iD16S = arm_kinematic_models.ARCMate100iD16S
+	ARCMate100iD8L = arm_kinematic_models.ARCMate100iD8L
+	ARCMate120iD = arm_kinematic_models.ARCMate120iD
+	ARCMate120iD12L = arm_kinematic_models.ARCMate120iD12L
+	ARCMate120iD35 = arm_kinematic_models.ARCMate120iD35
+	CR14iAL = arm_kinematic_models.CR14iAL
+	CR15iA = arm_kinematic_models.CR15iA
+	CR35iA = arm_kinematic_models.CR35iA
+	CR7iA = arm_kinematic_models.CR7iA
+	CR7iAL = arm_kinematic_models.CR7iAL
+	CRX10iA = arm_kinematic_models.CRX10iA
+	CRX10iAL = arm_kinematic_models.CRX10iAL
+	LRMate200iD = arm_kinematic_models.LRMate200iD
+	LRMate200iD7C = arm_kinematic_models.LRMate200iD7C
+	LRMate200iD7L = arm_kinematic_models.LRMate200iD7L
+	LRMate200iD7LC = arm_kinematic_models.LRMate200iD7LC
+	LaserRobotHA = arm_kinematic_models.LaserRobotHA
+	M10iA10M = arm_kinematic_models.M10iA10M
+	M10iA10MS = arm_kinematic_models.M10iA10MS
+	M10iA12 = arm_kinematic_models.M10iA12
+	M10iA12S = arm_kinematic_models.M10iA12S
+	M10iA7L = arm_kinematic_models.M10iA7L
+	M10iA8L = arm_kinematic_models.M10iA8L
+	M2000iA1700L = arm_kinematic_models.M2000iA1700L
+	M2000iA2300 = arm_kinematic_models.M2000iA2300
+	M2000iA1200 = arm_kinematic_models.M2000iA1200
+	M2000iA900L = arm_kinematic_models.M2000iA900L
+	M20iA = arm_kinematic_models.M20iA
+	M20iA12L = arm_kinematic_models.M20iA12L
+	M20iA20M = arm_kinematic_models.M20iA20M
+	M20iA35M = arm_kinematic_models.M20iA35M
+	M20iB25C = arm_kinematic_models.M20iB25C
+	M410iC110 = arm_kinematic_models.M410iC110
+	M410iC185_2 = arm_kinematic_models.M410iC185_2
+	M410iC185 = arm_kinematic_models.M410iC185
+	M410iC500 = arm_kinematic_models.M410iC500
+	M410iC500_2 = arm_kinematic_models.M410iC500_2
+	M800iA60 = arm_kinematic_models.M800iA60
+	M900iB280L = arm_kinematic_models.M900iB280L
+	M900iB330L = arm_kinematic_models.M900iB330L
+	M900iB360 = arm_kinematic_models.M900iB360
+	M900iB400L = arm_kinematic_models.M900iB400L
+	M900iB700 = arm_kinematic_models.M900iB700
+	M900iBKAI = arm_kinematic_models.M900iBKAI
+	M20iB25 = arm_kinematic_models.M20iB25
+	M20iB35S = arm_kinematic_models.M20iB35S
+	M710iC12L = arm_kinematic_models.M710iC12L
+	M710iC20M = arm_kinematic_models.M710iC20M
+	M710iC45M = arm_kinematic_models.M710iC45M
+	M710iC50 = arm_kinematic_models.M710iC50
+	P700iANewRightyArmRightOffset = arm_kinematic_models.P700iANewRightyArmRightOffset
+	P350iA45LeftHand = arm_kinematic_models.P350iA45LeftHand
+	P350iA45RightHand = arm_kinematic_models.P350iA45RightHand
+	R1000iA100F = arm_kinematic_models.R1000iA100F
+	R1000iA130F = arm_kinematic_models.R1000iA130F
+	R1000iA80F = arm_kinematic_models.R1000iA80F
+	R2000iB125L = arm_kinematic_models.R2000iB125L
+	R2000iB175L = arm_kinematic_models.R2000iB175L
+	R2000iC100S = arm_kinematic_models.R2000iC100S
+	R2000iC270F = arm_kinematic_models.R2000iC270F
+	R2000iD100FH = arm_kinematic_models.R2000iD100FH
+	R1000iA100F7 = arm_kinematic_models.R1000iA100F7
+	R1000iA120F7B_3 = arm_kinematic_models.R1000iA120F7B_3
+	R1000iA120F7B_2 = arm_kinematic_models.R1000iA120F7B_2
+	R1000iA120F7B = arm_kinematic_models.R1000iA120F7B
+	R1000iA120F7BS = arm_kinematic_models.R1000iA120F7BS
+	R1000iA120F7BS_3 = arm_kinematic_models.R1000iA120F7BS_3
+	R1000iA120F7BS_2 = arm_kinematic_models.R1000iA120F7BS_2
+	R2000iB210FS = arm_kinematic_models.R2000iB210FS
+	R2000iB220US = arm_kinematic_models.R2000iB220US
+	R2000iC125L = arm_kinematic_models.R2000iC125L
+	R2000iC190U = arm_kinematic_models.R2000iC190U
+	R2000iC210F = arm_kinematic_models.R2000iC210F
+	R2000iC210L = arm_kinematic_models.R2000iC210L
+	R2000iC210WE = arm_kinematic_models.R2000iC210WE
+	R2000iC210WEProto = arm_kinematic_models.R2000iC210WEProto
+	R2000iC220U = arm_kinematic_models.R2000iC220U

underautomation/fanuc/kinematics/crx/crx_kinematics_utils.py

@@ -0,0 +1,18 @@
+import typing
+from underautomation.fanuc.common.joints_position import JointsPosition
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.kinematics.dh_parameters import DhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics.Crx import CrxKinematicsUtils as crx_kinematics_utils
+
+class CrxKinematicsUtils:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = crx_kinematics_utils()
+		else:
+			self._instance = _internal
+	@staticmethod
+	def inverse_kinematics(pose: CartesianPosition, parameters: DhParameters, includeDuals: bool=True, seedJoints: typing.List[float]=None) -> typing.List[JointsPosition]:
+		return [JointsPosition(x) for x in crx_kinematics_utils.InverseKinematics(pose._instance if pose else None, parameters._instance if parameters else None, includeDuals, seedJoints)]

underautomation/fanuc/kinematics/crx10ia_l_dhm_parameters.py

@@ -0,0 +1,31 @@
+import typing
+from underautomation.fanuc.kinematics.i_dh_parameters import IDhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import Crx10iaLDhmParameters as crx10ia_l_dhm_parameters
+
+class Crx10iaLDhmParameters(IDhParameters):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = crx10ia_l_dhm_parameters()
+		else:
+			self._instance = _internal
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def a3(self) -> float:
+		return self._instance.A3
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6

underautomation/fanuc/kinematics/dh_parameters.py

@@ -0,0 +1,77 @@
+import typing
+from underautomation.fanuc.kinematics.i_dh_parameters import IDhParameters
+from underautomation.fanuc.kinematics.kinematics_category import KinematicsCategory
+from underautomation.fanuc.kinematics.arm_kinematic_models import ArmKinematicModels
+from underautomation.fanuc.ftp.variables.symotn_file import SymotnFile
+from underautomation.fanuc.ftp.variables.mrr_grp_variable_type import MrrGrpVariableType
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import DhParameters as dh_parameters
+
+class DhParameters(IDhParameters):
+	def __init__(self, d4: float, d5: float, d6: float, a1: float, a2: float, a3: float, _internal = 0):
+		if(_internal == 0):
+			self._instance = dh_parameters(d4, d5, d6, a1, a2, a3)
+		else:
+			self._instance = _internal
+	@staticmethod
+	def from_arm_kinematic_model(model: ArmKinematicModels) -> 'DhParameters':
+		return DhParameters(None, None, None, None, None, None, dh_parameters.FromArmKinematicModel(model))
+	@staticmethod
+	def from_opw_parameters(a1: float, a2: float, c2: float, c3: float, c4: float) -> 'DhParameters':
+		return DhParameters(None, None, None, None, None, None, dh_parameters.FromOpwParameters(a1, a2, c2, c3, c4))
+	@staticmethod
+	def from_def_file(doc: typing.Any) -> typing.List['DhParameters']:
+		return [DhParameters(x) for x in dh_parameters.FromDefFile(doc)]
+	@staticmethod
+	def from_symotn_file(file: SymotnFile) -> typing.List['DhParameters']:
+		return [DhParameters(x) for x in dh_parameters.FromSymotnFile(file._instance if file else None)]
+	@staticmethod
+	def from_mrr_grp(mrrGrp: MrrGrpVariableType) -> 'DhParameters':
+		return DhParameters(None, None, None, None, None, None, dh_parameters.FromMrrGrp(mrrGrp._instance if mrrGrp else None))
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@d4.setter
+	def d4(self, value: float):
+		self._instance.D4 = value
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@d5.setter
+	def d5(self, value: float):
+		self._instance.D5 = value
+	@property
+	def d6(self) -> float:
+		return self._instance.D6
+	@d6.setter
+	def d6(self, value: float):
+		self._instance.D6 = value
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@a1.setter
+	def a1(self, value: float):
+		self._instance.A1 = value
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@a2.setter
+	def a2(self, value: float):
+		self._instance.A2 = value
+	@property
+	def a3(self) -> float:
+		return self._instance.A3
+	@a3.setter
+	def a3(self, value: float):
+		self._instance.A3 = value
+	@property
+	def kinematics_category(self) -> KinematicsCategory:
+		return KinematicsCategory(self._instance.KinematicsCategory)
+	@property
+	def tag(self) -> typing.Any:
+		return self._instance.Tag
+	@tag.setter
+	def tag(self, value: typing.Any):
+		self._instance.Tag = value

underautomation/fanuc/kinematics/i_dh_parameters.py

@@ -0,0 +1,30 @@
+import typing
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import IDhParameters as i_dh_parameters
+
+class IDhParameters:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = i_dh_parameters()
+		else:
+			self._instance = _internal
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def a3(self) -> float:
+		return self._instance.A3

underautomation/fanuc/kinematics/internal/arm_model_attribute.py

@@ -0,0 +1,31 @@
+import typing
+from underautomation.fanuc.kinematics.i_dh_parameters import IDhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics.Internal import ArmModelAttribute as arm_model_attribute
+
+class ArmModelAttribute(IDhParameters):
+	def __init__(self, description: str, d4: float, d5: float, d6: float, a1: float, a2: float, a3: float, _internal = 0):
+		if(_internal == 0):
+			self._instance = arm_model_attribute(description, d4, d5, d6, a1, a2, a3)
+		else:
+			self._instance = _internal
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def a3(self) -> float:
+		return self._instance.A3

underautomation/fanuc/kinematics/kinematics_category.py

@@ -0,0 +1,9 @@
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import KinematicsCategory as kinematics_category
+
+class KinematicsCategory(int):
+	Invalid = kinematics_category.Invalid
+	Crx = kinematics_category.Crx
+	Opw = kinematics_category.Opw

underautomation/fanuc/kinematics/kinematics_utils.py

@@ -0,0 +1,24 @@
+import typing
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.common.joints_position import JointsPosition
+from underautomation.fanuc.kinematics.dh_parameters import DhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import KinematicsUtils as kinematics_utils
+
+class KinematicsUtils:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = kinematics_utils()
+		else:
+			self._instance = _internal
+	@staticmethod
+	def forward_kinematics(jointAnglesRad: typing.List[float], dhParameters: DhParameters) -> CartesianPosition:
+		return CartesianPosition(None, None, None, None, None, None, None, kinematics_utils.ForwardKinematics(jointAnglesRad, dhParameters._instance if dhParameters else None))
+	@staticmethod
+	def inverse_kinematics(position: CartesianPosition, parameters: DhParameters) -> typing.List[JointsPosition]:
+		return [JointsPosition(x) for x in kinematics_utils.InverseKinematics(position._instance if position else None, parameters._instance if parameters else None)]
+	@staticmethod
+	def mul(A: typing.List[float], B: typing.List[float]) -> typing.List[float]:
+		return kinematics_utils.Mul(A, B)

underautomation/fanuc/kinematics/opw/opw_kinematics_utils.py

@@ -0,0 +1,18 @@
+import typing
+from underautomation.fanuc.common.joints_position import JointsPosition
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.kinematics.dh_parameters import DhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics.Opw import OpwKinematicsUtils as opw_kinematics_utils
+
+class OpwKinematicsUtils:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = opw_kinematics_utils()
+		else:
+			self._instance = _internal
+	@staticmethod
+	def inverse_kinematics(pose: CartesianPosition, dhParameters: DhParameters) -> typing.List[JointsPosition]:
+		return [JointsPosition(x) for x in opw_kinematics_utils.InverseKinematics(pose._instance if pose else None, dhParameters._instance if dhParameters else None)]

underautomation/fanuc/lib/version.txt

@@ -1 +1 @@
-2.3.0.0
+3.1.1.0

underautomation/fanuc/rmi/internal/rmi_client_base.py

@@ -48,15 +48,15 @@ class RmiClientBase:
 	def read_u_frame(self, number: int) -> IndexedFrame:
 		return IndexedFrame(self._instance.ReadUFrame(number))
 	def write_u_frame(self, number: int, frame: Frame) -> None:
-		self._instance.WriteUFrame(number, frame._instance)
+		self._instance.WriteUFrame(number, frame._instance if frame else None)
 	def read_u_tool(self, number: int) -> IndexedFrame:
 		return IndexedFrame(self._instance.ReadUTool(number))
 	def write_u_tool(self, number: int, frame: Frame) -> None:
-		self._instance.WriteUTool(number, frame._instance)
+		self._instance.WriteUTool(number, frame._instance if frame else None)
 	def read_din(self, portNumber: int) -> DigitalInputValue:
 		return DigitalInputValue(self._instance.ReadDIN(portNumber))
 	def write_dout(self, portNumber: int, value: OnOff) -> None:
-		self._instance.WriteDOUT(portNumber, value._instance)
+		self._instance.WriteDOUT(portNumber, value)
 	def read_cartesian_position(self) -> CartesianPosition:
 		return CartesianPosition(self._instance.ReadCartesianPosition())
 	def read_joint_angles(self) -> JointAnglesSample:
@@ -68,11 +68,11 @@ class RmiClientBase:
 	def read_position_register(self, number: int) -> PositionRegisterData:
 		return PositionRegisterData(self._instance.ReadPositionRegister(number))
 	def write_position_register(self, number: int, cfg: MotionConfiguration, frame: Frame) -> None:
-		self._instance.WritePositionRegister(number, cfg._instance, frame._instance)
+		self._instance.WritePositionRegister(number, cfg._instance if cfg else None, frame._instance if frame else None)
 	def read_tcp_speed(self) -> TcpSpeed:
 		return TcpSpeed(self._instance.ReadTcpSpeed())
 	def wait_din(self, sequenceId: int, portNumber: int, value: OnOff) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.WaitDin(sequenceId, portNumber, value._instance))
+		return RmiSequenceResponse(self._instance.WaitDin(sequenceId, portNumber, value))
 	def set_u_frame_instruction(self, sequenceId: int, frameNumber: int) -> RmiSequenceResponse:
 		return RmiSequenceResponse(self._instance.SetUFrameInstruction(sequenceId, frameNumber))
 	def set_u_tool_instruction(self, sequenceId: int, toolNumber: int) -> RmiSequenceResponse:
@@ -82,21 +82,21 @@ class RmiClientBase:
 	def set_payload(self, sequenceId: int, scheduleNumber: int) -> RmiSequenceResponse:
 		return RmiSequenceResponse(self._instance.SetPayload(sequenceId, scheduleNumber))
 	def linear_motion(self, sequenceId: int, config: MotionConfiguration, position: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.LinearMotion(sequenceId, config._instance, position._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.LinearMotion(sequenceId, config._instance if config else None, position._instance if position else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def linear_relative(self, sequenceId: int, config: MotionConfiguration, delta: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.LinearRelative(sequenceId, config._instance, delta._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.LinearRelative(sequenceId, config._instance if config else None, delta._instance if delta else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_motion(self, sequenceId: int, config: MotionConfiguration, position: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointMotion(sequenceId, config._instance, position._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointMotion(sequenceId, config._instance if config else None, position._instance if position else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_relative(self, sequenceId: int, config: MotionConfiguration, delta: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointRelative(sequenceId, config._instance, delta._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointRelative(sequenceId, config._instance if config else None, delta._instance if delta else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def circular_motion(self, sequenceId: int, config: MotionConfiguration, position: Frame, viaConfig: MotionConfiguration, viaPosition: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.CircularMotion(sequenceId, config._instance, position._instance, viaConfig._instance, viaPosition._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.CircularMotion(sequenceId, config._instance if config else None, position._instance if position else None, viaConfig._instance if viaConfig else None, viaPosition._instance if viaPosition else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def circular_relative(self, sequenceId: int, config: MotionConfiguration, delta: Frame, viaConfig: MotionConfiguration, viaDelta: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.CircularRelative(sequenceId, config._instance, delta._instance, viaConfig._instance, viaDelta._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.CircularRelative(sequenceId, config._instance if config else None, delta._instance if delta else None, viaConfig._instance if viaConfig else None, viaDelta._instance if viaDelta else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_motion_j_rep(self, sequenceId: int, joints: JointAngles, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointMotionJRep(sequenceId, joints._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointMotionJRep(sequenceId, joints._instance if joints else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_relative_j_rep(self, sequenceId: int, deltaJoints: JointAngles, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointRelativeJRep(sequenceId, deltaJoints._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointRelativeJRep(sequenceId, deltaJoints._instance if deltaJoints else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def dispose(self) -> None:
 		self._instance.Dispose()
 	@property

underautomation/fanuc/rmi/internal/rmi_connect_parameters_base.py

@@ -28,21 +28,9 @@ class RmiConnectParametersBase:
 	@write_timeout_ms.setter
 	def write_timeout_ms(self, value: int):
 		self._instance.WriteTimeoutMs = value
-	@property
-	def defaul_t__port(self) -> int:
-		return self._instance.DEFAULT_PORT
-	@defaul_t__port.setter
-	def defaul_t__port(self, value: int):
-		self._instance.DEFAULT_PORT = value
-	@property
-	def defaul_t__rea_d__timeou_t__ms(self) -> int:
-		return self._instance.DEFAULT_READ_TIMEOUT_MS
-	@defaul_t__rea_d__timeou_t__ms.setter
-	def defaul_t__rea_d__timeou_t__ms(self, value: int):
-		self._instance.DEFAULT_READ_TIMEOUT_MS = value
-	@property
-	def defaul_t__writ_e__timeou_t__ms(self) -> int:
-		return self._instance.DEFAULT_WRITE_TIMEOUT_MS
-	@defaul_t__writ_e__timeou_t__ms.setter
-	def defaul_t__writ_e__timeou_t__ms(self, value: int):
-		self._instance.DEFAULT_WRITE_TIMEOUT_MS = value
+
+RmiConnectParametersBase.defaul_t__port = RmiConnectParametersBase(rmi_connect_parameters_base.DEFAULT_PORT)
+
+RmiConnectParametersBase.defaul_t__rea_d__timeou_t__ms = RmiConnectParametersBase(rmi_connect_parameters_base.DEFAULT_READ_TIMEOUT_MS)
+
+RmiConnectParametersBase.defaul_t__writ_e__timeou_t__ms = RmiConnectParametersBase(rmi_connect_parameters_base.DEFAULT_WRITE_TIMEOUT_MS)

underautomation/fanuc/snpx/internal/batch_assignment_2.py

@@ -13,8 +13,8 @@ class BatchAssignment2(typing.Generic[TValue, TIndex]):
 			self._instance = batch_assignment_2()
 		else:
 			self._instance = _internal
-	def read(self) -> typing.Any:
-		return self._instance.Read()
+	def read(self) -> typing.List[TValue]:
+		return list(self._instance.Read())
 	@property
 	def assignments(self) -> typing.List[Assignment1]:
 		return [Assignment1(x) for x in self._instance.Assignments]

underautomation/fanuc/snpx/internal/position_registers.py

@@ -17,6 +17,6 @@ class PositionRegisters(SnpxWritableAssignableElements3[Position, int, PositionR
 		else:
 			self._instance = _internal
 	def write(self, index: int, cartesianPosition: CartesianPosition) -> None:
-		self._instance.Write(index, cartesianPosition._instance)
+		self._instance.Write(index, cartesianPosition._instance if cartesianPosition else None)
 	def create_batch_assignment(self, startIndex: int, count: int) -> PositionRegistersBatchAssignment:
 		return PositionRegistersBatchAssignment(self._instance.CreateBatchAssignment(startIndex, count))

underautomation/fanuc/snpx/internal/position_system_variables.py

@@ -17,4 +17,4 @@ class PositionSystemVariables(SnpxWritableAssignableElements3[Position, str, Pos
 		else:
 			self._instance = _internal
 	def write(self, variable: str, cartesianPosition: CartesianPosition) -> None:
-		self._instance.Write(variable, cartesianPosition._instance)
+		self._instance.Write(variable, cartesianPosition._instance if cartesianPosition else None)

underautomation/fanuc/snpx/internal/robot_alarm.py

@@ -1,6 +1,7 @@
 import typing
 from underautomation.fanuc.snpx.internal.alarm_id import AlarmId
 from underautomation.fanuc.snpx.internal.alarm_severity import AlarmSeverity
+from underautomation.fanuc.common.languages import Languages
 import clr
 import os
 clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
@@ -13,10 +14,10 @@ class RobotAlarm:
 		else:
 			self._instance = _internal
 	@staticmethod
-	def from_bytes(bytes: typing.List[int], start: int=0) -> 'RobotAlarm':
-		return RobotAlarm(robot_alarm.FromBytes(bytes, start))
+	def from_bytes(bytes: typing.List[int], language: Languages, start: int=0) -> 'RobotAlarm':
+		return RobotAlarm(robot_alarm.FromBytes(bytes, language, start))
 	def equals(self, other: 'RobotAlarm') -> bool:
-		return self._instance.Equals(other._instance)
+		return self._instance.Equals(other._instance if other else None)
 	def __repr__(self):
 		return self._instance.ToString()
 	@property

underautomation/fanuc/snpx/internal/robot_task_status.py

@@ -1,5 +1,6 @@
 import typing
 from underautomation.fanuc.snpx.internal.robot_task_state import RobotTaskState
+from underautomation.fanuc.common.languages import Languages
 import clr
 import os
 clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
@@ -12,10 +13,10 @@ class RobotTaskStatus:
 		else:
 			self._instance = _internal
 	def equals(self, other: 'RobotTaskStatus') -> bool:
-		return self._instance.Equals(other._instance)
+		return self._instance.Equals(other._instance if other else None)
 	@staticmethod
-	def from_bytes(bytes: typing.List[int], start: int=0) -> 'RobotTaskStatus':
-		return RobotTaskStatus(robot_task_status.FromBytes(bytes, start))
+	def from_bytes(bytes: typing.List[int], language: Languages, start: int=0) -> 'RobotTaskStatus':
+		return RobotTaskStatus(robot_task_status.FromBytes(bytes, language, start))
 	@property
 	def program_name(self) -> str:
 		return self._instance.ProgramName

underautomation/fanuc/snpx/internal/snpx_client_base.py

@@ -10,6 +10,7 @@ from underautomation.fanuc.snpx.internal.digital_signals import DigitalSignals
 from underautomation.fanuc.snpx.internal.numeric_io import NumericIO
 from underautomation.fanuc.snpx.internal.current_position import CurrentPosition
 from underautomation.fanuc.snpx.internal.alarm_access import AlarmAccess
+from underautomation.fanuc.common.languages import Languages
 from underautomation.fanuc.snpx.internal.assignment import Assignment
 import clr
 import os
@@ -126,5 +127,11 @@ class SnpxClientBase:
 	def alarm_history(self) -> AlarmAccess:
 		return AlarmAccess(self._instance.AlarmHistory)
 	@property
+	def language(self) -> Languages:
+		return Languages(self._instance.Language)
+	@language.setter
+	def language(self, value: Languages):
+		self._instance.Language = value
+	@property
 	def connected(self) -> bool:
 		return self._instance.Connected

underautomation/fanuc/snpx/internal/snpx_connect_parameters_base.py

@@ -16,9 +16,5 @@ class SnpxConnectParametersBase:
 	@port.setter
 	def port(self, value: int):
 		self._instance.Port = value
-	@property
-	def defaul_t__port(self) -> int:
-		return self._instance.DEFAULT_PORT
-	@defaul_t__port.setter
-	def defaul_t__port(self, value: int):
-		self._instance.DEFAULT_PORT = value
+
+SnpxConnectParametersBase.defaul_t__port = SnpxConnectParametersBase(snpx_connect_parameters_base.DEFAULT_PORT)

underautomation/fanuc/snpx/internal/snpx_writable_assignable_elements_3.py

@@ -16,5 +16,5 @@ class SnpxWritableAssignableElements3(SnpxAssignableElements2[TValue, TIndex], t
 			self._instance = _internal
 	def write(self, index: TIndex, value: TValue) -> None:
 		self._instance.Write(index, value)
-	def create_batch_assignment(self, indexes: typing.Any) -> TAssignment:
+	def create_batch_assignment(self, indexes: typing.List[TIndex]) -> TAssignment:
 		return self._instance.CreateBatchAssignment(indexes)

underautomation/fanuc/telnet/internal/telnet_client_base.py

@@ -1,4 +1,5 @@
 import typing
+from underautomation.fanuc.common.languages import Languages
 from underautomation.fanuc.telnet.tp_coordinates import TpCoordinates
 from underautomation.fanuc.telnet.program_command_result import ProgramCommandResult
 from underautomation.fanuc.telnet.run_result import RunResult
@@ -28,7 +29,6 @@ import os
 clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
 from UnderAutomation.Fanuc.Telnet.Internal import TelnetClientBase as telnet_client_base
 
-렫 = typing.TypeVar('렫')
 T = typing.TypeVar('T')
 class TelnetClientBase:
 	def __init__(self, _internal = 0):
@@ -89,7 +89,7 @@ class TelnetClientBase:
 	def run(self, program: str="None") -> RunResult:
 		return RunResult(self._instance.Run(program))
 	def set_port(self, port: KCLPorts, index: int, value: int) -> SetPortResult:
-		return SetPortResult(self._instance.SetPort(port._instance, index, value))
+		return SetPortResult(self._instance.SetPort(port, index, value))
 	def set_variable(self, name: str, value: float, program: str="None") -> SetVariableResult:
 		return SetVariableResult(self._instance.SetVariable(name, value, program))
 	def get_current_pose(self) -> GetCurrentPoseResult:
@@ -97,11 +97,11 @@ class TelnetClientBase:
 	def get_variable(self, name: str, program: str="None") -> GetVariableResult:
 		return GetVariableResult(self._instance.GetVariable(name, program))
 	def simulate(self, port: KCLPorts, index: int, value: int) -> SimulateResult:
-		return SimulateResult(self._instance.Simulate(port._instance, index, value))
+		return SimulateResult(self._instance.Simulate(port, index, value))
 	def unsimulate_all(self) -> UnsimulateAllResult:
 		return UnsimulateAllResult(self._instance.UnsimulateAll())
 	def unsimulate(self, port: KCLPorts, index: int) -> UnsimulateResult:
-		return UnsimulateResult(self._instance.Unsimulate(port._instance, index))
+		return UnsimulateResult(self._instance.Unsimulate(port, index))
 	def send_custom_command(self, command: str) -> T:
 		return self._instance.SendCustomCommand(command)
 	def get_task_information(self, prog_name: str) -> TaskInformationResult:
@@ -122,6 +122,12 @@ class TelnetClientBase:
 	def ip(self) -> str:
 		return self._instance.IP
 	@property
+	def language(self) -> Languages:
+		return Languages(self._instance.Language)
+	@language.setter
+	def language(self, value: Languages):
+		self._instance.Language = value
+	@property
 	def tp_coordinates(self) -> TpCoordinates:
 		return TpCoordinates(self._instance.TpCoordinates)
 	@property

{underautomation_fanuc-2.3.0.0.dist-info → underautomation_fanuc-3.1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UnderAutomation.Fanuc
-Version: 2.3.0.0
+Version: 3.1.1.0
 Summary: Quickly create applications that communicate with your Fanuc robots
 Home-page: https://underautomation.com/fanuc
 Author: UnderAutomation