roboticstoolbox-python 1.4.0__py3-none-any.whl

roboticstoolbox/models/ETS/Frankie.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.ets.ET import ET
+from roboticstoolbox.ets.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.ets.ET import ET
+from roboticstoolbox.ets.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.ets.ET import ET
+from roboticstoolbox.ets.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.ets.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.ets.ET2 import ET2
+from roboticstoolbox.ets.ETS2 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.ets.ET import ET
+from roboticstoolbox.ets.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)

roboticstoolbox/models/ETS/Puma560.py

@@ -0,0 +1,70 @@
+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.ets.ET import ET
+from roboticstoolbox.ets.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,45 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+from math import pi
+
+
+class AL5D(URDFRobot):
+    """
+    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):
+        super().__init__(
+            "lynxmotion_al5d_description/urdf/al5d_robot.urdf",
+            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)