HRC assembly constraint-based tasks

General Description

This module is composed of a collection of Libraries with task specifications that are usable within HRC assembly applications. These task specifications are written in eTaSL constraint-based task specification language. These task specifications enable human-robot safe interaction, for example to make the robot recede in the path if the human holds it. It can also be effectively used to deal with uncertainties related to the insertion thanks to the use of force-based behaviors.

Resource	Link
Source code	Link to source code
Demo Video	Link to video

✔️ Generate a GIF with screenshots or images that represent the main functionalities of the component and add it to the it img subfolder, and link it in the image below.

Contact

The following table includes contact information of the main developers in charge of the component:

✔️ Edit the names and contact info of the main developers in charge and update the logo image and link to your website.

Name	email	Organisation
Federico Ulloa	federico.ulloarios@kuleuven.be
Santiago Iregui	santiago.iregui@kuleuven.be
Erwin Aertbeliën	erwin.aertbelien@kuleuven.be

License

GNU General Public License v3.0

Technical Foundations

✔️ Describe the technical foundations of your component. Describe in detail the models, algorithms, or methods you use. If the documentation is available in a different source, for instance, an open access paper, provide here a high-level overview and links to external references.

Code blocks

You can enter block codes in Markdown cells surrounding the text you want to display as code using triple quotes (````) and adding the language name. For instance, the following code block will display some python code styled using Python language syntax:

# This is a comment
print("Hello, world!")

Tables

You can add a table like this in your document:

| This | is   |
|------|------|
|   a  | table|

will display the following table:

This	is
a	table

The table cells are delimited by the (|) character. The first row and first column are used to determine the width of the table, so it is important to insert spaces if you want to control the table width and text alignment across the table. Also, note that the first row is used as headers, and that there is a separator between the header and the table body.

Note that the text in the table is automatically aligned to the left. You can control the alignment of the text using colons (:) after the column delimiter. For instance, the code:

```markdown
|           Right aligned           |centered aligned          |
|----------------------------------:|:------------------------:|
| This is a right aligned column    | and this one is centered |
```

see:

Right aligned	centered aligned
This is a right aligned column	and this one is centered

Lists

You can build itemized lists using the - character, and nested sublists using the tabulator or insert some spaces before the - character. For instance, the code:

- Item list number one
    - Sublist number one
        - This is a sublist item
    - Sublist number two
        - This is a sublist item
        - And this is another
- Item list number two
    - This is another sublist item
    - Here, just one more sublist:
        - One item
        - And one more!

Creates the following list:

• Item list number one
  • Sublist number one
    • This is a sublist item
  • Sublist number two
    • This is a sublist item
    • And this is another
• Item list number two
  • This is another sublist item
  • Here, just one more sublist:
    • One item
    • And one more!

You can also create numbered nested lists just using numbers before a '.' character. For instance:

1. Here we go
    1. Sublist item 1
    2. Sublist item 2
2. Here we go again
    1. Sublist item 1
    2. Sublist item 2

Will create this sublist: 1. Here we go 1. Sublist item 1 2. Sublist item 2 2. Here we go again 1. Sublist item 1 2. Sublist item 2

LaTeX equations

You can include mathematical expressions using LaTex notation wrapped using the dollar symbol as a delimiter. You can insert equations inline (in the same line) as text like:

This is an inline equation $e^{i\pi} + 1 = 0$
````

This is an inline equation $e^{i\pi} + 1 = 0$

You can also use the dollar symbol to include equations standalone in a new line. For instance, the code:

