roboticstoolbox-python 1.4.0__py3-none-any.whl

roboticstoolbox/models/URDF/YuMi.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+
+from roboticstoolbox.robot.Link import Link
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.models.URDF.URDFRobot import URDF_read
+import spatialmath as sm
+
+
+class YuMi(Robot):
+    """
+    Class that imports an ABB YuMi URDF model
+
+    ``YuMi()`` is a class which imports an ABB YuMi (IRB14000) robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.YuMi()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - `https://github.com/OrebroUniversity/yumi <https://github.com/OrebroUniversity/yumi>`_
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_filepath = URDF_read("yumi")
+
+        # We wish to add an intermediate link between gripper_r_base and
+        # @gripper_r_finger_r/l
+        # This is because gripper_r_base contains a revolute joint which is
+        # a part of the core kinematic chain and not the gripper.
+        # So we wish for gripper_r_base to be part of the robot and
+        # @gripper_r_finger_r/l to be in the gripper underneath a parent Link
+
+        gripper_r_base = links[16]
+        gripper_l_base = links[19]
+
+        # Find the finger links
+        r_gripper_links = [link for link in links if link.parent == gripper_r_base]
+        l_gripper_links = [link for link in links if link.parent == gripper_l_base]
+
+        # New intermediate links
+        r_gripper = Link(name="r_gripper", parent=gripper_l_base)
+        l_gripper = Link(name="l_gripper", parent=gripper_r_base)
+        links.append(r_gripper)
+        links.append(l_gripper)
+
+        # Set the finger link parent to be the new gripper base link
+        for g_link in r_gripper_links:
+            g_link._parent = r_gripper
+
+        for g_link in l_gripper_links:
+            g_link._parent = l_gripper
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="ABB",
+            gripper_links=[r_gripper, l_gripper],
+        )
+        self._urdf_filepath = str(urdf_filepath) if urdf_filepath is not None else ""
+
+        # Set the default tool transform for the end-effectors
+        self.grippers[0].tool = sm.SE3.Tz(0.13)
+        self.grippers[1].tool = sm.SE3.Tz(0.13)
+
+        self.qr = np.array(
+            [
+                0,
+                -0.3,
+                0,
+                -2.2,
+                0,
+                2.0,
+                np.pi / 4,
+                0,
+                -0.3,
+                0,
+                -2.2,
+                0,
+                2.0,
+                np.pi / 4,
+            ]
+        )
+        self.qz = np.zeros(14)
+        self.q1 = np.array([0, -0.4, 0, 0, 0, 0, 0, 0, -0.4, 0, 0, 0, 0, 0])
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+        self.addconfiguration("q1", self.q1)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = YuMi()
+    print(robot)

roboticstoolbox/models/URDF/__init__.py

@@ -0,0 +1,51 @@
+from roboticstoolbox.models.URDF.Panda import Panda
+from roboticstoolbox.models.URDF.Frankie import Frankie
+from roboticstoolbox.models.URDF.FrankieOmni import FrankieOmni
+from roboticstoolbox.models.URDF.UR3 import UR3
+from roboticstoolbox.models.URDF.UR5 import UR5
+from roboticstoolbox.models.URDF.UR10 import UR10
+from roboticstoolbox.models.URDF.Puma560 import Puma560
+from roboticstoolbox.models.URDF.px100 import px100
+from roboticstoolbox.models.URDF.px150 import px150
+from roboticstoolbox.models.URDF.rx150 import rx150
+from roboticstoolbox.models.URDF.rx200 import rx200
+from roboticstoolbox.models.URDF.vx300 import vx300
+from roboticstoolbox.models.URDF.vx300s import vx300s
+from roboticstoolbox.models.URDF.wx200 import wx200
+from roboticstoolbox.models.URDF.wx250 import wx250
+from roboticstoolbox.models.URDF.wx250s import wx250s
+from roboticstoolbox.models.URDF.Jaco import Jaco
+from roboticstoolbox.models.URDF.PR2 import PR2
+from roboticstoolbox.models.URDF.LBR import LBR
+from roboticstoolbox.models.URDF.KinovaGen3 import KinovaGen3
+from roboticstoolbox.models.URDF.YuMi import YuMi
+from roboticstoolbox.models.URDF.Fetch import Fetch
+from roboticstoolbox.models.URDF.Valkyrie import Valkyrie
+from roboticstoolbox.models.URDF.AL5D import AL5D
+
+__all__ = [
+    "Panda",
+    "Frankie",
+    "FrankieOmni",
+    "UR3",
+    "UR5",
+    "UR10",
+    "Puma560",
+    "px100",
+    "px150",
+    "rx150",
+    "rx200",
+    "vx300",
+    "vx300s",
+    "wx200",
+    "wx250",
+    "wx250s",
+    "Jaco",
+    "PR2",
+    "LBR",
+    "KinovaGen3",
+    "YuMi",
+    "Fetch",
+    "Valkyrie",
+    "AL5D",
+]

roboticstoolbox/models/URDF/px100.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class px100(URDFRobot):
+    """
+    Class that imports a PX100 URDF model
+
+    ``px100()`` is a class which imports an Interbotix px100 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.px100()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/px100.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/px100.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        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 = px100()
+    print(robot)

