roboticstoolbox-python 1.3.0__cp313-cp313-win_amd64.whl

roboticstoolbox/models/ETS/Puma560.py

@@ -0,0 +1,69 @@
+from roboticstoolbox import ET as ET
+from roboticstoolbox import Robot
+import numpy as np
+
+
+class Puma560(Robot):
+    """
+    Create model of Franka-Emika Panda manipulator
+
+    ``puma = Puma560()`` creates a robot object representing the classic
+    Unimation Puma560 robot arm. This robot is represented using the elementary
+    transform sequence (ETS).
+
+    .. note::
+
+        - The model has different joint offset conventions compared to
+          ``DH.Puma560()``. For this robot:
+            - Zero joint angles ``qz`` is the vertical configuration,
+              corresponding to ``qr`` with ``DH.Puma560()``
+            - ``qbent`` is the bent configuration, corresponding to
+              ``qz`` with ``DH.Puma560()``
+
+    :references:
+        - "A Simple and Systematic Approach to Assigning Denavit–Hartenberg
+          Parameters,", P. I. Corke,  in IEEE Transactions on Robotics, vol. 23,
+          no. 3, pp. 590-594, June 2007, doi: 10.1109/TRO.2007.896765.
+        - https://petercorke.com/robotics/a-simple-and-systematic-approach-to-assigning-denavit-hartenberg-parameters
+
+    """  # noqa
+
+    def __init__(self):
+        # Puma dimensions (m)
+        l1 = 0.672
+        l2 = -0.2337
+        l3 = 0.4318
+        l4 = 0.0203
+        l5 = 0.0837
+        l6 = 0.4318
+
+        e = (
+            ET.tz(l1)
+            * ET.Rz()
+            * ET.ty(l2)
+            * ET.Ry()
+            * ET.tz(l3)
+            * ET.tx(l4)
+            * ET.ty(l5)
+            * ET.Ry()
+            * ET.tz(l6)
+            * ET.Rz()
+            * ET.Ry()
+            * ET.Rz()
+            * ET.tx(0.2)
+        )
+
+        super().__init__(
+            e, name="Puma560", manufacturer="Unimation", comment="ETS-based model"
+        )
+
+        self.qr = np.array([0, -np.pi / 2, np.pi / 2, 0, 0, 0])
+        self.qz = np.zeros(6)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Puma560()
+    print(robot)

roboticstoolbox/models/ETS/XYPanda.py

