roboticstoolbox-python 1.3.0__cp312-cp312-win_amd64.whl

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",
+]

roboticstoolbox/models/ETS/Frankie.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ET import ET
+from roboticstoolbox.robot.ETS import ETS
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.robot.Link import Link
+
+
+class Frankie(Robot):
+    """
+    A class representing the Franka Emika Panda robot arm. ETS taken from [1]
+    based on https://frankaemika.github.io/docs/control_parameters.html
+
+    :param et_list: List of elementary transforms which represent the robot
+        kinematics
+    :type et_list: list of etb.robot.et
+    :param q_idx: List of indexes within the ets_list which correspond to
+        joints
+    :type q_idx: list of int
+    :param name: Name of the robot
+    :type name: str, optional
+    :param manufacturer: Manufacturer of the robot
+    :type manufacturer: str, optional
+    :param base: Location of the base is the world frame
+    :type base: float np.ndarray(4,4), optional
+    :param tool: Offset of the flange of the robot to the end-effector
+    :type tool: float np.ndarray(4,4), optional
+    :param qz: The zero joint angle configuration of the robot
+    :type qz: float np.ndarray(7,)
+    :param qr: The ready state joint angle configuration of the robot
+    :type qr: float np.ndarray(7,)
+
+    References: [1] Kinematic Derivatives using the Elementary Transform
+        Sequence, J. Haviland and P. Corke
+    """
+
+    def __init__(self):
+
+        deg = np.pi / 180
+        mm = 1e-3
+        tool_offset = (103) * mm
+
+        b0 = Link(ETS(ET.Rz()), name="base0", parent=None)
+
+        b1 = Link(ETS(ET.tx()), name="base1", parent=b0)
+
+        l0 = Link(ET.tz(0.333) * ET.Rz(), name="link0", parent=b1)
+
+        l1 = Link(ET.Rx(-90 * deg) * ET.Rz(), name="link1", parent=l0)
+
+        l2 = Link(ET.Rx(90 * deg) * ET.tz(0.316) * ET.Rz(), name="link2", parent=l1)
+
+        l3 = Link(ET.tx(0.0825) * ET.Rx(90 * deg) * ET.Rz(), name="link3", parent=l2)
+
+        l4 = Link(
+            ET.tx(-0.0825) * ET.Rx(-90 * deg) * ET.tz(0.384) * ET.Rz(),
+            name="link4",
+            parent=l3,
+        )
+
+        l5 = Link(ET.Rx(90 * deg) * ET.Rz(), name="link5", parent=l4)
+
+        l6 = Link(
+            ET.tx(0.088) * ET.Rx(90 * deg) * ET.tz(0.107) * ET.Rz(),
+            name="link6",
+            parent=l5,
+        )
+
+        ee = Link(ET.tz(tool_offset) * ET.Rz(-np.pi / 4), name="ee", parent=l6)
+
+        elinks = [b0, b1, l0, l1, l2, l3, l4, l5, l6, ee]
+
+        super(Frankie, self).__init__(
+            elinks,
+            name="Frankie",
+            manufacturer="Franka Emika, Omron",
+            keywords=("mobile",),
+        )
+
+        self.qr = np.array([0, 0, 0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4])
+        self.qz = np.zeros(9)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Frankie()
+    print(robot)

roboticstoolbox/models/ETS/GenericSeven.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ET import ET
+from roboticstoolbox.robot.ETS import ETS
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.robot.Link import Link
+
+
+class GenericSeven(Robot):
+    """
+    Create model of a generic seven degree-of-freedom robot
+
+    robot = GenericSeven() creates a robot object. This robot is represented
+    using the elementary transform sequence (ETS).
+
+    """
+
+    def __init__(self):
+
+        deg = np.pi / 180
+        mm = 1e-3
+        tool_offset = (103) * mm
+
+        link_length = 0.5
+
+        l0 = Link(ET.tz(link_length) * ET.Rz(), name="link0", parent=None)
+
+        l1 = Link(ETS(ET.Ry()), name="link1", parent=l0)
+
+        l2 = Link(ET.tz(link_length) * ET.Rz(), name="link2", parent=l1)
+
+        l3 = Link(ETS(ET.Ry()), name="link3", parent=l2)
+
+        l4 = Link(ET.tz(link_length) * ET.Rz(), name="link4", parent=l3)
+
+        l5 = Link(ETS(ET.Ry()), name="link5", parent=l4)
+
+        l6 = Link(ET.tx(link_length) * ET.Rz(), name="link6", parent=l5)
+
+        ee = Link(ETS(ET.tz(-link_length)), name="ee", parent=l6)
+
+        elinks = [l0, l1, l2, l3, l4, l5, l6, ee]
+        # elinks = [l0, l1, l2, l3, l4, l5, ee]
+
+        super(GenericSeven, self).__init__(
+            elinks, name="Generic Seven", manufacturer="Jesse's Imagination"
+        )
+
+        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)

