merge with updates

Author: Rhys

.github/workflows/future_testing.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        python-version: [3.6, 3.7, 3.8, 3.9]
+        python-version: [3.7, 3.8, 3.9]
 
     steps:
     - name: Set up Python ${{ matrix.python-version }}

.github/workflows/pythonpackage.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        python-version: [3.6, 3.7, 3.8, 3.9]
+        python-version: [3.7, 3.8, 3.9]
     steps:
     - uses: actions/checkout@v2
     - name: Set up Python ${{ matrix.python-version }}

roboticstoolbox/models/DH/AL5D.py

@@ -0,0 +1,118 @@
+"""
+@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(4):
+            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/Panda.py

@@ -46,49 +46,70 @@ def __init__(self):
                 a=0.0,
                 d=0.333,
                 alpha=0.0,
-                qlim=np.array([-2.8973, 2.8973])
+                qlim=np.array([-2.8973, 2.8973]),
+	            m=4.970684,
+                I = [7.03370e-01,  7.06610e-01,  9.11700e-03,-1.39000e-04,  1.91690e-02, 6.77200e-03],
+                G= 1
             ),
 
             RevoluteMDH(
                 a=0.0,
                 d=0.0,
                 alpha=-np.pi/2,
-                qlim=np.array([-1.7628, 1.7628])
+                qlim=np.array([-1.7628, 1.7628]),
+	            m= 0.646926,
+                I = [7.96200e-03,  2.81100e-02,  2.59950e-02, -3.92500e-03,  7.04000e-04,  1.02540e-02],
+                G= 1
             ),
 
             RevoluteMDH(
                 a=0.0,
                 d=0.316,
                 alpha=np.pi/2,
-                qlim=np.array([-2.8973, 2.8973])
+                qlim=np.array([-2.8973, 2.8973]),
+	            m= 3.228604,
+                I = [3.72420e-02,  3.61550e-02,  1.08300e-02, -4.76100e-03, -1.28050e-02, -1.13960e-02],
+                G= 1
             ),
 
             RevoluteMDH(
                 a=0.0825,
                 d=0.0,
                 alpha=np.pi/2,
-                qlim=np.array([-3.0718, -0.0698])
+                qlim=np.array([-3.0718, -0.0698]),
+	            m= 3.587895,
+                I =[2.58530e-02,  1.95520e-02,  2.83230e-02, 7.79600e-03,  8.64100e-03, -1.33200e-03],
+                G= 1
             ),
 
             RevoluteMDH(
                 a=-0.0825,
                 d=0.384,
                 alpha=-np.pi/2,
-                qlim=np.array([-2.8973, 2.8973])
+                qlim=np.array([-2.8973, 2.8973]),
+	            m= 1.225946,
+                I =  [3.55490e-02,  2.94740e-02,  8.62700e-03, -2.11700e-03,  2.29000e-04, -4.03700e-03],
+                G= 1
             ),
 
             RevoluteMDH(
                 a=0.0,
                 d=0.0,
                 alpha=np.pi/2,
-                qlim=np.array([-0.0175, 3.7525])
+                qlim=np.array([-0.0175, 3.7525]),
+	            m= 1.666555,
+                I = [1.96400e-03,  4.35400e-03,  5.43300e-03,  1.09000e-04, 3.41000e-04, -1.15800e-03],
+                G= 1
             ),
 
             RevoluteMDH(
                 a=0.088,
                 d=flange,
                 alpha=np.pi/2,
-                qlim=np.array([-2.8973, 2.8973])
+                qlim=np.array([-2.8973, 2.8973]),
+	            m=7.35522e-01,
+                I = [1.25160e-02,  1.00270e-02,  4.81500e-03, -4.28000e-04, -7.41000e-04, -1.19600e-03],
+                G= 1
             )
         ]
 

roboticstoolbox/models/DH/__init__.py

@@ -21,6 +21,7 @@
 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__ = [
@@ -47,4 +48,5 @@
     'Baxter',
     'TwoLink',
     'P8',
+    'AL5D',
 ]

roboticstoolbox/models/URDF/AL5D.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.ERobot import ERobot
+from math import pi
+
+class AL5D(ERobot):
+    """
+    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/__init__.py

@@ -21,6 +21,7 @@
 from roboticstoolbox.models.URDF.YuMi import YuMi
 from roboticstoolbox.models.URDF.Fetch import Fetch
 from roboticstoolbox.models.URDF.FetchCamera import FetchCamera
+from roboticstoolbox.models.URDF.AL5D import AL5D
 
 __all__ = [
     "Panda",
@@ -46,4 +47,5 @@
     "YuMi",
     "Fetch",
     "FetchCamera",
+    "AL5D",
 ]