roboticstoolbox-python 1.4.0__py3-none-any.whl

roboticstoolbox/models/DH/Stanford.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH, PrismaticDH
+from math import pi
+import numpy as np
+
+
+class Stanford(DHRobot):
+    """
+    Class that models a Stanford arm manipulator
+
+    ``Stanford()`` 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.Stanford()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+        - qz, zero joint angle configuration
+
+    .. note::
+        - SI units are used.
+        - Gear ratios not currently known, though reflected armature inertia
+          is known, so gear ratios are set to 1.
+
+    :references:
+        - Kinematic data from "Modelling, Trajectory calculation and Servoing
+          of a computer controlled arm".  Stanford AIM-177.  Figure 2.3
+        - Dynamic data from "Robot manipulators: mathematics, programming and
+          control"
+          Paul 1981, Tables 6.5, 6.6
+        - Dobrotin & Scheinman, "Design of a computer controlled manipulator
+          for robot research", IJCAI, 1973.
+
+    .. codeauthor:: Peter Corke
+
+    """
+
+    def __init__(self):
+
+        deg = pi / 180
+        inch = 0.0254
+
+        L0 = RevoluteDH(
+            d=0.412,  # link length (Dennavit-Hartenberg notation)
+            a=0,  # link offset (Dennavit-Hartenberg notation)
+            alpha=-pi / 2,  # link twist (Dennavit-Hartenberg notation)
+            # inertia tensor of link with respect to
+            # center of mass I = [L_xx, L_yy, L_zz,
+            # L_xy, L_yz, L_xz]
+            I=[0.276, 0.255, 0.071, 0, 0, 0],
+            # distance of ith origin to center of mass [x,y,z]
+            # in link reference frame
+            r=[0, 0.0175, -0.1105],
+            m=9.29,  # mass of link
+            Jm=0.953,  # actuator inertia
+            G=1,  # gear ratio
+            qlim=[-170 * deg, 170 * deg],
+        )  # minimum and maximum joint angle
+
+        L1 = RevoluteDH(
+            d=0.154,
+            a=0.0,
+            alpha=pi / 2,
+            I=[0.108, 0.018, 0.100, 0, 0, 0],
+            r=[0, -1.054, 0],
+            m=5.01,
+            Jm=2.193,
+            G=1,
+            qlim=[-170 * deg, 170 * deg],
+        )
+
+        L2 = PrismaticDH(
+            theta=-pi / 2,
+            a=0.0203,
+            alpha=0,
+            I=[2.51, 2.51, 0.006, 0, 0, 0],
+            r=[0, 0, -6.447],
+            m=4.25,
+            Jm=0.782,
+            G=1,
+            qlim=[12 * inch, (12 + 38) * inch],
+        )
+
+        L3 = RevoluteDH(
+            d=0,
+            a=0,
+            alpha=-pi / 2,
+            I=[0.002, 0.001, 0.001, 0, 0, 0],
+            r=[0, 0.092, -0.054],
+            m=1.08,
+            Jm=0.106,
+            G=1,
+            qlim=[-170 * deg, 170 * deg],
+        )
+
+        L4 = RevoluteDH(
+            d=0,
+            a=0,
+            alpha=pi / 2,
+            I=[0.003, 0.0004, 0, 0, 0, 0],
+            r=[0, 0.566, 0.003],
+            m=0.630,
+            Jm=0.097,
+            G=1,
+            qlim=[-90 * deg, 90 * deg],
+        )
+
+        L5 = RevoluteDH(
+            d=0,
+            a=0,
+            alpha=0,
+            I=[0.013, 0.013, 0.0003, 0, 0, 0],
+            r=[0, 0, 1.554],
+            m=0.51,
+            Jm=0.020,
+            G=1,
+            qlim=[-170 * deg, 170 * deg],
+        )
+
+        L = [L0, L1, L2, L3, L4, L5]
+
+        super().__init__(
+            L,
+            name="Stanford arm",
+            manufacturer="Victor Scheinman",
+            keywords=("dynamics",),
+        )
+
+        self.qr = np.zeros(6)
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    stanford = Stanford()
+    print(stanford)

