roboticstoolbox-python 1.3.0__cp312-cp312-win_amd64.whl

roboticstoolbox/models/DH/AL5D.py

@@ -0,0 +1,121 @@
+"""
+@author: Tassos Natsakis
+"""
+
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteMDH
+from spatialmath import SE3
+
+
+class AL5D(DHRobot):
+    """
+    Class that models a Lynxmotion AL5D manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``AL5D()`` is an object which models a Lynxmotion AL5D robot and
+    describes its kinematic and dynamic characteristics using modified DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.AL5D()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+
+    .. note::
+        - SI units are used.
+
+    :References:
+
+        - 'Reference of the robot <http://www.lynxmotion.com/c-130-al5d.aspx>'_
+
+    .. codeauthor:: Tassos Natsakis
+    """  # 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
+
+        # robot length values (metres)
+        a = [0, 0.002, 0.14679, 0.17751]
+        d = [-0.06858, 0, 0, 0]
+
+        alpha = [pi, pi / 2, pi, pi]
+        offset = [pi / 2, pi, -0.0427, -0.0427 - pi / 2]
+
+        # mass data as measured
+        # mass = [0.187, 0.044, 0.207, 0.081]
+
+        # center of mass as calculated through CAD model
+        center_of_mass = [
+            [0.01724, -0.00389, 0.00468],
+            [0.07084, 0.00000, 0.00190],
+            [0.05615, -0.00251, -0.00080],
+            [0.04318, 0.00735, -0.00523],
+        ]
+
+        # moments of inertia are practically zero
+        moments_of_inertia = [
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0],
+        ]
+
+        joint_limits = [
+            [-pi / 2, pi / 2],
+            [-pi / 2, pi / 2],
+            [-pi / 2, pi / 2],
+            [-pi / 2, pi / 2],
+        ]
+
+        links = []
+
+        for j in range(3):
+            link = RevoluteMDH(
+                d=d[j],
+                a=a[j],
+                alpha=alpha[j],
+                offset=offset[j],
+                r=center_of_mass[j],
+                I=moments_of_inertia[j],
+                G=1,
+                B=0,
+                Tc=[0, 0],
+                qlim=joint_limits[j],
+            )
+            links.append(link)
+
+        tool = SE3(0.07719, 0, 0)
+
+        super().__init__(
+            links,
+            name="AL5D",
+            manufacturer="Lynxmotion",
+            keywords=("dynamics", "symbolic"),
+            symbolic=symbolic,
+            tool=tool,
+        )
+
+        # zero angles
+        self.addconfiguration("home", np.array([pi / 2, pi / 2, pi / 2, pi / 2]))
+
+
+if __name__ == "__main__":  # pragma nocover
+    al5d = AL5D(symbolic=False)
+    print(al5d)
+    # print(al5d.dyntable())

