roboticstoolbox-python 1.4.0__py3-none-any.whl

roboticstoolbox/models/DH/P8.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+@author: Jesse Haviland
+"""
+
+# 2/8/95  changed D3 to 150.05mm which is closer to data from Lee, AKB86 and
+# Tarn fixed errors in COG for links 2 and 3
+# 29/1/91 to agree with data from Armstrong etal.  Due to their use
+#  of modified D&H params, some of the offsets Ai, Di are
+#  offset, and for links 3-5 swap Y and Z axes.
+# 14/2/91 to use Paul's value of link twist (alpha) to be consistant
+#  with ARCL.  This is the -ve of Lee's values, which means the
+#  zero angle position is a righty for Paul, and lefty for Lee.
+
+# all parameters are in SI units: m, radians, kg, kg.m2, N.m, N.m.s etc.
+
+# from math import pi
+import numpy as np
+from roboticstoolbox import DHRobot, PrismaticDH, models
+from spatialmath import SE3
+from spatialmath import base
+from math import pi
+
+
+class P8(DHRobot):
+    """
+    Class that models a Puma robot on an XY base
+
+    ``P8()`` is an object which models an 8-axis robot comprising a Puma 560
+    robot on an XY base.  Joints 0 and 1 are the base, joints 2-7 are the robot
+    arm.
+
+    .. 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
+
+
+    .. note::
+        - SI units are used.
+
+    .. codeauthor:: Peter Corke
+
+    :seealso: :func:`models.DH.Puma560`
+    """  # noqa
+
+    def __init__(self):
+
+        # create the base
+        links = [
+            PrismaticDH(alpha=-pi / 2, qlim=[-1, 1]),
+            PrismaticDH(theta=-pi / 2, alpha=pi / 2, qlim=[-1, 1]),
+        ]
+
+        # stick the Puma on top
+        puma = models.DH.Puma560()
+        links.extend(puma.links)
+
+        super().__init__(
+            links, name="P8", keywords=("mobile", "redundant"), base=SE3.Ry(pi / 2)
+        )
+
+        self.qr = np.zeros(8)
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = P8()
+    print(robot)
+
+    # robot.plot([.5, -0.6, 0, 0, 0, 0, 0, 0], block=True)

roboticstoolbox/models/DH/Panda.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+
+import numpy as np
+from spatialmath.base import trotz, transl
+from roboticstoolbox import DHRobot, RevoluteMDH
+
+
+class Panda(DHRobot):
+    """
+    A class representing the Panda robot arm.
+
+    ``Panda()`` is a class which models a Franka-Emika Panda robot and
+    describes its kinematic characteristics using modified DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Panda()
+        >>> print(robot)
+
+    .. note::
+        - SI units of metres are used.
+        - The model includes a tool offset.
+
+    :references:
+        - https://frankaemika.github.io/docs/control_parameters.html
+
+    .. codeauthor:: Samuel Drew
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        # deg = np.pi/180
+        mm = 1e-3
+        tool_offset = (103) * mm
+
+        flange = (107) * mm
+        # d7 = (58.4)*mm
+
+        # This Panda model is defined using modified
+        # Denavit-Hartenberg parameters
+        L = [
+            RevoluteMDH(
+                a=0.0,
+                d=0.333,
+                alpha=0.0,
+                qlim=np.array([-2.8973, 2.8973]),
+                m=4.970684,
+                I=[
+                    7.03370e-01,
+                    7.06610e-01,
+                    9.11700e-03,
+                    -1.39000e-04,
+                    1.91690e-02,
+                    6.77200e-03,
+                ],
+                r=[
+                    3.875e-03,
+                    2.081e-03,
+                    0,
+                ],
+                G=1,
+            ),
+            RevoluteMDH(
+                a=0.0,
+                d=0.0,
+                alpha=-np.pi / 2,
+                qlim=np.array([-1.7628, 1.7628]),
+                m=0.646926,
+                I=[
+                    7.96200e-03,
+                    2.81100e-02,
+                    2.59950e-02,
+                    -3.92500e-03,
+                    7.04000e-04,
+                    1.02540e-02,
+                ],
+                r=[
+                    -3.141e-03,
+                    -2.872e-02,
+                    3.495e-03,
+                ],
+                G=1,
+            ),
+            RevoluteMDH(
+                a=0.0,
+                d=0.316,
+                alpha=np.pi / 2,
+                qlim=np.array([-2.8973, 2.8973]),
+                m=3.228604,
+                I=[
+                    3.72420e-02,
+                    3.61550e-02,
+                    1.08300e-02,
+                    -4.76100e-03,
+                    -1.28050e-02,
+                    -1.13960e-02,
+                ],
+                r=[
+                    2.7518e-02,
+                    3.9252e-02,
+                    -6.6502e-02,
+                ],
+                G=1,
+            ),
+            RevoluteMDH(
+                a=0.0825,
+                d=0.0,
+                alpha=np.pi / 2,
+                qlim=np.array([-3.0718, -0.0698]),
+                m=3.587895,
+                I=[
+                    2.58530e-02,
+                    1.95520e-02,
+                    2.83230e-02,
+                    7.79600e-03,
+                    8.64100e-03,
+                    -1.33200e-03,
+                ],
+                r=[
+                    -5.317e-02,
+                    1.04419e-01,
+                    2.7454e-02,
+                ],
+                G=1,
+            ),
+            RevoluteMDH(
+                a=-0.0825,
+                d=0.384,
+                alpha=-np.pi / 2,
+                qlim=np.array([-2.8973, 2.8973]),
+                m=1.225946,
+                I=[
+                    3.55490e-02,
+                    2.94740e-02,
+                    8.62700e-03,
+                    -2.11700e-03,
+                    2.29000e-04,
+                    -4.03700e-03,
+                ],
+                r=[
+                    -1.1953e-02,
+                    4.1065e-02,
+                    -3.8437e-02,
+                ],
+                G=1,
+            ),
+            RevoluteMDH(
+                a=0.0,
+                d=0.0,
+                alpha=np.pi / 2,
+                qlim=np.array([-0.0175, 3.7525]),
+                m=1.666555,
+                I=[
+                    1.96400e-03,
+                    4.35400e-03,
+                    5.43300e-03,
+                    1.09000e-04,
+                    3.41000e-04,
+                    -1.15800e-03,
+                ],
+                r=[
+                    6.0149e-02,
+                    -1.4117e-02,
+                    -1.0517e-02,
+                ],
+                G=1,
+            ),
+            RevoluteMDH(
+                a=0.088,
+                d=flange,
+                alpha=np.pi / 2,
+                qlim=np.array([-2.8973, 2.8973]),
+                m=7.35522e-01,
+                I=[
+                    1.25160e-02,
+                    1.00270e-02,
+                    4.81500e-03,
+                    -4.28000e-04,
+                    -7.41000e-04,
+                    -1.19600e-03,
+                ],
+                r=[
+                    1.0517e-02,
+                    -4.252e-03,
+                    -4.5403e-02,
+                ],
+                G=1,
+            ),
+        ]
+
+        tool = transl(0, 0, tool_offset) @ trotz(-np.pi / 4)
+
+        super().__init__(
+            L,
+            name="Panda",
+            manufacturer="Franka Emika",
+            meshdir="meshes/FRANKA-EMIKA/Panda",
+            tool=tool,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    panda = Panda()
+    print(panda)

roboticstoolbox/models/DH/Planar2.py

@@ -0,0 +1,69 @@
+"""
+@author: Luis Fernando Lara Tobar
+@author: Peter Corke
+@author: Samuel Drew
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH
+import numpy as np
+
+
+class Planar2(DHRobot):
+    """
+    Class that models a planar 2-link robot
+
+    ``Planar2()`` is a class which models a 2-link planar robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Planar2()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+        - qz, zero angles, all folded up
+        - q1, links are horizontal and vertical respectively
+        - q2, links are vertical and horizontal respectively
+
+    .. note::
+
+      - Robot has only 2 DoF.
+
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self, symbolic=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            zero = sym.zero()
+            pi = sym.pi()
+            a1, a2 = sym.symbol("a1 a2")  # type: ignore
+        else:
+            from math import pi
+
+            zero = 0.0
+            a1 = 1
+            a2 = 1
+
+        L = [RevoluteDH(a=a1, alpha=zero), RevoluteDH(a=a2, alpha=zero)]
+
+        super().__init__(L, name="Planar 2 link", keywords=("planar",))
+
+        self.qr = np.array([0, pi / 2])
+        self.qz = np.zeros(2)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+        self.addconfiguration_attr("q1", np.array([0, pi / 2]))
+        self.addconfiguration_attr("q2", np.array([pi / 2, -pi / 2]))
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Planar2()
+    print(robot)

roboticstoolbox/models/DH/Planar3.py

@@ -0,0 +1,51 @@
+"""
+@author: Luis Fernando Lara Tobar
+@author: Peter Corke
+@author: Samuel Drew
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH
+import numpy as np
+
+
+class Planar3(DHRobot):
+    """
+    Class that models a planar 3-link robot
+
+    ``Planar2()`` is a class which models a 3-link planar robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Planar3()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+        - qz, zero angles, all folded up
+
+    .. note::
+
+      - Robot has only 3 DoF.
+
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        L = [RevoluteDH(a=1), RevoluteDH(a=1), RevoluteDH(a=1)]
+
+        super().__init__(L, name="Planar 3 link", keywords=("planar",))
+
+        self.qr = np.zeros(3)
+        self.qz = np.zeros(3)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Planar3()
+    print(robot)