roboticstoolbox/models/DH/TwoLink.py

@@ -0,0 +1,153 @@
+"""
+@author: Peter Corke
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH, RevoluteMDH
+
+# from math import pi
+from spatialmath import SE3
+import numpy as np
+
+
+class TwoLink(DHRobot):
+    """
+    Class that models a 2-link robot moving in the vertical plane
+
+    :param symbolic: use symbolic constants
+    :param mdh: create a model using modified DH parameters, otherwise standard DH parameters are used
+    :param inertia: include link inertias, otherwise they are set to zero
+
+    ``TwoLink()`` is a class which models a 2-link planar robot and
+    describes its kinematic and dynamic characteristics using standard DH
+    conventions. of a simple planar 2-link mechanism moving in the xz-plane, it experiences gravity loading.
+    All mass is concentrated at the joints.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.TwoLink()
+        >>> print(robot)
+
+    The parameters values depend on the ``symbolic`` and ``mdh`` parameters
+
+    ===========================================  =================  ==============
+    Parameters                                   Numeric values     Symbolic values
+    ===========================================  =================  ==============
+    link lengths                                 1, 1               a1, a2
+    link masses                                  1, 1               m1, m2
+    link CoMs in the link frame x-direction DH   -0.5, -0.5         c1, c2
+    link CoMs in the link frame x-direction MDH  0.5, 0.5           c1, c2
+    gravitational acceleration                   9.8                g
+    ===========================================  =================  ==============
+
+    Defined joint configurations are:
+
+        - qz, zero angles, all folded up
+        - q1, links are horizontal and vertical respectively
+        - q2, links are vertical and horizontal respectively
+        - qn, nominal working configuration
+
+    .. note::
+
+        - Robot has only 2 DoF.
+        - Motor inertia is 0.
+        - Link inertias are 0 unless ``inertia`` is True.
+        - Viscous and Coulomb friction is 0.
+
+    :Reference: Based on Fig 3-6 (p73) of Spong and Vidyasagar (1st edition).
+
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self, symbolic:bool=False, mdh:bool=False, inertia:bool=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            zero = sym.zero()
+            pi = sym.pi()
+            a1, a2 = sym.symbol("a1 a2")  # link lengths # type: ignore
+            m1, m2 = sym.symbol("m1 m2")  # link masses # type: ignore
+            c1, c2 = sym.symbol("c1 c2")  # link CoMs location relative to link frames# type: ignore
+            if inertia:
+                r = sym.symbol("r") # link radius, assumed tubular, for inertia calculation # type: ignore
+                I1, I2 = _cylinder_inertia_x(m1, r, a1), _cylinder_inertia_x(m2, r, a2)  # moments of inertia about CoM # type: ignore
+            else:
+                I1, I2 = None, None
+            g = sym.symbol("g")
+        else:
+            from math import pi
+
+
+        if mdh:
+            # create a modified DH model
+            if not symbolic:
+                zero = 0.0
+                a1 = 1 # length of first link
+                a2 = 1 # length of second link
+                m1 = 1 # mass of first link
+                m2 = 1 # mass of second link
+                c1 = 0.5 # CoM location of first link relative to first link frame
+                c2 = 0.5 # CoM location of second link relative to second link frame
+                r = 0.1 # radius of links, assumed tubular, for inertia calculation
+                if inertia:
+                    I1, I2 = _cylinder_inertia_x(m1, r, a1), _cylinder_inertia_x(m2, r, a2)  # moments of inertia about CoM # type: ignore
+                else:
+                    I1, I2 = None, None
+                g = 9.8
+
+            links = [
+                RevoluteMDH(a=0, alpha=zero, m=m1, r=[c1, zero, zero], I=I1),
+                RevoluteMDH(a=a1, alpha=zero, m=m2, r=[c2, zero, zero], I=I2),
+            ]
+            tool = SE3.Tx(a2) # the last link is considered as a tool in this case, so the tool is a translation along x by a2
+        else:
+            # create a standard DH model
+            if not symbolic:
+                zero = 0.0
+                a1 = 1 # length of first link
+                a2 = 1 # length of second link
+                m1 = 1 # mass of first link
+                m2 = 1 # mass of second link
+                c1 = -0.5 # CoM location of first link relative to first link frame
+                c2 = -0.5 # CoM location of second link relative to second link frame
+                r = 0.1 # radius of links, assumed tubular, for inertia calculation
+                if inertia:
+                    I1, I2 = _cylinder_inertia_x(m1, r, a1), _cylinder_inertia_x(m2, r, a2)  # moments of inertia about CoM # type: ignore
+                else:
+                    I1, I2 = None, None
+                g = 9.8
+            links = [
+                RevoluteDH(a=a1, alpha=zero, m=m1, r=[c1, 0, 0], I=I1),
+                RevoluteDH(a=a2, alpha=zero, m=m2, r=[c2, 0, 0], I=I2),
+            ]
+            tool = None
+
+        super().__init__(
+            links, symbolic=symbolic, name="2 link", tool=tool, keywords=("planar", "dynamics")
+        )
+
+        self.qr = np.array([pi / 6, -pi / 6])
+        self.qz = np.zeros(2)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+        self.addconfiguration_attr("qz", [0, 0])
+        self.addconfiguration_attr("q1", [0, pi / 2])
+        self.addconfiguration_attr("q2", [pi / 2, -pi / 2])
+        self.addconfiguration_attr("qn", [pi / 6, -pi / 6])
+
+        self.base = SE3.Rx(pi / 2)
+        self.gravity = [0, 0, g]
+
+
+def _cylinder_inertia_x(m, r, L):
+    ixx = 0.5 * m * r**2
+    iyy = (1.0 / 12.0) * m * (3 * r**2 + L**2)
+    izz = iyy
+    return np.diag([ixx, iyy, izz])
+
+if __name__ == "__main__":  # pragma nocover
+    robot = TwoLink(symbolic=True)
+    print(robot)