roboticstoolbox/models/ETS/Omni.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ET import ET
+from roboticstoolbox.robot.ETS import ETS
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.robot.Link import Link
+import spatialgeometry as sg
+import spatialmath as sm
+
+
+class Omni(Robot):
+    """
+    A class an omnidirectional mobile robot.
+
+    :param et_list: List of elementary transforms which represent the robot
+        kinematics
+    :type et_list: list of etb.robot.et
+    :param q_idx: List of indexes within the ets_list which correspond to
+        joints
+    :type q_idx: list of int
+    :param name: Name of the robot
+    :type name: str, optional
+    :param manufacturer: Manufacturer of the robot
+    :type manufacturer: str, optional
+    :param base: Location of the base is the world frame
+    :type base: float np.ndarray(4,4), optional
+    :param tool: Offset of the flange of the robot to the end-effector
+    :type tool: float np.ndarray(4,4), optional
+    :param qz: The zero joint angle configuration of the robot
+    :type qz: float np.ndarray(7,)
+    :param qr: The ready state joint angle configuration of the robot
+    :type qr: float np.ndarray(7,)
+
+    References: [1] Kinematic Derivatives using the Elementary Transform
+        Sequence, J. Haviland and P. Corke
+    """
+
+    def __init__(self):
+
+        l, w, h = 0.55, 0.40, 0.35
+
+        b0 = Link(ETS(ET.Rz()), name="base0", parent=None, qlim=[-1000, 1000])
+
+        b1 = Link(ETS(ET.tx()), name="base1", parent=b0, qlim=[-1000, 1000])
+
+        b2 = Link(ETS(ET.ty()), name="base2", parent=b1, qlim=[-1000, 1000])
+
+        g0 = Link(name="gripper", parent=b2)
+
+        b2.geometry = sg.Cuboid(
+            [l, w, h], base=sm.SE3(0, 0, h / 2), color=(163, 157, 134)
+        )
+
+        elinks = [b0, b1, b2, g0]
+
+        super(Omni, self).__init__(
+            elinks,
+            name="Omni",
+            manufacturer="Jesse",
+            keywords=("mobile",),
+            gripper_links=g0,
+        )
+
+        self.qr = np.array([0, 0, 0])
+        self.qz = np.zeros(3)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Omni()
+    print(robot)

roboticstoolbox/models/ETS/Panda.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ET import ET
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.robot.Link import Link
+
+
+class Panda(Robot):
+    """
+    Create model of Franka-Emika Panda manipulator
+
+    panda = Panda() creates a robot object representing the Franka-Emika
+    Panda robot arm. This robot is represented using the elementary
+    transform sequence (ETS).
+
+    ETS taken from [1] based on
+    https://frankaemika.github.io/docs/control_parameters.html
+
+    :references:
+        - Kinematic Derivatives using the Elementary Transform
+          Sequence, J. Haviland and P. Corke
+
+    """
+
+    def __init__(self):
+
+        deg = np.pi / 180
+        mm = 1e-3
+        tool_offset = (103) * mm
+
+        l0 = Link(ET.tz(0.333) * ET.Rz(), name="link0", parent=None)
+
+        l1 = Link(ET.Rx(-90 * deg) * ET.Rz(), name="link1", parent=l0)
+
+        l2 = Link(ET.Rx(90 * deg) * ET.tz(0.316) * ET.Rz(), name="link2", parent=l1)
+
+        l3 = Link(ET.tx(0.0825) * ET.Rx(90, "deg") * ET.Rz(), name="link3", parent=l2)
+
+        l4 = Link(
+            ET.tx(-0.0825) * ET.Rx(-90, "deg") * ET.tz(0.384) * ET.Rz(),
+            name="link4",
+            parent=l3,
+        )
+
+        l5 = Link(ET.Rx(90, "deg") * ET.Rz(), name="link5", parent=l4)
+
+        l6 = Link(
+            ET.tx(0.088) * ET.Rx(90, "deg") * ET.tz(0.107) * ET.Rz(),
+            name="link6",
+            parent=l5,
+        )
+
+        ee = Link(ET.tz(tool_offset) * ET.Rz(-np.pi / 4), name="ee", parent=l6)
+
+        elinks = [l0, l1, l2, l3, l4, l5, l6, ee]
+
+        super(Panda, self).__init__(elinks, name="Panda", manufacturer="Franka Emika")
+
+        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
+    robot = Panda()
+    print(robot)