roboticstoolbox/models/URDF/px150.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class px150(URDFRobot):
+    """
+    Class that imports a PX150 URDF model
+
+    ``px150()`` is a class which imports an Interbotix px150 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.px150()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/px150.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/px150.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = px150()
+    print(robot)

roboticstoolbox/models/URDF/rx150.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class rx150(URDFRobot):
+    """
+    Class that imports a RX150 URDF model
+
+    ``rx150()`` is a class which imports an Interbotix rx150 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.rx150()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/rx150.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/rx150.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = rx150()
+    print(robot)

roboticstoolbox/models/URDF/rx200.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class rx200(URDFRobot):
+    """
+    Class that imports a RX200 URDF model
+
+    ``rx200()`` is a class which imports an Interbotix rx200 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.rx200()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/rx200.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/rx200.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = rx200()
+    print(robot)

roboticstoolbox/models/URDF/vx300.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class vx300(URDFRobot):
+    """
+    Class that imports a VX300 URDF model
+
+    ``vx300()`` is a class which imports an Interbotix vx300 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.vx300()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/vx300.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+        super().__init__(
+            "trossen_descriptions/urdf/vx300.urdf.xacro",
+            manufacturer="Interbotix",
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = vx300()
+    print(robot)

roboticstoolbox/models/URDF/vx300s.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class vx300s(URDFRobot):
+    """
+    Class that imports a VX300s URDF model
+
+    ``vx300s()`` is a class which imports an Interbotix vx300s robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.vx300s()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/vx300s.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/vx300s.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0, 0])
+        self.qz = np.zeros(9)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = vx300s()
+    print(robot)

roboticstoolbox/models/URDF/wx200.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class wx200(URDFRobot):
+    """
+    Class that imports a WX200 URDF model
+
+    ``wx200()`` is a class which imports an Interbotix wx200 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.wx200()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/wx200.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/wx200.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = wx200()
+    print(robot)

roboticstoolbox/models/URDF/wx250.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class wx250(URDFRobot):
+    """
+    Class that imports a WX250 URDF model
+
+    ``wx250()`` is a class which imports an Interbotix wx250 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.wx250()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/wx250.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/wx250.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = wx250()
+    print(robot)

roboticstoolbox/models/URDF/wx250s.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.models.URDF.URDFRobot import URDFRobot
+
+
+class wx250s(URDFRobot):
+    """
+    Class that imports a wx250s URDF model
+
+    ``wx250s()`` is a class which imports an Interbotix wx250s robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.wx250s()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/wx250s.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        super().__init__(
+            "trossen_descriptions/urdf/wx250s.urdf.xacro", manufacturer="Interbotix"
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0, 0])
+        self.qz = np.zeros(9)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = wx250s()
+    print(robot)

roboticstoolbox/models/__init__.py

@@ -0,0 +1,7 @@
+from roboticstoolbox.models.URDF import *  # noqa
+from roboticstoolbox.models import ETS  # noqa
+from roboticstoolbox.models import DH  # noqa
+from roboticstoolbox.models.catalog import catalog, list
+
+
+__all__ = ["catalog", "list", "ETS", "DH"]