roboticstoolbox/models/DH/UR10.py

@@ -0,0 +1,124 @@
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+from spatialmath import SE3
+
+
+class UR10(DHRobot):
+    """
+    Class that models a Universal Robotics UR10 manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``UR10()`` is an object 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.UR10()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+    - qr, arm horizontal along x-axis
+
+    .. note::
+        - SI units are used.
+
+    :References:
+
+        - `Parameters for calculations of kinematics and dynamics <https://www.universal-robots.com/articles/ur/parameters-for-calculations-of-kinematics-and-dynamics>`_
+
+    :sealso: :func:`UR3`, :func:`UR5`
+
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    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
+        inch = 0.0254
+
+        # robot length values (metres)
+        a = [0, -0.612, -0.5723, 0, 0, 0]
+        d = [0.1273, 0, 0, 0.163941, 0.1157, 0.0922]
+
+        alpha = [pi / 2, zero, zero, pi / 2, -pi / 2, zero]
+
+        # mass data
+        mass = [7.1, 12.7, 4.27, 2.000, 2.000, 0.365]
+        center_of_mass = [
+            [0.021, 0, 0.027],
+            [0.38, 0, 0.158],
+            [0.24, 0, 0.068],
+            [0.0, 0.007, 0.018],
+            [0.0, 0.007, 0.018],
+            [0, 0, -0.026],
+        ]
+
+        # inertia matrices for each link
+        inertia = [
+            np.array(
+                [[0.0341, 0, -0.0043], [0, 0.0353, 0.0001], [-0.0043, 0.0001, 0.0216]]
+            ),
+            np.array(
+                [[0.0281, 0.0001, -0.0156], [0.0001, 0.7707, 0], [-0.0156, 0, 0.7694]]
+            ),
+            np.array(
+                [[0.0101, 0.0001, 0.0092], [0.0001, 0.3093, 0], [0.0092, 0, 0.3065]]
+            ),
+            np.array(
+                [[0.0030, -0.0000, 0], [-0.0000, 0.0022, -0.0002], [0, -0.0002, 0.0026]]
+            ),
+            np.array(
+                [[0.0030, -0.0000, 0], [-0.0000, 0.0022, -0.0002], [0, -0.0002, 0.0026]]
+            ),
+            np.array([[0, 0, 0], [0, 0.0004, 0], [0, 0, 0.0003]]),
+        ]
+
+        links = []
+
+        for j in range(6):
+            link = RevoluteDH(
+                d=d[j],
+                a=a[j],
+                alpha=alpha[j],
+                m=mass[j],
+                r=center_of_mass[j],
+                G=1,
+                I=inertia[j],
+            )
+            links.append(link)
+
+        super().__init__(
+            links,
+            name="UR10",
+            manufacturer="Universal Robotics",
+            keywords=("dynamics", "symbolic"),
+            symbolic=symbolic,
+        )
+
+        self.qr = np.array([180, 0, 0, 0, 90, 0]) * deg
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    ur10 = UR10(symbolic=False)
+    print(ur10)
+    # print(ur10.dyntable())

roboticstoolbox/models/DH/UR3.py

@@ -0,0 +1,98 @@
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+from spatialmath import SE3
+
+
+class UR3(DHRobot):
+    """
+    Class that models a Universal Robotics UR3 manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``UR3()`` is an object 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.UR3()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+    - qr, arm horizontal along x-axis
+
+    .. note::
+        - SI units are used.
+
+    :References:
+
+        - `Parameters for calculations of kinematics and dynamics <https://www.universal-robots.com/articles/ur/parameters-for-calculations-of-kinematics-and-dynamics>`_
+
+    :sealso: :func:`UR5`, :func:`UR10`
+
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    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
+        inch = 0.0254
+
+        # robot length values (metres)
+        a = [0, -0.24365, -0.21325, 0, 0, 0]
+        d = [0.1519, 0, 0, 0.11235, 0.08535, 0.0819]
+
+        alpha = [pi / 2, zero, zero, pi / 2, -pi / 2, zero]
+
+        # mass data, no inertia available
+        mass = [2, 3.42, 1.26, 0.8, 0.8, 0.35]
+        center_of_mass = [
+            [0, -0.02, 0],
+            [0.13, 0, 0.1157],
+            [0.05, 0, 0.0238],
+            [0, 0, 0.01],
+            [0, 0, 0.01],
+            [0, 0, -0.02],
+        ]
+        links = []
+
+        for j in range(6):
+            link = RevoluteDH(
+                d=d[j], a=a[j], alpha=alpha[j], m=mass[j], r=center_of_mass[j], G=1
+            )
+            links.append(link)
+
+        super().__init__(
+            links,
+            name="UR3",
+            manufacturer="Universal Robotics",
+            keywords=("dynamics", "symbolic"),
+            symbolic=symbolic,
+        )
+
+        self.qr = np.array([180, 0, 0, 0, 90, 0]) * deg
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    ur3 = UR3(symbolic=False)
+    print(ur3)
+    # print(ur3.dyntable())

