Elementary transforms are canonic rotations or translations about, or along,

the x-, y- or z-axes. The amount of rotation or translation can be a constant

or a variable. A variable amount corresponds to a joint.

Consider the example:

:linenos:

>>> from roboticstoolbox import ETS

>>> ETS.rx(45, 'deg')

>>> ETS.tz(0.75)

>>> e = ETS.rx(0.3) * ETS.tz(0.75)

>>> print(e)

>>> e.eval()

In lines 2-5 we defined two elementary transforms. Line 2 defines a rotation

of 45° about the x-axis, and line 4 defines a translation of 0.75m along the z-axis.

Compounding them in line 6, the result is the two elementary transforms in a

sequence - an elementary transform sequence (ETS). An ETS can be arbitrarily

long.

Line 8 *evaluates* the sequence, substituting in values, and the result is an

SE(3) matrix encapsulated in an ``SE3`` object.

The real power comes from having variable arguments to the elementary transforms

as shown in this example where we define a simple two link planar manipulator.

.. runblock:: pycon

:linenos:

>>> from roboticstoolbox import ETS

>>> e = ETS.rz() * ETS.tx(1) * ETS.rz() * ETS.tx(1)

>>> print(e)

>>> len(e)

>>> e[1:3]

>>> e.eval([0, 0])

>>> e.eval([90, -90], 'deg')

Line 2 succinctly describes the kinematics in terms of elementary transforms: a rotation around the z-axis by the

first joint angle, then a translation in the x-direction, then a rotation around

the z-axis by the second joint angle, and finally a translation in the

x-direction.

Line 3 creates the elementary transform sequence, with variable transforms.

``e`` is a single object that encapsulates a list of elementary transforms, and list like

methods such as ``len`` as well as indexing and slicing as shown in lines 5-8.

Lines 9-18 *evaluate* the sequence, and substitutes elements from the passed

arrays as the joint variables.

This approach is general enough to be able to describe any serial-link robot

manipulator. For a branched manipulator we can use ETS to describe the

connections between every parent and child link pair.

**Reference:**

- `A simple and systematic approach to assigning Denavit-Hartenberg parameters <https://petercorke.com/robotics/a-simple-and-systematic-approach-to-assigning-denavit-hartenberg-parameters>`_.

Peter I. Corke, IEEE Transactions on Robotics, 23(3), pp 590-594, June 2007.

.. autoclass:: roboticstoolbox.robot.ETS.ETS

:members: rx, ry, rz, tx, ty, tz, eta, eval, T, joints, axis, jtype, config, __getitem__, __mul__, __repr__, __str__

.. autoclass:: roboticstoolbox.robot.ETS2.ETS

:members: rx, ry, rz, tx, ty, tz, eta, eval, T, joints, axis, jtype, config, __getitem__, __mul__, __repr__, __str__

ETS Robot models

A number of models are defined in terms of elementary transform sequences.

They can be listed by:

.. runblock:: pycon

>>> import roboticstoolbox as rtb

>>> rtb.models.list(mtype="ETS")

keywords=('dynamics', 'symbolic', 'mesh'),

ETS.tz(0.333) * ETS.rz(),

ETS.rx(-90*deg) * ETS.rz(),

ETS.rx(90*deg) * ETS.tz(0.316) * ETS.rz(),

ETS.tx(0.0825) * ETS.rx(90, 'deg') * ETS.rz(),

ETS.tx(-0.0825) * ETS.rx(-90, 'deg') * ETS.tz(0.384) * ETS.rz(),

ETS.rx(90, 'deg') * ETS.rz(),

ETS.tx(0.088) * ETS.rx(90, 'deg') * ETS.tz(0.107) * ETS.rz(),

print(robot.n, robot.M)

print(robot.elinks)

print(robot.q_idx)

for link in robot:

print(link.name, link)

print(link.ets, link.v, link.isjoint)

print(link.parent, link.child)

print(link.Ts)

print(link.geometry, link.collision)

print()

from ansitable import ANSITable, Column

table = ANSITable(

Column("link"),

Column("parent"),

Column("ETS", headalign="^", colalign="<"),

border="thin")

for link in robot:

if link.isjoint:

color = ""

else:

color = "<<blue>>"

table.row(color + link.name,

link.parent.name if link.parent is not None else "-",

link.ets * link.v if link.v is not None else link.ets)

table.print()

from roboticstoolbox import ETS as ET

from roboticstoolbox import ERobot

l1 = 0.672

l2 = 0.2337

l3 = 0.4318

l4 = -0.0837

l5 = 0.4318

l6 = 0.0203

e = ET.tz(l1) * ET.rz() * ET.ty(l2) * ET.ry() * ET.tz(l3) * ET.tx(l6) * \

ET.ty(l4) * ET.ry() * ET.tz(l5) * ET.rz() * ET.ry() * ET.rz() * ET.tx(0.2)

robot = ERobot(e, name="my first ERobot")

print(robot)

return "<<red>>" + str(theta)

return str(theta * deg) + "\u00b0"

has_qlim = any([link._qlim is not None for link in self])

if has_qlim:

qlim_columns = [

Column("q⁻", headalign="^"), Column("q⁺", headalign="^"),

]

qlim = self.qlim

else:

qlim_columns = []

# MDH format

*qlim_columns,

if has_qlim:

if L.isprismatic():

ql = [qlim[0, j], qlim[1, j]]

else:

ql = [angle(qlim[k, j]) for k in [0, 1]]

else:

ql = []

table.row(L.a, angle(L.alpha), angle(L.theta), qs(j, L), *ql)

table.row(L.a, angle(L.alpha), qs(j, L), L.d, *ql)

*qlim_columns,

if has_qlim:

if L.isprismatic():

ql = [qlim[0, j], qlim[1, j]]

else:

ql = [angle(qlim[k, j]) for k in [0, 1]]

else:

ql = []

angle(L.theta), qs(j, L), L.a, angle(L.alpha), *ql)

table.row(qs(j, L), L.d, L.a, angle(L.alpha), *ql)

# show tool and base

if self._tool is not None or self._tool is not None:

table = ANSITable(

Column("", colalign=">"),

Column("", colalign="<"),

border="thin", header=False)

if self._base is not None:

table.row(

"base", self._base.printline(

orient="rpy/xyz", fmt="{:.2g}", file=None))

if self._tool is not None:

table.row(

"tool", self._tool.printline(

orient="rpy/xyz", fmt="{:.2g}", file=None))

s += "\n" + str(table)

# show named configurations

if len(self._configdict) > 0:

table = ANSITable(

Column("name", colalign=">"),

*[Column(f"q{j:d}", colalign="<", headalign="<") for j in range(self.n)],

border="thin")

for name, q in self._configdict.items():

qlist = []

for i, L in enumerate(self):

if L.isprismatic():

qlist.append(f"{q[i]:.3g}")

else:

qlist.append(angle(q[i]))

table.row(name, *qlist)

s += "\n" + str(table)

return s

planar = rtb.models.DH.Planar2()

print(planar)

puma = rtb.models.DH.Puma560()

print(puma)