roboticstoolbox-python 1.3.0__cp313-cp313-win_amd64.whl

roboticstoolbox/models/DH/IRB140.py

@@ -0,0 +1,159 @@
+"""
+@author: Peter Corke
+@author: Samuel Drew
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH
+from math import pi
+import numpy as np
+
+
+class IRB140(DHRobot):
+    """
+    Class that models an ABB  IRB140 manipulator
+
+    ``IRB140()`` is a class which models a Unimation Puma560 robot and
+    describes its kinematic and dynamic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.IRB140()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+        - qz, zero joint angle configuration
+        - qr, vertical 'READY' configuration
+        - qd, lower arm horizontal as per data sheet
+
+    .. note:: SI units of metres are used.
+
+    :references:
+        - "IRB 140 data sheet", ABB Robotics.
+        - "Utilizing the Functional Work Space Evaluation Tool for Assessing a
+          System Design and Reconfiguration Alternatives"
+          A. Djuric and R. J. Urbanic
+        - https://github.com/4rtur1t0/ARTE/blob/master/robots/ABB/IRB140/parameters.m
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self):
+        deg = pi / 180
+
+        # robot length values (metres)
+        d1 = 0.352
+        a1 = 0.070
+        a2 = 0.360
+        d4 = 0.380
+        d6 = 0.065
+
+        # Create Links
+        # Updated values form ARTE git. Old values left as comments
+
+        L = [
+            RevoluteDH(
+                d=d1,
+                a=a1,
+                alpha=-pi / 2,
+                m=34655.36e-3,
+                r=np.array([27.87, 43.12, -89.03]) * 1e-3,
+                I=np.array(
+                    [
+                        512052539.74,
+                        1361335.88,
+                        51305020.72,
+                        1361335.88,
+                        464074688.59,
+                        70335556.04,
+                        51305020.72,
+                        70335556.04,
+                        462745526.12,
+                    ]
+                )
+                * 1e-9,
+                qlim=[-180 * deg, 180 * deg],
+            ),
+            RevoluteDH(
+                d=0,
+                a=a2,
+                alpha=0,
+                m=15994.59e-3,
+                r=np.array([198.29, 9.73, 92.43]) * 1e03,
+                I=np.array(
+                    [
+                        94817914.40,
+                        -3859712.77,
+                        37932017.01,
+                        -3859712.77,
+                        328604163.24,
+                        -1088970.86,
+                        37932017.01,
+                        -1088970.86,
+                        277463004.88,
+                    ]
+                )
+                * 1e-9,
+                qlim=[-100 * deg, 100 * deg],
+            ),
+            RevoluteDH(
+                d=0,
+                a=0,
+                alpha=-pi / 2,  # alpha=pi/2,
+                m=20862.05e-3,
+                r=np.array([-4.56, -79.96, -5.86]),
+                I=np.array(
+                    [
+                        500060915.95,
+                        -1863252.17,
+                        934875.78,
+                        -1863252.17,
+                        75152670.69,
+                        -15204130.09,
+                        934875.78,
+                        -15204130.09,
+                        515424754.34,
+                    ]
+                )
+                * 1e-9,
+                qlim=[-220 * deg, 60 * deg],
+            ),
+            RevoluteDH(
+                d=d4,
+                a=0,
+                alpha=pi / 2,
+                qlim=[-200 * deg, 200 * deg],  # alpha=-pi/2,
+            ),
+            RevoluteDH(
+                d=0,
+                a=0,
+                alpha=-pi / 2,
+                qlim=[-120 * deg, 120 * deg],  # alpha=pi/2,
+            ),
+            RevoluteDH(d=d6, a=0, alpha=0, qlim=[-400 * deg, 400 * deg]),  # alpha=pi/2,
+        ]
+
+        super().__init__(
+            L,
+            # basemesh="ABB/IRB140/link0.stl",
+            name="IRB 140",
+            manufacturer="ABB",
+            meshdir="meshes/ABB/IRB140",
+        )
+
+        self.qr = np.array([0, -90 * deg, 90 * deg, 0, 90 * deg, -90 * deg])
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+        self.addconfiguration_attr(
+            "qd", np.array([0, -90 * deg, 180 * deg, 0, 0, -90 * deg])
+        )
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = IRB140()
+    print(robot)