roboticstoolbox/models/DH/UR5.py

@@ -0,0 +1,98 @@
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+from spatialmath import SE3
+
+
+class UR5(DHRobot):
+    """
+    Class that models a Universal Robotics UR5 manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``UR5()`` is an object 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.UR5()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+    - qr, arm horizontal along x-axis
+
+    .. note::
+        - SI units are used.
+
+    :References:
+
+        - `Parameters for calculations of kinematics and dynamics <https://www.universal-robots.com/articles/ur/parameters-for-calculations-of-kinematics-and-dynamics>`_
+
+    :sealso: :func:`UR4`, :func:`UR10`
+
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    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
+        inch = 0.0254
+
+        # robot length values (metres)
+        a = [0, -0.42500, -0.39225, 0, 0, 0]
+        d = [0.089459, 0, 0, 0.10915, 0.09465, 0.0823]
+
+        alpha = [pi / 2, zero, zero, pi / 2, -pi / 2, zero]
+
+        # mass data, no inertia available
+        mass = [3.7000, 8.3930, 2.33, 1.2190, 1.2190, 0.1897]
+        center_of_mass = [
+            [0, -0.02561, 0.00193],
+            [0.2125, 0, 0.11336],
+            [0.15, 0, 0.0265],
+            [0, -0.0018, 0.01634],
+            [0, -0.0018, 0.01634],
+            [0, 0, -0.001159],
+        ]
+        links = []
+
+        for j in range(6):
+            link = RevoluteDH(
+                d=d[j], a=a[j], alpha=alpha[j], m=mass[j], r=center_of_mass[j], G=1
+            )
+            links.append(link)
+
+        super().__init__(
+            links,
+            name="UR5",
+            manufacturer="Universal Robotics",
+            keywords=("dynamics", "symbolic"),
+            symbolic=symbolic,
+        )
+
+        self.qr = np.array([180, 0, 0, 0, 90, 0]) * deg
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    ur5 = UR5(symbolic=False)
+    print(ur5)
+    # print(ur5.dyntable())

roboticstoolbox/models/DH/Uprighttl.py

@@ -0,0 +1,24 @@
+# """
+# Defines the object 'arm' in the current workspace
+
+# Also define the vector qz = [pi/4,0,-pi/3]
+# """
+
+# from roboticstoolbox.robot.serial_link import *
+
+
+# class Uprighttl(SerialLink):
+
+#     def __init__(self):
+#         L = [Link(a=0.1, alpha=pi / 2, jointtype='R'),
+#              Link(a=1.0, jointtype='R'),
+#              Link(a=1.0, jointtype='R'),
+#              Link(a=0.5, jointtype='R')]
+
+#         self._qz = [0, 0, 0, 0]
+
+#         super(Uprighttl, self).__init__(L, name='Upright Arm')
+
+#     @property
+#     def qz(self):
+#         return self._qz