@@ -0,0 +1,84 @@
+#!/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 XYPanda(Robot):
+    """
+    Create model of Franka-Emika Panda manipulator on an XY platform
+
+    xypanda = XYPanda() creates a robot object representing the Franka-Emika
+    Panda robot arm mounted on an XY platform. 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, workspace=5):
+        """
+        Create model of Franka-Emika Panda manipulator on an XY platform.
+
+        :param workspace: workspace limits in the x and y directions, defaults to 5
+        :type workspace: float, optional
+
+        The XY part of the robot has a range -``workspace`` to ``workspace``.
+        """
+
+        deg = np.pi / 180
+        mm = 1e-3
+        tool_offset = (103) * mm
+
+        lx = Link(
+            ETS(ET.tx()), name="link-x", parent=None, qlim=[-workspace, workspace]
+        )
+
+        ly = Link(ETS(ET.ty()), name="link-y", parent=lx, qlim=[-workspace, workspace])
+
+        l0 = Link(ET.tz(0.333) * ET.Rz(), name="link0", parent=ly)
+
+        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 = [lx, ly, l0, l1, l2, l3, l4, l5, l6, ee]
+
+        super().__init__(elinks, name="XYPanda", manufacturer="Franka Emika")
+
+        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 = XYPanda()
+    print(robot)

roboticstoolbox/models/ETS/__init__.py

@@ -0,0 +1,20 @@
+from roboticstoolbox.models.ETS.Panda import Panda
+from roboticstoolbox.models.ETS.Frankie import Frankie
+from roboticstoolbox.models.ETS.Puma560 import Puma560
+from roboticstoolbox.models.ETS.Planar_Y import Planar_Y
+from roboticstoolbox.models.ETS.Planar2 import Planar2
+from roboticstoolbox.models.ETS.GenericSeven import GenericSeven
+
+# from roboticstoolbox.models.ETS.Omni import Omni
+from roboticstoolbox.models.ETS.XYPanda import XYPanda
+
+
+__all__ = [
+    "Panda",
+    "Frankie",
+    "Puma560",
+    "Planar_Y",
+    "Planar2",
+    "GenericSeven",
+    "XYPanda",
+]  # , "Omni"]

roboticstoolbox/models/README.md

@@ -0,0 +1,9 @@
+The Toolbox supports three types of model. Each is represented by a distinct class which inherits from the abstract `Robot` superclass.
+
+* [Denavit-Hartenberg (DH) models](https://github.com/petercorke/robotics-toolbox-python/tree/master/roboticstoolbox/models/DH). These are defined using standard or modified DH parameters, with optional 3D meshes for visualisation and optional dynamic parameters.
+* [ETS models](https://github.com/petercorke/robotics-toolbox-python/tree/master/roboticstoolbox/models/ETS). There are defined using a sequence of elementary transformations (rotation and translations), and is a quick and intuitive way to describe a robot, see [this article](https://petercorke.com/robotics/a-simple-and-systematic-approach-to-assigning-denavit-hartenberg-parameters/).
+* [URDF models](https://github.com/petercorke/robotics-toolbox-python/tree/master/roboticstoolbox/models/URDF). These models are defined by a Unified Robot Description Format file, an XML format file. Models exist for the classic Puma560 robot as well as the Franka-Emika Panda, the Universal robotics range and all the Interbotix hobby-class robots.
+
+In each folder you will find a README describing how to create your own model.
+
+If you think your model might be interesting to others consider submitting a pull request.

roboticstoolbox/models/URDF/AL5D.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+from math import pi
+
+
+class AL5D(Robot):
+    """
+    Class that imports a AL5D URDF model
+
+    ``AL5D()`` is a class which imports a Lynxmotion AL5D robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.AL5D()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - up, robot poiting upwards
+
+    .. codeauthor:: Tassos Natsakis
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "al5d_description/urdf/al5d_robot.urdf"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.manufacturer = "Lynxmotion"
+
+        # zero angles, upper arm pointing up, lower arm straight ahead
+        self.addconfiguration("qz", np.array([0, 0, 0, 0]))
+
+        # reference pose robot pointing upwards
+        self.addconfiguration("up", np.array([0.0000, 0.0000, 1.5707, 0.0000]))
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = AL5D()
+    print(robot)

roboticstoolbox/models/URDF/Fetch.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+# from spatialmath import SE3
+
+
+class Fetch(Robot):
+    """
+    Class that imports a Fetch URDF model
+
+    ``Fetch()`` is a class which imports a Fetch robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.Fetch()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, arm is stretched out in the x-direction
+    - qr, tucked arm configuration
+
+    .. codeauthor:: Kerry He
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "fetch_description/robots/fetch.urdf"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Fetch",
+            gripper_links=links[11],
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qdlim = np.array([4.0, 4.0, 0.1, 1.25, 1.45, 1.57, 1.52, 1.57, 2.26, 2.26])
+
+        self.qz = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+        self.qr = np.array([0, 0, 0.05, 1.32, 1.4, -0.2, 1.72, 0, 1.66, 0])
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = Fetch()
+    print(robot)
+
+    for link in robot.links:
+        print(link.name)
+        print(link.isjoint)
+        print(len(link.collision))
+
+    print()
+
+    for link in robot.grippers[0].links:
+        print(link.name)
+        print(link.isjoint)
+        print(len(link.collision))

roboticstoolbox/models/URDF/FetchCamera.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+# from spatialmath import SE3
+
+
+class FetchCamera(Robot):
+    """
+    Class that imports a FetchCamera URDF model
+
+    ``FetchCamera()`` is a class which imports a FetchCamera robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.Fetch()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+    - qr, zero joint angle configuration
+
+    .. codeauthor:: Kerry He
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "fetch_description/robots/fetch_camera.urdf"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Fetch",
+            gripper_links=links[6],
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        # self.grippers[0].tool = SE3(0, 0, 0.1034)
+        self.qdlim = np.array([4.0, 4.0, 0.1, 1.57, 1.57])
+
+        self.qz = np.array([0, 0, 0, 0, 0])
+        self.qr = np.array([0, 0, 0, 0, 0])
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = FetchCamera()
+    print(robot)
+
+    for link in robot.links:
+        print(link.name)
+        print(link.isjoint)
+        print(len(link.collision))
+
+    print()
+
+    for link in robot.grippers[0].links:
+        print(link.name)
+        print(link.isjoint)
+        print(len(link.collision))