roboticstoolbox/models/DH/Jaco.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+
+from math import sin, cos
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+# from spatialmath import SE3
+
+
+class Jaco(DHRobot):
+    """
+    Class that models a  Kinova Jaco manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``Jaco()`` is an object which models a Kinova Jaco robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Puma560()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+    - qs, arm is stretched out in the x-direction
+    - qn, arm is at a nominal non-singular configuration
+
+    .. note::
+        - SI units are used.
+
+    :references:
+        - "DH Parameters of Jaco" Version 1.0.8, July 25, 2013.
+
+    :seealso: :func:`Mico`
+    """
+
+    def __init__(self, symbolic=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            # zero = sym.zero()
+            pi = sym.pi()
+        else:
+            from math import pi
+
+            # zero = 0.0
+
+        deg = pi / 180
+        # robot length values (metres)
+        D1 = 0.2755
+        D2 = 0.4100
+        D3 = 0.2073
+        D4 = 0.0743
+        D5 = 0.0743
+        D6 = 0.1687
+        e2 = 0.0098
+
+        # alternate parameters
+        aa = 30 * deg
+        # ca = cos(aa)
+        sa = sin(aa)
+        # c2a = cos(2 * aa)
+        s2a = sin(2 * aa)
+        d4b = D3 + sa / s2a * D4
+        d5b = sa / s2a * D4 + sa / s2a * D5
+        d6b = sa / s2a * D5 + D6
+
+        # and build a serial link manipulator
+
+        # offsets from the table on page 4, "Mico" angles are the passed joint
+        # angles.  "DH Algo" are the result after adding the joint angle offset.
+
+        super().__init__(
+            [
+                RevoluteDH(alpha=pi / 2, a=0, d=D1, flip=True),
+                RevoluteDH(alpha=pi, a=D2, d=0, offset=-pi / 2),
+                RevoluteDH(alpha=pi / 2, a=0, d=-e2, offset=pi / 2),
+                RevoluteDH(alpha=2 * aa, a=0, d=-d4b),
+                RevoluteDH(alpha=2 * aa, a=0, d=-d5b, offset=-pi),
+                RevoluteDH(alpha=pi, a=0, d=-d6b, offset=100 * deg),
+            ],
+            name="Jaco",
+            manufacturer="Kinova",
+            keywords=("symbolic",),
+        )
+
+        self.qr = np.array([270, 180, 180, 0, 0, 0]) * deg
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    jaco = Jaco(symbolic=False)
+    print(jaco)

roboticstoolbox/models/DH/KR5.py

@@ -0,0 +1,112 @@
+"""
+@author: Gautam Sinha, Indian Institute of Technology, Kanpur
+  (original MATLAB version)
+@author: Peter Corke
+@author: Samuel Drew
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH
+from math import pi
+import numpy as np
+
+
+class KR5(DHRobot):
+    """
+    Class that models a Kuka KR5 manipulator
+
+    ``KR5()`` is a class which models a Kuka KR5 robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.KR5()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+      - qk1, nominal working position 1
+      - qk2, nominal working position 2
+      - qk3, nominal working position 3
+
+    .. note::
+      - SI units of metres are used.
+      - Includes an 11.5cm tool in the z-direction
+
+    :references:
+      - https://github.com/4rtur1t0/ARTE/blob/master/robots/KUKA/KR5_arc/parameters.m
+
+    .. codeauthor:: Gautam Sinha, Indian Institute of Technology, Kanpur (original MATLAB version)
+    .. codeauthor:: Samuel Drew
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self):
+        deg = pi / 180
+
+        # Updated values form ARTE git. Old values left as comments
+
+        L1 = RevoluteDH(
+            a=0.18,
+            d=0.4,
+            alpha=-pi / 2,
+            qlim=[-155 * deg, 155 * deg],  # alpha=pi / 2,
+        )
+        L2 = RevoluteDH(
+            a=0.6,
+            d=0,
+            alpha=0,
+            qlim=[-180 * deg, 65 * deg],  # d=0.135,  # alpha=pi,
+        )
+        L3 = RevoluteDH(
+            a=0.12,
+            d=0,  # d=0.135,
+            alpha=pi / 2,  # alpha=-pi / 2,
+            qlim=[-15 * deg, 158 * deg],
+        )
+        L4 = RevoluteDH(
+            a=0.0,
+            d=-0.62,  # d=0.62,
+            alpha=-pi / 2,  # alpha=pi / 2,
+            qlim=[-350 * deg, 350 * deg],
+        )
+        L5 = RevoluteDH(
+            a=0.0,
+            d=0.0,
+            alpha=pi / 2,
+            qlim=[-130 * deg, 130 * deg],  # alpha=-pi / 2,
+        )
+        L6 = RevoluteDH(a=0, d=-0.115, alpha=pi, qlim=[-350 * deg, 350 * deg])
+
+        L = [L1, L2, L3, L4, L5, L6]
+
+        # Create SerialLink object
+        super().__init__(
+            L,
+            # meshdir="KUKA/KR5_arc",
+            name="KR5",
+            manufacturer="KUKA",
+            meshdir="meshes/KUKA/KR5_arc",
+        )
+
+        self.qr = np.array([pi / 4, pi / 3, pi / 4, pi / 6, pi / 4, pi / 6])
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+        self.addconfiguration_attr(
+            "qk1", np.array([pi / 4, pi / 3, pi / 4, pi / 6, pi / 4, pi / 6])
+        )
+        self.addconfiguration_attr(
+            "qk2", np.array([pi / 4, pi / 3, pi / 6, pi / 3, pi / 4, pi / 6])
+        )
+        self.addconfiguration_attr(
+            "qk3", np.array([pi / 6, pi / 3, pi / 6, pi / 3, pi / 6, pi / 3])
+        )
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = KR5()
+    print(robot)