roboticstoolbox/models/DH/Ball.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+@author: Samuel Drew
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH
+from math import pi
+import numpy as np
+
+
+class Ball(DHRobot):
+    """
+    Class that models a ball manipulator
+
+    :param N: number of links, defaults to 10
+    :type N: int, optional
+    :param symbolic: [description], defaults to False
+    :type symbolic: bool, optional
+
+    The ball robot is an *abstract* robot with an arbitrary number of joints.
+    At zero joint angles it is straight along the x-axis, and as the joint
+    angles are increased (equally) it wraps up into a 3D ball shape.
+
+    - ``Ball()`` is an object which describes the kinematic characteristics of
+      a ball robot using standard DH conventions.
+
+    - ``Ball(N)`` as above, but models a robot with ``N`` joints.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Ball()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+        - qz, zero joint angles
+        - q1, ball shaped configuration
+
+    :references:
+
+        - "A divide and conquer articulated-body algorithm for parallel
+          O(log(n)) calculation of rigid body dynamics, Part 2",
+          Int. J. Robotics Research, 18(9), pp 876-892.
+
+    :seealso: :func:`Hyper`, :func:`Ball`
+
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self, N=10):
+
+        links = []
+        q1 = []
+
+        for i in range(N):
+            links.append(RevoluteDH(a=0.1, alpha=pi / 2))
+
+        # and build a serial link manipulator
+        super(Ball, self).__init__(links, name="ball")
+
+        self.qr = np.array([_fract(i) for i in range(N)])
+        self.qz = np.zeros(N)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+def _fract(i):
+    # i is "i-1" as per the paper
+    theta1 = 1
+    theta2 = -2 / 3
+
+    if i == 0:
+        return theta1
+    elif i % 3 == 1:
+        return theta1
+    elif i % 3 == 2:
+        return theta2
+    elif i % 3 == 0:
+        return _fract(i / 3)
+
+
+if __name__ == "__main__":  # pragma nocover
+    ball = Ball()
+    print(ball)

roboticstoolbox/models/DH/Baxter.py

@@ -0,0 +1,91 @@
+import numpy as np
+from math import pi
+from roboticstoolbox import DHRobot, RevoluteDH
+from spatialmath import SE3
+
+
+class Baxter(DHRobot):
+    """
+    Class that models a Baxter manipulator
+
+    :param symbolic: use symbolic constants
+    :type symbolic: bool
+
+    ``Baxter()`` is an object which models the left arm of the two 7-joint
+    arms of a Rethink Robotics Baxter robot using standard DH conventions.
+
+    ``Baxter(which)`` as above but models the specified arm and ``which`` is
+    either 'left' or 'right'.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Baxter()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+    - qr, vertical 'READY' configuration
+    - qs, arm is stretched out in the X direction
+    - qd, lower arm horizontal as per data sheet
+
+    .. note:: SI units are used.
+
+    .. warning:: The base transform is set to reflect the pose of the arm's
+        shoulder with respect to the base.  Changing the base attribute of the
+        arm will overwrite this, IT DOES NOT CHANGE THE POSE OF BAXTER's base.
+        Instead do ``baxter.base = newbase * baxter.base``.
+
+    :References:
+        - "Kinematics Modeling and Experimental Verification of Baxter Robot"
+          Z. Ju, C. Yang, H. Ma, Chinese Control Conf, 2015.
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self, arm="left"):
+
+        links = [
+            RevoluteDH(d=0.27, a=0.069, alpha=-pi / 2),
+            RevoluteDH(d=0, a=0, alpha=pi / 2, offset=pi / 2),
+            RevoluteDH(d=0.102 + 0.262, a=0.069, alpha=-pi / 2),
+            RevoluteDH(d=0, a=0, alpha=pi / 2),
+            RevoluteDH(d=0.103 + 0.271, a=0.010, alpha=-pi / 2),
+            RevoluteDH(d=0, a=0, alpha=pi / 2),
+            RevoluteDH(d=0.28, a=0, alpha=0),
+        ]
+
+        super().__init__(
+            links,
+            name=f"Baxter-{arm}",
+            manufacturer="Rethink Robotics",
+        )
+
+        self.qr = np.array([0, -pi / 2, -pi / 2, 0, 0, 0, 0])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+        # straight and horizontal
+        self.addconfiguration_attr("qs", np.array([0, 0, -pi / 2, 0, 0, 0, 0]))
+
+        # nominal table top picking pose
+        self.addconfiguration_attr("qn", np.array([0, pi / 4, pi / 2, 0, pi / 4, 0, 0]))
+
+        if arm == "left":
+            self.base = SE3(0.064614, 0.25858, 0.119) * SE3.Rz(pi / 4)
+        else:
+            self.base = SE3(0.063534, -0.25966, 0.119) * SE3.Rz(-pi / 4)
+
+
+if __name__ == "__main__":  # pragma nocover
+    baxter = Baxter("left")
+    print(baxter.name, baxter.base)
+    # baxter.plot(baxter.qz, block=False)
+
+    # baxter = Baxter('right')
+    # print(baxter)
+
+    # baxter.plot(baxter.qz)