roboticstoolbox/models/URDF/Frankie.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+from spatialmath import SE3
+
+
+class Frankie(Robot):
+    """
+    Class that imports a Frankie URDF model
+
+    ``Frankie()`` is a class which imports a Frankie robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.Frankie()
+        >>> 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
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "franka_description/robots/frankie_arm_hand.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Franka Emika",
+            gripper_links=links[12],
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.grippers[0].tool = SE3(0, 0, 0.1034)
+
+        self.qdlim = np.array(
+            [4.0, 4.0, 2.1750, 2.1750, 2.1750, 2.1750, 2.6100, 2.6100, 2.6100, 3.0, 3.0]
+        )
+
+        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)
+
+    for link in robot.links:
+        print(link.name)
+        print(link.isjoint)
+        print(len(link.collision))
+
+    print()
+
+    for link in robot.grippers[0].links:
+        print(link.name)
+        print(link.isjoint)
+        print(len(link.collision))

roboticstoolbox/models/URDF/FrankieOmni.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.robot.Link import Link
+from roboticstoolbox.robot.ETS import ETS
+from roboticstoolbox.robot.ET import ET
+from spatialmath import SE3
+
+
+class FrankieOmni(Robot):
+    """
+    Class that imports an Omnidirectional Frankie URDF model
+
+    ``FrankieOmni()`` is a class which imports a FrankieOmni robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.FrankieOmni()
+        >>> 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
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links_base, _, urdf_string, urdf_filepath = self.URDF_read(
+            "ridgeback_description/urdf/ridgeback.urdf.xacro"
+        )
+
+        links_panda, _, _, _ = self.URDF_read(
+            "franka_description/robots/panda_arm_hand.urdf.xacro"
+        )
+
+        base_link = links_base[9]
+        base_arm = Link(ETS(ET.tz(0.28)), name="base_arm", parent=base_link)
+
+        links_panda[0]._parent = base_arm
+        links_all = links_base + links_panda
+        links_all.append(base_arm)
+
+        super().__init__(
+            links_all,
+            name="FrankieOmni",
+            manufacturer="Custom",
+            gripper_links=links_all[28],
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.grippers[0].tool = SE3(0, 0, 0.1034)
+
+        self.qdlim = np.array(
+            [
+                4.0,
+                4.0,
+                4.0,
+                2.1750,
+                2.1750,
+                2.1750,
+                2.1750,
+                2.6100,
+                2.6100,
+                2.6100,
+                3.0,
+                3.0,
+            ]
+        )
+
+        self.qr = np.array([0, 0, 0, 0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4])
+        self.qz = np.zeros(10)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    pass
+
+    # r = Panda()
+
+    # for link in r.grippers[0].links:
+    #     print(link)

roboticstoolbox/models/URDF/KinovaGen3.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class KinovaGen3(Robot):
+    """
+    Class that imports a KinovaGen3 URDF model
+
+    ``KinovaGen3()`` is a class which imports a KinovaGen3 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.KinovaGen3()
+        >>> 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
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "kortex_description/robots/gen3.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Kinova",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+            gripper_links=links[10],
+        )
+
+        # self.qdlim = np.array([
+        # 2.1750, 2.1750, 2.1750, 2.1750, 2.6100, 2.6100, 2.6100, 3.0, 3.0])
+
+        self.qr = np.deg2rad([0.0, 15.0, 180.0, 230.0, 0.0, 55.0, 90.0])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = KinovaGen3()
+    robot.q = robot.qr
+    print(robot)
+
+    from swift import Swift
+
+    env = Swift()
+    env.launch()
+    env.add(robot)
+    env.hold()
+
+    for link in robot.links:
+        print("\n")
+        print(link.isjoint)

roboticstoolbox/models/URDF/LBR.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class LBR(Robot):
+    """
+    Class that imports a LBR URDF model
+
+    ``LBR()`` is a class which imports a Franka-Emika LBR robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.LBR()
+        >>> 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
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "kuka_description/kuka_lbr_iiwa/urdf/lbr_iiwa_14_r820.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Kuka",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+            # gripper_links=elinks[9]
+        )
+
+        # self.qdlim = np.array([
+        #     2.1750, 2.1750, 2.1750, 2.1750, 2.6100, 2.6100, 2.6100, 3.0, 3.0])
+
+        self.qr = np.array([0, -0.3, 0, -1.9, 0, 1.5, np.pi / 4])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = LBR()
+    print(robot)