roboticstoolbox/models/DH/__init__.py

@@ -0,0 +1,52 @@
+from roboticstoolbox.models.DH.Panda import Panda
+from roboticstoolbox.models.DH.Puma560 import Puma560
+from roboticstoolbox.models.DH.Stanford import Stanford
+from roboticstoolbox.models.DH.Ball import Ball
+from roboticstoolbox.models.DH.Hyper import Hyper
+from roboticstoolbox.models.DH.Coil import Coil
+from roboticstoolbox.models.DH.Cobra600 import Cobra600
+from roboticstoolbox.models.DH.IRB140 import IRB140
+from roboticstoolbox.models.DH.KR5 import KR5
+from roboticstoolbox.models.DH.Orion5 import Orion5
+from roboticstoolbox.models.DH.Planar3 import Planar3
+from roboticstoolbox.models.DH.Planar2 import Planar2
+from roboticstoolbox.models.DH.LWR4 import LWR4
+from roboticstoolbox.models.DH.Sawyer import Sawyer
+from roboticstoolbox.models.DH.UR3 import UR3
+from roboticstoolbox.models.DH.UR5 import UR5
+from roboticstoolbox.models.DH.UR10 import UR10
+from roboticstoolbox.models.DH.Mico import Mico
+from roboticstoolbox.models.DH.Jaco import Jaco
+from roboticstoolbox.models.DH.Baxter import Baxter
+from roboticstoolbox.models.DH.TwoLink import TwoLink
+from roboticstoolbox.models.DH.Hyper3d import Hyper3d
+from roboticstoolbox.models.DH.P8 import P8
+from roboticstoolbox.models.DH.AL5D import AL5D
+
+
+__all__ = [
+    "Panda",
+    "Puma560",
+    "Stanford",
+    "Ball",
+    "Coil",
+    "Hyper",
+    "Hyper3d",
+    "Cobra600",
+    "IRB140",
+    "KR5",
+    "Orion5",
+    "Planar3",
+    "Planar2",
+    "LWR4",
+    "UR3",
+    "UR5",
+    "UR10",
+    "Sawyer",
+    "Mico",
+    "Jaco",
+    "Baxter",
+    "TwoLink",
+    "P8",
+    "AL5D",
+]