roboticstoolbox/models/DH/LWR4.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+import numpy as np
+from spatialmath.base import trotz, transl
+from roboticstoolbox import DHRobot, RevoluteDH
+
+
+class LWR4(DHRobot):
+    """
+    Class that models a LWR-IV manipulator
+
+    ``LWR4()`` is a class which models a Kuka LWR-IV robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.LWR4()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+    - qs, arm is stretched out in the X direction
+    - qn, arm is at a nominal non-singular configuration
+
+    .. note:: SI units are used.
+
+    :references:
+
+        - http://www.diag.uniroma1.it/~deluca/rob1_en/09_Exercise_DH_KukaLWR4.pdf
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self):
+
+        # deg = np.pi/180
+        mm = 1e-3
+        tool_offset = (103) * mm
+
+        flange = 0 * mm
+        # d7 = (58.4)*mm
+
+        # This Kuka model is defined using modified
+        # Denavit-Hartenberg parameters
+
+        L = [
+            RevoluteDH(a=0.0, d=0, alpha=np.pi / 2, qlim=np.array([-2.8973, 2.8973])),
+            RevoluteDH(
+                a=0.0, d=0.0, alpha=-np.pi / 2, qlim=np.array([-1.7628, 1.7628])
+            ),
+            RevoluteDH(
+                a=0.0, d=0.40, alpha=-np.pi / 2, qlim=np.array([-2.8973, 2.8973])
+            ),
+            RevoluteDH(
+                a=0.0, d=0.0, alpha=np.pi / 2, qlim=np.array([-3.0718, -0.0698])
+            ),
+            RevoluteDH(
+                a=0.0, d=0.39, alpha=np.pi / 2, qlim=np.array([-2.8973, 2.8973])
+            ),
+            RevoluteDH(
+                a=0.0, d=0.0, alpha=-np.pi / 2, qlim=np.array([-0.0175, 3.7525])
+            ),
+            RevoluteDH(a=0.0, d=flange, alpha=0.0, qlim=np.array([-2.8973, 2.8973])),
+        ]
+
+        tool = transl(0, 0, tool_offset) @ trotz(-np.pi / 4)
+
+        super().__init__(L, name="LWR-IV", manufacturer="Kuka", tool=tool)
+
+        # tool = xyzrpy_to_trans(0, 0, d7, 0, 0, -np.pi/4)
+
+        self.qr = np.array(7)
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = LWR4()
+    print(robot)

roboticstoolbox/models/DH/Mico.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+
+from math import pi, sin, cos
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+from spatialmath import SE3
+
+
+class Mico(DHRobot):
+    """
+    Class that models a  Kinova Mico manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``Mico()`` is an object which models a Kinova Mico robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Puma560()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+    - qs, arm is stretched out in the x-direction
+    - qn, arm is at a nominal non-singular configuration
+
+    .. note::
+        - SI units are used.
+
+    :references:
+        - "DH Parameters of Mico" Version 1.0.8, July 25, 2013.
+
+    :seealso: :func:`Mico`
+    """
+
+    def __init__(self, symbolic=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            zero = sym.zero()
+            pi = sym.pi()
+        else:
+            from math import pi
+
+            zero = 0.0
+
+        deg = pi / 180
+        # robot length values (metres)
+        D1 = 0.2755
+        D2 = 0.2900
+        D3 = 0.1233
+        D4 = 0.0741
+        D5 = 0.0741
+        D6 = 0.1600
+        e2 = 0.0070
+
+        # alternate parameters
+        aa = 30 * deg
+        ca = cos(aa)
+        sa = sin(aa)
+        c2a = cos(2 * aa)
+        s2a = sin(2 * aa)
+        d4b = D3 + sa / s2a * D4
+        d5b = sa / s2a * D4 + sa / s2a * D5
+        d6b = sa / s2a * D5 + D6
+
+        # and build a serial link manipulator
+
+        # offsets from the table on page 4, "Mico" angles are the passed joint
+        # angles.  "DH Algo" are the result after adding the joint angle offset.
+
+        super().__init__(
+            [
+                RevoluteDH(alpha=pi / 2, a=0, d=D1, flip=True),
+                RevoluteDH(alpha=pi, a=D2, d=0, offset=-pi / 2),
+                RevoluteDH(alpha=pi / 2, a=0, d=-e2, offset=pi / 2),
+                RevoluteDH(alpha=2 * aa, a=0, d=-d4b),
+                RevoluteDH(alpha=2 * aa, a=0, d=-d5b, offset=-pi),
+                RevoluteDH(alpha=pi, a=0, d=-d6b, offset=100 * deg),
+            ],
+            name="Mico",
+            manufacturer="Kinova",
+            keywords=("symbolic",),
+        )
+
+        self.qr = np.array([270, 180, 180, 0, 0, 0]) * deg
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    mico = Mico(symbolic=False)
+    print(mico)

roboticstoolbox/models/DH/Orion5.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+# Created by: Aditya Dua
+# 5 October 2017
+
+from math import pi
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+from spatialmath import SE3
+
+
+class Orion5(DHRobot):
+    """
+    Class that models a RAWR robotics Orion5 manipulator
+
+    ``Orion5()`` is a class which models a RAWR Robotics Orion5 robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Orion5()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+        - qz, zero angles, all folded up
+        - qv, stretched out vertically
+        - qh, arm horizontal, hand down
+
+    .. note::
+
+      - SI units of metres are used.
+      - Robot has only 4 DoF.
+
+    :references:
+        - https://rawrobotics.com.au/orion5
+        - https://drive.google.com/file/d/0B6_9_-ZgiRdTNkVqMEkxN2RSc2c/view
+
+    .. codeauthor:: Aditya Dua
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self, base=None):
+
+        mm = 1e-3
+        deg = pi / 180
+
+        # details from
+
+        h = 53.0 * mm
+        r = 30.309 * mm
+        l2 = 170.384 * mm
+        l3 = 136.307 * mm
+        l4 = 86.00 * mm
+        c = 40.0 * mm
+
+        # tool_offset = l4 + c
+
+        # Turret, Shoulder, Elbow, Wrist, Claw
+        links = [
+            RevoluteDH(d=h, a=0, alpha=90 * deg),  # Turret
+            RevoluteDH(d=0, a=l2, alpha=0, qlim=[10 * deg, 122.5 * deg]),  # Shoulder
+            RevoluteDH(d=0, a=-l3, alpha=0, qlim=[20 * deg, 340 * deg]),  # Elbow
+            RevoluteDH(d=0, a=l4 + c, alpha=0, qlim=[45 * deg, 315 * deg]),  # Wrist
+        ]
+
+        super().__init__(
+            links,
+            name="Orion 5",
+            manufacturer="RAWR Robotics",
+            base=SE3(r, 0, 0),
+            tool=SE3.Ry(90, "deg"),
+        )
+
+        self.qr = np.array([0, 0, 180, 90]) * deg
+        self.qz = np.zeros(4)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+        # stretched out vertically
+        self.addconfiguration_attr("qv", np.r_[0, 90, 180, 180] * deg)
+
+        # arm horizontal, hand down
+        self.addconfiguration_attr("qh", np.r_[0, 0, 180, 90] * deg)
+
+
+if __name__ == "__main__":  # pragma nocover
+    orion = Orion5()
+    print(orion)