roboticstoolbox/models/ETS/Planar2.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ET import ET2
+from roboticstoolbox.robot.ETS import ETS2
+from roboticstoolbox.robot.Robot import Robot2
+from roboticstoolbox.robot.Link import Link2
+
+
+class Planar2(Robot2):
+    """
+    Create model of a branched planar manipulator::
+
+        L0 -- L1 -+- L2a -- L3a -- EEa
+                |
+                +- L2b -- L3b -- EEb
+
+    ``Planar_Y()`` creates a planar branched manipulator model.
+
+
+    :references:
+        - Kinematic Derivatives using the Elementary Transform
+          Sequence, J. Haviland and P. Corke
+
+    """
+
+    def __init__(self):
+
+        a1 = 1
+        a2 = 1
+
+        l0 = Link2(ETS2(ET2.R()), name="link0")
+        l1 = Link2(ETS2(ET2.tx(a1)) * ET2.R(), name="link1", parent=l0)
+        l2 = Link2(ETS2(ET2.tx(a2)), name="ee", parent=l1)
+
+        super().__init__([l0, l1, l2], name="Planar2", comment="Planar 2D manipulator")
+
+        self.qb = np.array([0, np.pi / 2])
+        self.qz = np.zeros(2)
+
+        self.addconfiguration("qz", self.qz)
+        self.addconfiguration("qb", self.qb)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Planar2()
+    print(robot)
+
+    # print(robot.fkine(robot.qz))

roboticstoolbox/models/ETS/Planar_Y.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ET import ET
+from roboticstoolbox.robot.ETS import ETS
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.robot.Link import Link
+
+
+class Planar_Y(Robot):
+    """
+    Create model of a branched planar manipulator::
+
+        L0 -- L1 -+- L2a -- L3a -- EEa
+                |
+                +- L2b -- L3b -- EEb
+
+    ``Planar_Y()`` creates a planar branched manipulator model.
+
+
+    :references:
+        - Kinematic Derivatives using the Elementary Transform
+          Sequence, J. Haviland and P. Corke
+
+    """
+
+    def __init__(self):
+
+        # deg = np.pi / 180
+        # mm = 1e-3
+        tool_offset = 1
+
+        # trunk of the tree
+        l0 = Link(ETS(ET.Rz()), name="link0", jindex=0, parent=None)
+
+        l1 = Link(ET.tx(1) * ET.Rz(), name="link1", jindex=1, parent=l0)
+
+        # branch 1
+        l2 = Link(ET.tx(1) * ET.Rz(), name="link2a", jindex=2, parent=l1)
+
+        l3 = Link(ET.tx(1) * ET.Rz(), name="link3a", jindex=3, parent=l2)
+
+        eea = Link(ETS(ET.tz(tool_offset)), name="eea", parent=l3)
+
+        # branch 2
+        l4 = Link(ET.tx(1) * ET.Rz(), name="link2b", jindex=4, parent=l1)
+
+        l5 = Link(ET.tx(1) * ET.Rz(), name="link3b", jindex=5, parent=l4)
+
+        eeb = Link(ETS(ET.tz(tool_offset)), name="eeb", parent=l5)
+
+        elinks = [l0, l1, l2, l3, l4, l5, eea, eeb]
+
+        super().__init__(elinks, name="Planar-Y")
+
+        self.qr = np.array([0, 0, np.pi / 4, 0, -np.pi / 4, 0])
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Planar_Y()
+    print(robot)