Deployable Constraint based reactive Controller
General Description
✔️ High level description (500 - 1000 characters) of the component, describing what it does
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. This module contains a library that understands this task specification language and can run a robot controller for a given specification. This module follows a ROS2 architechture, allowing e.g. to use signals coming from topics to constraint an entity of the robot or to coordinate the node using a life cycle state machine.
| 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:
| Name | Organisation | |
|---|---|---|
| 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
- Sublist number one
- 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
Orocos etasl-rtt component
Source
Website: https://etasl.pages.gitlab.kuleuven.be/index.html Open source repository: https://gitlab.kuleuven.be/rob-expressiongraphs/etasl_rtt
Description
An orocos component to run eTaSL task specifications. It was developed by KUL and, even if it was reconfigurable, it is complex to use.
Modifications
The core libraries of eTaSL already existed and implementation in Orocos also existed.
However for the project we:
- Integrated in ROS2
- Increased the TRL by making the task specifications (made in eTaSL) and the skills (made with tasks plsu coordination) more easily reusable. A whole framework based on JSON Schemas was developed and, respectively, code that use the filled JSON to reconfigure the component was implemented. This node is highly reconfigurable to adapt multiple applications without the need to program in C++.
- Created input/output handlers to interface with ROS2 topics. If a user wants to put a constraint on the robot to e.g. follow a joystick that streams geometry_msgs/Twist through a ROS2 topic, then the user would only need to specify it through a JSON file that complies with a JSON Schema. This makes it easy since IDEs such as VSCode supports JSON Schema and provides autocompletion, real-time validation, documentation (by hovering mouse over parameter), etc.
- Created mechanisms to interface with robots in an easy way, without depending on ROS2. This is done via shared memory to reduce latencies.
- Structed and formalized the creation of task specifications, skill specifications and applications. These abstraction layers facilitate that different stakeholders, with different expertise, can develop and deploy new applications with our module.
Purpose in AI-PRISM
It serves the purpose of being able to program any sensor-based task that requires adaptation/reaction to the environment or the human. When traditional sense-plan-act paradigms fail, this module can be used to specify the desired robot behaviors in terms of constraints withing a high level language.
It is being used in the Keba pilot to execute the tasks.
License
GNU General Public License v3.0 https://gitlab.kuleuven.be/rob-expressiongraphs/etasl_rtt/-/blob/master/LICENSE?ref_type=heads
How to install
✔️ Every AI-PRISM component is installed using the Cluster management service. During the installation process, the user needs to configure a set of high-level parameters. Provide here a description of the parameters that the user needs to fill in.
TODO
How to use
A full MKDocs gitlab page is being developed with a series of tutorials on how to use this module. It is a big module with lots of things to learn and explore, and therefore it requires it's own page.