roboticstoolbox/models/DH/Cobra600.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+@author: Samuel Drew
+"""
+
+from roboticstoolbox import DHRobot, RevoluteDH, PrismaticDH
+from math import pi
+import numpy as np
+
+
+class Cobra600(DHRobot):
+    """
+    Class that models a Adept Cobra 600 SCARA manipulator
+
+    ``Cobra600()`` is a class which models an Adept Cobra 600 SCARA robot and
+    describes its kinematic characteristics using standard DH
+    conventions.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Cobra600()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+
+    .. note::
+        - SI units are used.
+        - Robot has only 4 DoF.
+
+    .. codeauthor:: Peter Corke
+    """
+
+    def __init__(self):
+        deg = pi / 180
+
+        L = [
+            RevoluteDH(d=0.387, a=0.325, qlim=[-50 * deg, 50 * deg]),
+            RevoluteDH(a=0.275, alpha=pi, qlim=[-88 * deg, 88 * deg]),
+            PrismaticDH(qlim=[0, 0.210]),
+            RevoluteDH(),
+        ]
+
+        super().__init__(L, name="Cobra600", manufacturer="Omron")
+
+        # zero angles, L shaped pose
+        self.addconfiguration_attr("qz", np.array([0, 0, 0, 0]))
+
+        self.qr = np.zeros(4)
+        self.qz = np.zeros(4)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    deg = pi / 180
+    a = RevoluteDH(d=0.387, a=0.325, qlim=[-50 * deg, 50 * deg])
+    cobra = Cobra600()
+    print(cobra)

roboticstoolbox/models/DH/Coil.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+"""
+
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+
+
+class Coil(DHRobot):
+    """
+    Create model of a coil manipulator
+
+    :param N: number of links, defaults to 10
+    :type N: int, optional
+    :param symbolic: [description], defaults to False
+    :type symbolic: bool, optional
+
+    The coil robot is an *abstract* robot with an arbitrary number of joints
+    that folds into a helix shape.  At zero joint angles it is straight along
+    the x-axis, and as the joint angles are increased (equally) it wraps up into
+    a 3D helix shape.
+
+    - ``Coil()`` is an object which describes the kinematic characteristics of
+      a coil robot using standard DH conventions.
+
+    - ``Coil(N)`` as above, but models a robot with ``N`` joints.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Coil()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+
+    :references:
+        - "A divide and conquer articulated-body algorithm for parallel O(log(n))
+          calculation of rigid body dynamics, Part 2",
+          Int. J. Robotics Research, 18(9), pp 876-892.
+
+    :seealso: :func:`Hyper`, :func:`Ball`
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self, N=10, symbolic=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            pi = sym.pi()
+        else:
+            from math import pi
+
+        a = 1 / N
+
+        links = []
+        for i in range(N):
+            links.append(RevoluteDH(a=a, alpha=5 * pi / N))
+
+        super().__init__(
+            links, name="Coil" + str(N), keywords=("symbolic",), symbolic=symbolic
+        )
+
+        self.qr = np.array(np.ones(N) * 10 * pi / N)
+        self.qz = np.zeros(N)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    coil = Coil(N=10, symbolic=False)
+    print(coil)
+
+    # print(coil.fkine(coil.qz))
+    # print(coil.fkine(coil.qf))

roboticstoolbox/models/DH/Hyper.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+"""
+
+# from math import pi
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+
+
+class Hyper(DHRobot):
+    """
+    Create model of a hyper redundant planar manipulator
+
+    :param N: number of links, defaults to 10
+    :type N: int, optional
+    :param a: link length, defaults total ``1/N`` giving a reach of 1
+    :type a: int or symbolic, optional
+    :param symbolic: [description], defaults to False
+    :type symbolic: bool, optional
+
+    - ``Hyper()`` is an object which describes the kinematics of a serial link
+      manipulator with 10 joints which moves in the xy-plane, using standard DH
+      conventions. At zero angles it forms a straight line along the x-axis.
+
+    - ``Hyper(N)`` as above, but models a robot with ``N`` joints.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Hyper()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+
+    :References:
+
+      - "A divide and conquer articulated-body algorithm for parallel O(log(n))
+      calculation of rigid body dynamics, Part 2",
+      Int. J. Robotics Research, 18(9), pp 876-892.
+
+    :seealso: :func:`Coil`, :func:`Ball`
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self, N=10, a=None, symbolic=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            zero = sym.zero()
+            pi = sym.pi()
+        else:
+            from math import pi
+
+            zero = 0.0
+
+        if a is None:
+            a = 1 / N
+
+        links = []
+        for i in range(N):
+            links.append(RevoluteDH(a=a, alpha=zero))
+
+        super().__init__(
+            links, name="Hyper" + str(N), keywords=("symbolic",), symbolic=symbolic
+        )
+
+        self.qr = np.array(N)
+        self.qz = np.zeros(N)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    hyper = Hyper(N=10, symbolic=False)
+    print(hyper)
+
+    # print(hyper.fkine(hyper.qz))

roboticstoolbox/models/DH/Hyper3d.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""
+@author: Peter Corke
+"""
+
+# from math import pi
+import numpy as np
+from roboticstoolbox import DHRobot, RevoluteDH
+
+
+class Hyper3d(DHRobot):
+    """
+    Create model of a hyper redundant manipulator
+
+    :param N: number of links, defaults to 10
+    :type N: int, optional
+    :param a: link length, defaults total ``1/N`` giving a reach of 1
+    :type a: int or symbolic, optional
+    :param symbolic: [description], defaults to False
+    :type symbolic: bool, optional
+
+    - ``Hyper3d()`` is an object which describes the kinematics of a serial link
+      manipulator with 10 joints which moves in the xy-plane, using standard DH
+      conventions. At zero angles it forms a straight line along the x-axis.
+
+    - ``Hyper3d(N)`` as above, but models a robot with ``N`` joints.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.DH.Hyper3d()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration
+
+    :References:
+
+      - "A divide and conquer articulated-body algorithm for parallel O(log(n))
+      calculation of rigid body dynamics, Part 2",
+      Int. J. Robotics Research, 18(9), pp 876-892.
+
+    :seealso: :func:`Coil`, :func:`Ball`
+
+    .. codeauthor:: Peter Corke
+    """  # noqa
+
+    def __init__(self, N=10, a=None, symbolic=False):
+
+        if symbolic:
+            import spatialmath.base.symbolic as sym
+
+            # zero = sym.zero()
+            pi = sym.pi()
+        else:
+            from math import pi
+
+            # zero = 0.0
+
+        if a is None:
+            a = 1 / N
+
+        links = []
+        for i in range(N):
+            links.append(RevoluteDH(a=a, alpha=pi / 2))
+
+        super().__init__(
+            links, name="Hyper3d" + str(N), keywords=("symbolic",), symbolic=symbolic
+        )
+
+        self.qr = np.array(N)
+        self.qz = np.zeros(N)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    hyper = Hyper3d(N=10, symbolic=False)
+    print(hyper)
+
+    # hyper.plot([2]*10, block=True)
+
+    # print(hyper.fkine(hyper.qz))