```markdown
$$e^x=\sum_{i=0}^\infty \frac{1}{i!}x^i$$

Will introduce an equation in a new line, like this:

$$e^x=\sum_{i=0}^\infty \frac{1}{i!}x^i$$

Latex cheat sheet

You can find a comprehensive cheat sheet for LaTeX equations here. You can also use Overleaf to find tutorials and edit equations online. However, we hope this table contains the most common LaTeX commands and symbols.

Symbol	LaTex Command	Description	Example
$x^y$	^{x}	Exponent. The expression in the exponent is passed between curly brackets ({})	$x^{y+1}$
$x_i$	_{i}	Subscript. The expression in the subscript is passed between curly brackets	$x_{i+1}$
$\sum$	\sum	Summation. You can add subscripts and exponents to determine the range of the summation	$\sum_{i=0}^{10}{i!}$
$\frac{x}{y}$	\frac	Fraction. Pass first the numerator and then the denominator using curly brackets	$\frac{1}{2}$
$\int$	\int	Integration. Pass the expression to integrate and the variable to integrate over	$\int x^2 dx$
$\sqrt{x}$	\sqrt	Square root. Pass the expression to square root using curly brackets	$\sqrt{x^2}$
$\geq$	\geq	Greater than or equal to.	$\geq x^2 dx$
$\leq$	\leq	Less than or equal to.	$\leq x^2 dx$
$\neq$	\neq	Not equal to.	$\neq x^2 dx$
$\alpha$	\alpha	Any greek symbol, using its english name (e.g. alpha).	$\alpha$
$\beta$	\beta	Beta is another popular greek symbol.	$\beta$
$\gamma$	\gamma	Gamma is another great greek symbol.	$\gamma$
$\omega$	\omega	But Omega as in Omega level mutant is my favourite.	$\omega$

Matrices and vectors in LaTeX

You can just use brackets to insert vectors in LaTex, which is quite convenient. For instance, the code:

x = [1, 2, 3]

Defines a row vector x with the values 1, 2, 3.

Writing a matrix in LaTex is a bit more complicated. You can use the following syntax:

\begin{bmatrix}
  1 & 2 & 3 \\
  4 & 5 & 6 \\
  7 & 8 & 9
\end{bmatrix}

To write a matrix like:

\begin{bmatrix} 1 & 2 & 3 \ 4 & 5 & 6 \ 7 & 8 & 9 \end{bmatrix}

Note that we write the matrix row-by-row, using two backslashes to separate rows, and the & symbol to separate cells in a row.

Integrated and Open Source Components

This section outlines both pre-existing technologies and open-source components that have been integrated into the component. It provides details on their sources, purposes, modifications, and compliance with licensing terms.

Overview

✔️ Provide a high-level overview of the integrated and open-source components. Provide a high-level description of the funding received in previous projects and what is the progress in AI-PRISM.

Pre-existing Components

eTaSL

Source

Website: https://etasl.pages.gitlab.kuleuven.be/index.html Open source repository: https://gitlab.kuleuven.be/rob-expressiongraphs/docker/etasl-cmake

Description

eTasl is a task specification language for reactive control of robot systems. It is a language that allows you to describe how your robotic system has to move and interact with sensors. This description is based on a constraint-based methodology. Everything is specified as an optimization problem subject to constraints.

Modifications

• Structed and formalized the creation of task specifications to be more re-usable. From the task specification, routines that automatically generate JSON Schemas to define the parameters of the task specification were developed.

Purpose in AI-PRISM

These task specifications can be re-used to create robotic skills and deal with insertions involving uncertainties and human-robot interaction. For example, the KEBA pilot uses these task specifications to make the insertion of PCBs robust using force control.

License

GNU General Public License v3.0 https://gitlab.kuleuven.be/rob-expressiongraphs/docker/etasl-cmake/-/blob/main/LICENSE.txt

How to install

The task specification library needs to be included in the application ROS2 package in a specific folder (e.g. adding a git submodule). Then the application ROS2 package needs to be built with colcon, which genarates a collection of JSON Schema files that will then enable the use of the library.

For the installation with the AI-Prism methodology we could have a "task specification library installer" and then provide the following parameters:

• Name of the library
• Gitlab URL of the library

Then the installation would add the git submodule from the gitlab repository, use the provided name to re-name the submodule, and then call the colcon build procedure and source the ROS2 workspace.

How to use

Tasks can be easily configured through a JSON file that complies with a JSON Schema as shown below.

Then any coordination/orchestration mechanism (e.g. from python) can use this JSON files to create tasks (i.e. task specifications with filled in parameters) and then create skills based on these tasks.