Robotique Open Source

Sauf mention contraire, le contenu de ce wiki est placé sous les termes de la licence suivante : CC Attribution-Non Commercial-Share Alike 4.0 International Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr

1 - ROS2 - Démarrage

1 - ROS2 - Démarrage

Installation PC ROS2

ROS est un Middleware Open Source pour développer des applications robotiques. Originellement développé sous Linux (Ubuntu), il est maintenant disponible sur plusieurs systèmes d'exploitation dont Debian et Windows.

Installation des prérequis et liens importants

Pour des raisons de stabilité et légèreté du système, il y a tout à penser que les déploiements de ROS dans des milieux industriels se font (robotique autonome et mobile) et se feront à l'avenir sur Ubuntu et de plus en plus Debian. L'industrie des serveurs a déjà largement adopté Debian pour sa stabilité et sa modularité. C'est pourquoi plutôt que d'apprendre la ligne de commande Windows, nous recommandons d'apprendre la ligne de commande Bash, utilisée dans Ubuntu/Debian. Pour cela, il faut installer un système (noyau) Linux, plusieurs options s'offrent à nous:

Notes importantes pour les installations virtuelles (deux premières options d'installation) :

Ubuntu via Windows SubSystem for Linux (WSL2)

WSL2 installe une machine virtuelle avec le noyau Linux complet, supporté et managé par Microsoft Windows. Il n'y a pas besoin de droits administrateur car le logiciel est disponible dans le store Windows.

Prérequis :

Installation de Ubuntu 22 :

sudo apt update
sudo apt upgrade

Depuis Windows, pour éteindre les Machines Virtuelles Ubuntu et ainsi libérer la mémoire RAM affectée :

Ubuntu via VirtualBox

Télécharger et installer VirtualBox pour Windows : https://www.oracle.com/virtualization/technologies/vm/downloads/virtualbox-downloads.html

image.pngimage.png

image.png

Windows 10/11

Une installation native sous Windows 10 avec Visual Studio 2019 (Version Community gratuite) est possible :

Installation de ROS2 Humble

Les distributions stables publiées (pré-compilées) de ROS2 sont nommées par ordre alphabétique. Début 2023, on va installer ROS 2 Humble :

sudo apt update && sudo apt install locales
sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
export LANG=en_US.UTF-8
sudo apt install software-properties-common
sudo add-apt-repository universe
sudo apt update && sudo apt install curl
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null
sudo apt update && sudo apt upgrade
sudo apt install ros-humble-desktop-full
source /opt/ros/humble/setup.bash
echo 'source /opt/ros/humble/setup.bash' >> ~/.bashrc

Tester l'installation

https://docs.ros.org/en/humble/Installation/Ubuntu-Install-Debians.html#try-some-examples

Installation d'autres versions de ROS2

Pour avoir accès à toutes les dernières fonctionnalités en cours de développement (partiellement publiées), il faut installer ROS2 Rolling, qui est une distribution en développement continu "rolling release". Par exemple en Avril 2023, l'API Python de MoveIt2 et son tutoriel ne sont disponibles que sous rolling.

On peut installer plusieurs versions de ros en parallèle. Chaque version sera installée dans /opt/ros/version. Pour faire cohabiter les deux versions, il faut "sourcer" le bon répertoire avant de lancer un programme ros2 launch ... ou de compiler un workspace colcon build .... Deux options s'offrent à nous :

Tutoriel

Pour comprendre les concepts de ROS2 par la pratique, il existe des tutoriels pour débutant. Ils reposent sur la simulation d'un robot mobile à deux roues principales développé par les développeurs de ROS en 2010 : Turtlebot. Le TurtleBot 3 est vendue par Robotis et peut être couplé à un bras manipulateur 5 axes OpenMANIPULATOR-X. Il est possible de simuler des applications de manipulation mobile avec Gazebo.

Outils utiles

Terminal multi-fenêtres Terminator

Visual Studio Codium

Pour éviter d'alourdir la VM avec de la télémétrie Microsoft, on installe la version sans tracker de Visual Studio Code depuis un dépôt debian :

wget https://gitlab.com/paulcarroty/vscodium-deb-rpm-repo/raw/master/pub.gpg 
sudo mv pub.gpg /usr/share/keyrings/vscodium-archive-keyring.asc
echo 'deb [ signed-by=/usr/share/keyrings/vscodium-archive-keyring.asc ] https://paulcarroty.gitlab.io/vscodium-deb-rpm-repo/debs vscodium main' \
    | sudo tee /etc/apt/sources.list.d/vscodium.list
sudo apt update
sudo apt install codium

Installer Firefox dans WSL

https://askubuntu.com/questions/1444962/how-do-i-install-firefox-in-wsl-when-it-requires-snap-but-snap-doesnt-work

sudo snap remove firefox
sudo apt remove firefox
sudo add-apt-repository ppa:mozillateam/ppa

# Create a new file, it should be empty as it opens:
sudo gedit /etc/apt/preferences.d/mozillateamppa

# Insert these lines, then save and exit
Package: firefox*
Pin: release o=LP-PPA-mozillateam
Pin-Priority: 501

# after saving, do
sudo apt update
sudo apt install firefox-esr

Sources

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) 

1 - ROS2 - Démarrage

Tutoriels de base

Pour réaliser les tutoriels de base, il nous faut un environnement de développement, deux options :

Supposons que vous avez installé et testé votre environnement comme celui de la VM.

Connexion à la VM

Nous pouvons directement passer aux tutoriels sur les outils ROS 2 en ligne de commande :

Ces premiers tutoriels ne nécessitent qu'une installation basique de ROS 2, on n'y regarde pas le code source.

Ensuite on passe aux tutoriels sur les bibliothèques clientes de ROS 2 en C++ et Python : 

Ces tutoriels vous engagent à copier et analyser du code source en C++ et Python. Les fichiers créés sont placés dans le dossier de travail (workspace) /home/etudiant/ros2_ws/src, à ouvrir avec Visual Studio Code :

image.png

Vous trouverez des fichiers de correction commentés dans ros2_ws/src/cpp_pubsub/src/, en particulier :

Pour les tester il faut lancer :

cd ~/ros2_ws
colcon build --packages-select cpp_pubsub
source install/setup.bash
ros2 run cpp_pubsub talker

Le noeud se met à publier/parler :

[INFO] [minimal_publisher]: Publishing: "Hello World: 0"
[INFO] [minimal_publisher]: Publishing: "Hello World: 1"
[INFO] [minimal_publisher]: Publishing: "Hello World: 2"
[INFO] [minimal_publisher]: Publishing: "Hello World: 3"
[INFO] [minimal_publisher]: Publishing: "Hello World: 4"

Puis dans un second Terminal :

ros2 run cpp_pubsub listener

Le noeud se met à écouter :

[INFO] [minimal_subscriber]: I heard: "Hello World: 10"
[INFO] [minimal_subscriber]: I heard: "Hello World: 11"
[INFO] [minimal_subscriber]: I heard: "Hello World: 12"
[INFO] [minimal_subscriber]: I heard: "Hello World: 13"
[INFO] [minimal_subscriber]: I heard: "Hello World: 14"

Tapez Ctrl+C dans chaque Terminal pour arrêter les noeuds ("stop spinning").

 

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) 

1 - ROS2 - Démarrage

Découverte d'Ubuntu Linux et son Terminal Bash

## Tutoriel
Pour comprendre les concepts de ROS2 par la pratique, il existe des tutoriels pour débutant. Ils reposent sur la simulation d'un robot mobile à deux roues principales développé par les développeurs de ROS en 2010 : [Turtlebot](https://fr.wikipedia.org/wiki/TurtleBot). Le [TurtleBot 3 est vendue par Robotis](https://emanual.robotis.com/docs/en/platform/turtlebot3/overview/) et peut être [couplé à un bras manipulateur 5 axes OpenMANIPULATOR-X](https://emanual.robotis.com/docs/en/platform/turtlebot3/manipulation/#manipulation). Il est possible de [simuler des applications de manipulation mobile avec Gazebo](https://emanual.robotis.com/docs/en/platform/turtlebot3/manipulation/#simulation).

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) 

Navigating the Ubuntu GUI

In this exercise, we will familiarize ourselves with the graphical user interface (GUI) of the Ubuntu operating system.

Task 1: Familiarize Yourself with the Ubuntu Desktop

At the log-in screen, click in the password input box, enter rosindustrial for the password, and hit enter. The screen should look like the image below when you log in:

../../_images/ubuntu_desktop.png

There are several things you will notice on the desktop:

../../_images/ubuntu_desktop_details.png

  1. The gear icon on the top right of the screen brings up a menu which allows the user to log out, shut down the computer, access system settings, etc…

  2. The bar on the left side shows running and “favorite” applications, connected thumb drives, etc.

  3. The top icon is used to access all applications and files. We will look at this in more detail later.

  4. The next icons are either applications which are currently running or have been “pinned” (again, more on pinning later)

  5. Any removable drives, like thumb drives, are found after the application icons.

  6. If the launcher bar gets “too full”, clicking and dragging up/down allows you to see the applications that are hidden.

  7. To reorganize the icons on the launcher, click and hold the icon until it “pops out”, then move it to the desired location.


Task 2: Open and Inspect an Application

Click on the filing-cabinet icon in the launcher. A window should show up, and your desktop should look like something below:

../../_images/ubuntu_folder_browser.png

Things to notice:

  1. The close, minimize, and maximize buttons typically found on the right-hand side of the window title bar are found on the left-hand side.

  2. The menu for windows are found on the menu bar at the top of the screen, much in the same way Macs do. The menus, however, only show up when you hover the mouse over the menu bar.

  3. Notice that there are menu highlights of the folder icon. The dots on the left show how many windows of this application are open. Clicking on these icons when the applications are open does one of two things:

  • If there is only one window open, this window gets focus.

  • If more than one are open, clicking a second time causes all of the windows to show up in the foreground, so that you can choose which window to go to (see below):

../../_images/ubuntu_inspect.png


Task 3: Start an Application & Pin it to the Launcher Bar

Click on the launcher button (top left) and type gedit in the search box. The “Text Editor” application (this is actually gedit) should show up (see below):

../../_images/ubuntu_start_application.png

Click on the application. The text editor window should show up on the screen, and the text editor icon should show up on the launcher bar on the left-hand side (see below):

../../_images/ubuntu_application_pin.png

  1. Right-click on the text editor launch icon, and select “Lock to Launcher”.

  2. Close the gedit window. The launcher icon should remain after the window closes.

  3. Click on the gedit launcher icon. You should see a new gedit window appear.

Le Terminal Linux

In this exercise, we will familiarize ourselves with the Linux terminal.

Starting the Terminal

  1. Pour ouvrir le Terminal, recherchez le programme "terminator" ou cliquez sur l'icône:

    63008829.png

  2. Create a second terminal window, either by:

    • Right-clicking on the terminal and selecting the “Open Terminal” or

    • Selecting “Open Terminal” from the “File” menu

  3. Create a second terminal within the same window by pressing “Ctrl+Shift+T” while the terminal window is selected.

  4. Close the 2nd terminal tab, either by:

    • clicking the small ‘x’ in the terminal tab (not the main terminal window)

    • typing exit and hitting enter.

  5. The window will have a single line, which looks like this:

    ros-industrial@ros-i-humble-vm:~$

  6. This is called the prompt, where you enter commands. The prompt, by default, provides three pieces of information:

    1. ros-industrial is the login name of the user you are running as.

    2. ros-i-humble-vm is the host name of the computer.

    3. ~ is the directory in which the terminal is currently in. (More on this later).

  7. Close the terminal window by typing exit or clicking on the red ‘x’ in the window’s titlebar.

Navigating Directories and Listing Files

Prepare your environment

  1. Open your home folder in the file browser.

  2. Double-click on the ex0.3 folder we created in the previous step.

    • We’ll use this to illustrate various file operations in the terminal.

  3. Right click in the main file-browser window and select “Open in Terminal” to create a terminal window at that location.

  4. In the terminal window, type the following command to create some sample files that we can study later:

    • cp -a ~/industrial_training/exercises/0.3/. .

ls Command

  1. Enter ls into the terminal.

    • You should see test.txt, and new listed. (If you don’t see ‘new’, go back and complete the previous exercise).

    • Directories, like new, are colored in blue.

    • The file sample_job is in green; this indicates it has its “execute” bit set, which means it can be executed as a command.

  2. Type ls *.txt. Only the file test.txt will be displayed.

  3. Enter ls -l into the terminal.

    • Adding the -l option shows one entry per line, with additional information about each entry in the directory.

    • The first 10 characters indicate the file type and permissions

    • The first character is d if the entry is a directory.

    • The next 9 characters are the permissions bits for the file

    • The third and fourth fields are the owning user and group, respectively.

    • The second-to-last field is the time the file was last modified.

    • If the file is a symbolic link, the link’s target file is listed after the link’s file name.

  4. Enter ls -a in the terminal.

    • You will now see one additional file, which is hidden.

  5. Enter ls -a -l (or ls -al) in the command.

    • You’ll now see that the file hidden_link.txt points to .hidden_text_file.txt.

pwd and cd Commands

  1. Enter pwd into the terminal.

    • This will show you the full path of the directory you are working in.

  2. Enter cd new into the terminal.

    • The prompt should change to ros-industrial@ros-i-humble-vm:~/ex0.3/new$.

    • Typing pwd will show you now in the directory /home/ros-industrial/ex0.3/new.

  3. Enter cd .. into the terminal. * In the previous exercise, we noted that .. is the parent folder. * The prompt should therefore indicate that the current working directory is /home/ros-industrial/ex0.3.

  4. Enter cd /bin, followed by ls.

    • This folder contains a list of the most basic Linux commands.
      Note that pwd and ls are both in this folder.

  5. Enter cd ~/ex0.3 to return to our working directory.

    • Linux uses the ~ character as a shorthand representation for your home directory.

    • It’s a convenient way to reference files and paths in command-line commands.

    • You’ll be typing it a lot in this class… remember it!

If you want a full list of options available for any of the commands given in this section, type man <command> (where <command> is the command you want information on) in the command line. This will provide you with built-in documentation for the command. Use the arrow and page up/down keys to scroll, and q to exit.

Altering Files

mv Command

  1. Type mv test.txt test2.txt, followed by ls.

    • You will notice that the file has been renamed to test2.txt.
      This step shows how mv can rename files.

  2. Type mv test2.txt new, then ls.

    • The file will no longer be present in the folder.

  3. Type cd new, then ls.

    • You will see test2.txt in the folder.
      These steps show how mv can move files.

  4. Type mv test2.txt ../test.txt, then ls.

    • test2.txt will no longer be there.

  5. Type cd .., then ls.

    • You will notice that test.txt is present again.
      This shows how mv can move and rename files in one step.

cp Command

  1. Type cp test.txt new/test2.txt, then ls new.

    • You will see test2.txt is now in the new folder.

  2. Type cp test.txt "test copy.txt", then ls -l.

    • You will see that test.txt has been copied to test copy.txt.
      Note that the quotation marks are necessary when spaces or other special characters are included in the file name.

rm Command

  1. Type rm "test copy.txt", then ls -l.

    • You will notice that test copy.txt is no longer there.

mkdir Command

  1. Type mkdir new2, then ls.

    • You will see there is a new folder new2.

touch Command

  1. Type touch ~/Templates/"Untitled Document".

    • This will create a new Document named “Untitled Document”

You can use the -i flag with cp, mv, and rm commands to prompt you when a file will be overwritten or removed.

Job management

Stopping Jobs

  1. Type ./sample_job.

    • The program will start running.

  2. Press Control+C.

    • The program should exit.

  3. Type ./sample_job sigterm.

    • The program will start running.

  4. Press Control+C.

    • This time the program will not die.

Stopping “Out of Control” Jobs

  1. Open a new terminal window.

  2. Type ps ax.

  3. Scroll up until you find python ./sample_job sigterm.

    • This is the job that is running in the first window.

    • The first field in the table is the ID of the process (use man ps to learn more about the other fields).

  4. Type ps ax | grep sample.

    • You will notice that only a few lines are returned.

    • This is useful if you want to find a particular process

    • Note: this is an advanced technique called “piping”, where the output of one program is passed into the input of the next. This is beyond the scope of this class, but is useful to learn if you intend to use the terminal extensively.

  5. Type kill <id>, where <id> is the job number you found with the ps ax.

  6. In the first window, type ./sample_job sigterm sigkill.

    • The program will start running.

  7. In the second window, type ps ax | grep sample to get the id of the process.

  8. Type kill <id>.

    • This time, the process will not die.

  9. Type kill -SIGKILL <id>.

    • This time the process will exit.

Showing Process and Memory usage

  1. In a terminal, type top.

    • A table will be shown, updated once per second, showing all of the processes on the system, as well as the overall CPU and memory usage.

  2. Press the Shift+P key.

    • This will sort processes by CPU utilization.
      This can be used to determine which processes are using too much CPU time.

  3. Press the Shift+M key.

    • This will sort processes by memory utilization
      This can be used to determine which processes are using too much memory.

  4. Press q or Ctrl+C to exit the program.

Editing Text (and Other GUI Commands)

  1. Type gedit test.txt.

    • You will notice that a new text editor window will open, and test.txt will be loaded.

    • The terminal will not come back with a prompt until the window is closed.

  2. There are two ways around this limitation. Try both…

  3. Starting the program and immediately returning a prompt:

    1. Type gedit test.txt &.

      • The & character tells the terminal to run this command in “the background”, meaning the prompt will return immediately.

    2. Close the window, then type ls.

      • In addition to showing the files, the terminal will notify you that gedit has finished.

  4. Moving an already running program into the background:

    1. Type gedit test.txt.

      • The window should open, and the terminal should not have a prompt waiting.

    2. In the terminal window, press Ctrl+Z.

      • The terminal will indicate that gedit has stopped, and a prompt will appear.

    3. Try to use the gedit window.

      • Because it is paused, the window will not run.

    4. Type bg in the terminal.

      • The gedit window can now run.

    5. Close the gedit window, and type ls in the terminal window.

      • As before, the terminal window will indicate that gedit is finished.

Running Commands as Root

  1. In a terminal, type ls -a /root.

    • The terminal will indicate that you cannot read the folder /root.

    • Many times you will need to run a command that cannot be done as an ordinary user, and must be done as the “super user”

  2. To run the previous command as root, add sudo to the beginning of the command.

    • In this instance, type sudo ls -a /root instead.

    • The terminal will request your password (in this case, rosindustrial) in order to proceed.

    • Once you enter the password, you should see the contents of the /root directory.

Warning: sudo is a powerful tool which doesn’t provide any sanity checks on what you ask it to do, so be VERY careful in using it

2 - ROS2 - Robotique mobile

2 - ROS2 - Robotique mobile

Turtlesim et modèle de Dubins

https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Introducing-Turtlesim/Introducing-Turtlesim.html

2 - ROS2 - Robotique mobile

TurtleBot3 - Bases en Simulation

Ressources :

 

2 - ROS2 - Robotique mobile

TurtleBot3 - Piloter le Robot

https://emanual.robotis.com/docs/en/platform/turtlebot3/navigation/#navigation

3 - ROS2 - Manipulation Mobile

3 - ROS2 - Manipulation Mobile

Assemblage du Turtlebot et OpenManipulator-X et configuration initiale

https://www.classes.cs.uchicago.edu/archive/2022/fall/20600-1/turtlebot_assembly_setup.html

A Word of Caution

This page is NOT intended for student use. This page is designed for course staff to build and maintaing the turtlebots. If you are a student, please ensure you have permission from course staff before making any of the changes detailed on this page to any of the turtlebots.


Setup Checklist


Turtlebot Assembly Tips

Turtlebot3

OpenMANIPULATOR Arm


OpenMANIPULATOR Arm First-Time Configuration

After assembling an OpenMANIPULATOR arm, its servos must first be configured properly before it can be used. By default, all the arm motors are set to the same ID (1) and the wrong baud rate, which causes collisions when trying to detect them.

  1. Connect a SINGLE motor (no daisy-chains in the arm) to the OpenCR module and DISCONNECT ALL OTHER MOTORS (the wheel motors!!)
  2. Open up Dynamixel Wizard 2.0 and update the firmware for that motor by following this tutorial. The arm Dynamixel model is XM430-W350, and the wheel motors are XM430-W210.
  3. Scan for connected Dynamixels using the “Scan” button on the top menu. If the scan does not turn up any results, you may need to change the scan options in the "Options" menu. By default, an unconfigured arm motor will have ID 1, be on Protocol 2.0, and have a baud rate of 57600 bps.
  4. Change the ID for the detected motor from 1 to 11/12/13/14/15 (whichever you're doing the procedure for). Click on the “ID” item, and find the ID # you want in the lower right corner. Click it and press “Save”.
  5. Change the baud rate to 1M (if not already 1M). Click on the “Baud Rate (Bus)” item, and find the 1 Mbps option. Click it and press “Save”.
  6. Disconnect the motor (both in the wizard by clicking “Disconnect” up top and physically disconnecting from the board) and repeat the steps for the remaining ones.


Attaching/Detaching the OpenMANIPULATOR Arm

Physical Attachment/Detachment

Follow these steps below:

  1. The arm can be attached and detached by first removing the top layer of the the Turtlebot. There are 10 screws around the perimeter of the top layer that you will need to remove with a Phillips head / cross screwdriver.
  2. Once the top layer of the Turtlebot is loose, disconnect the cable that is attached to the LiDAR. This cable is multi-colored with several pins.
    Note: ONLY remove this LiDAR cable in this step.

    Turtlebot3 with an arm.

    Once the top layer is fully disconnected, flip the top layer upside-down for easy access.
  3. To connect the arm, there are four screws that you will need to insert through the bottom side of the top layer that connect to Dynamixel #11. The exact location of the screws are marked in the picture below. Use an hex/allen key to secure them.

    Turtlebot3 with an arm.

  4. Once the arm is securely attached, thread the cable connected to DynaMIXEL #11 through the top layer (if not already threaded) and attach the other end to the remaining 3-pin slot on the OpenCR board. It should be the open slot adjacent to the already occupied slots.
  5. Reconnect the LiDAR cable and re-screw the top layer onto the robot.

To disconnect the arm, follow the same steps as above, but remove the four screws instead and disconnect the DynaMIXEL.

Updating Firmware and Files

Every time the arm is attached or detached, you will need to reconfigure environment variables and update the OpenCR firmware.

If you are attaching the arm, set the environment variable OPENCR_MODEL=om_with_tb3 and ensure that OPENCR_PORT=/dev/ttyACM0 in the ~/.bashrc file.

Note: You can also set those environment variables in the command line by running:
$ export OPENCR_PORT=/dev/ttyACM0
$ export OPENCR_MODEL=om_with_tb3

Source the file and update the firmware with:

$ source ~/.bashrc
$ cd ~/opencr_update && ./update.sh $OPENCR_PORT $OPENCR_MODEL.opencr


If you are detaching the arm, set the environment variable OPENCR_MODEL=waffle and ensure that OPENCR_PORT=/dev/ttyACM0 in the ~/.bashrc file.

Enter the OpenCR board into firmware recovery mode by pressing and holding SW2, and simultaneously pressing RESET (you will need to remove the top layer of the turtlebot in order to access those OpenCR buttons). If you want to read more about the OpenCR bootloader, please refer to this page in the OpenCR 1.0 manual.


buttons on OpenCR

Source the file and update the firmware with:

$ source ~/.bashrc
$ cd ~/opencr_update && ./update.sh $OPENCR_PORT $OPENCR_MODEL.opencr


Common Errors During Setup

Firmware Recovery Mode and Device Firmware Update for OpenCR Board

We found the firmware recovery mode not clearly detailed in the Turtlebot3 manual. Here are the steps for firmware recovery:

  1. Push and hold SW2
  2. Press RESET
  3. Release SW2
  4. Arduino code should upload successfully with jump_with_fw

Firmware recovery is different from device firmware update (DFU), where the steps are:

  1. Push and hold BOOT
  2. Press RESET
  3. Release BOOT

Troubleshooting /dev/ttyACM0 Connection Issues

If the /dev/ttyACM0 port isn't found or running bringup on the Pi is hanging:

If the hydro rosserial / groovy Arduino error appears:

3 - ROS2 - Manipulation Mobile

Installation et démarrage du Turtlebot & OpenManipulator-X

Installation Ubuntu Server

Version rapide

sudo umount /media/user/writable /media/user/system-boot
sudo gunzip -c ~/turtlebot3-manipulator-humble.img.gz | sudo of=/dev/sda status=progress
            addresses: [IP_TURTLEBOT/24]
            gateway4: IP_BOX
            nameservers:
                addresses: [DNS_BOX_OPERATEUR, 9.9.9.9, 89.234.141.66]
            access-points:
                "SSID_WIFI":
                    password: PASSWORD_WIFI

Remarque : l'image a été créée après avoir suivi les instructions longues ci-dessous (et quelques workspace et package ros installés en plus) en lançant la commande suivante :

sudo dd if=/dev/sda status=progress | gzip -9 > ~/turtlebot3-manipulator-humble.img.gz

Reinitialiser le mot-de-passe

Voir la section 4 ici

Version longue

https://emanual.robotis.com/docs/en/platform/turtlebot3/sbc_setup/#sbc-setup 

Depuis un ordinateur sous Ubuntu 22.04

Depuis une VM WSL Ubuntu 22

Configurer la connexion automatique au réseau wifi et donner une IP fixe au robot (dans la plage DHCP autorisée par le routeur)  :

network:
    renderer: networkd
    ethernets:
        eth0:
            dhcp4: true
            dhcp6: true
            optional: true
    wifis:
        wlan0:
            dhcp4: false
            dhcp6: false
            addresses: [192.168.100.40/24]
            gateway4: 192.168.100.1
            nameservers:
                addresses: [192.168.100.1, 9.9.9.9, 89.234.141.66]
            access-points:
                fablab:
                    password: ...
    version: 2
network: {config: disabled}

Insérer la carte dans le robot, le démarrer assez proche du hotspot wifi configuré, se connecter en ssh depuis l'ordinateur :

Installer ROS 2 Humble sans interfaces graphiques (ros-humble-desktop) qui seront lancées sur l'ordinateur externe :

sudo apt update && sudo apt install locales
sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
export LANG=en_US.UTF-8
sudo apt install software-properties-common
sudo add-apt-repository universe
sudo apt update && sudo apt install curl
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null
sudo apt update && sudo apt upgrade
sudo apt install ros-humble-ros-base ros-dev-tools
source /opt/ros/humble/setup.bash
echo 'source /opt/ros/humble/setup.bash' >> ~/.bashrc

Installer le workspace du turtlebot et les dépendances :

sudo apt install python3-argcomplete python3-colcon-common-extensions libboost-system-dev build-essential
sudo apt install ros-humble-hls-lfcd-lds-driver
sudo apt install ros-humble-turtlebot3-msgs
sudo apt install ros-humble-dynamixel-sdk
sudo apt install libudev-dev
mkdir -p ~/turtlebot3_ws/src && cd ~/turtlebot3_ws/src
git clone -b humble-devel https://github.com/ROBOTIS-GIT/turtlebot3.git
git clone -b ros2-devel https://github.com/ROBOTIS-GIT/ld08_driver.git
cd ~/turtlebot3_ws/src/turtlebot3
rm -r turtlebot3_cartographer turtlebot3_navigation2
cd ~/turtlebot3_ws/
echo 'source /opt/ros/humble/setup.bash' >> ~/.bashrc
source ~/.bashrc
colcon build --symlink-install --parallel-workers 1
echo 'source ~/turtlebot3_ws/install/setup.bash' >> ~/.bashrc
source ~/.bashrc

Configurer le Port USB pour OpenCR :

sudo cp `ros2 pkg prefix turtlebot3_bringup`/share/turtlebot3_bringup/script/99-turtlebot3-cdc.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
sudo udevadm trigger

ID de domain ROS pour la communication DDS :

echo 'export ROS_DOMAIN_ID=30 #TURTLEBOT3' >> ~/.bashrc
source ~/.bashrc

Configurer le modèle du LIDAR : 

echo 'export LDS_MODEL=LDS-02' >> ~/.bashrc
source ~/.bashrc

Montage et Configuration des Dynamixels

https://www.classes.cs.uchicago.edu/archive/2022/fall/20600-1/turtlebot_assembly_setup.html

Pour l'Open-Manipulator

Configurer les dynamixel (baud et ID 11 à 15) https://www.classes.cs.uchicago.edu/archive/2022/fall/20600-1/turtlebot_assembly_setup.html#arm-first-time :

Pour le Turtlebot

Via Arduino IDE ou DynamixelWizard en s'inspirant de : https://emanual.robotis.com/docs/en/platform/turtlebot3/faq/#setup-dynamixels-for-turtlebot3

Test depuis un PC sans la raspberry

Téléopération du OpenManipulator-X seul

Suivre le tutoriel Foxy en remplaçant foxy par humble et foxy-devel par ros2 en utilisant l'interface de communication OpenCR : https://emanual.robotis.com/docs/en/platform/openmanipulator_x/quick_start_guide/

Pour tester le bon fonctionnement du bras et de sa pince, on connecte la carte OpenCR directement à un PC ayant ROS Humble préinstallé :

sudo apt install ros-humble-rqt* ros-humble-joint-state-publisher
mkdir -p ~/openmanipulator_ws/src/
cd ~/openmanipulator_ws/src/
git clone -b ros2 https://github.com/ROBOTIS-GIT/DynamixelSDK.git
git clone -b ros2 https://github.com/ROBOTIS-GIT/dynamixel-workbench.git
git clone -b ros2 https://github.com/ROBOTIS-GIT/open_manipulator.git
git clone -b ros2 https://github.com/ROBOTIS-GIT/open_manipulator_msgs.git
git clone -b ros2 https://github.com/ROBOTIS-GIT/open_manipulator_dependencies.git
git clone -b ros2 https://github.com/ROBOTIS-GIT/robotis_manipulator.git
cd ~/openmanipulator_ws && colcon build --symlink-install

image.png

Programmation hors-ligne du OpenManipulator-X et TurtleBot3 depuis MoveIt

On suit le tutoriel https://emanual.robotis.com/docs/en/platform/turtlebot3/manipulation/#operate-the-actual-openmanipulator en installant tout ce qui est censé être installé sur le raspberry [SBC]/[TurtleBot3] sur le PC [Remote PC].

sudo apt install ros-humble-dynamixel-sdk ros-humble-ros2-control ros-humble-ros2-controllers ros-humble-gripper-controllers ros-humble-moveit
cd ~/turtlebot3_ws/src/
git clone -b humble-devel https://github.com/ROBOTIS-GIT/turtlebot3_manipulation.git
cd ~/turtlebot3_ws && colcon build --symlink-install
export ROS_DOMAIN_ID=30 #TURTLEBOT3
export LDS_MODEL=LDS-02
export TURTLEBOT3_MODEL=waffle_pi
export OPENCR_PORT=/dev/ttyACM0
export OPENCR_MODEL=turtlebot3_manipulation
rm -rf ./opencr_update.tar.bz2
wget https://github.com/ROBOTIS-GIT/OpenCR-Binaries/raw/master/turtlebot3/ROS2/latest/opencr_update.tar.bz2
tar -xvf opencr_update.tar.bz2
cd ./opencr_update
./update.sh $OPENCR_PORT $OPENCR_MODEL.opencr

Configuration OpenCR

Pour le Turtlebot : https://emanual.robotis.com/docs/en/platform/turtlebot3/opencr_setup/#opencr-setup

Pour l'OpenManipulator-X : https://emanual.robotis.com/docs/en/platform/turtlebot3/manipulation/#opencr-setup

Dépendances manquantes :

sudo apt install ros-humble-hardware-interface
ros-humble-ros2-control ?
ros-humble-joint-state-publisher ?

Dépendances manquantes côté Raspberry : 

sudo apt install rros-humble-gripper-controllers ros-humble-xacro

Dépendances manquantes côté PC : 

sudo apt install ros-humble-moveit-servo

Issues :

https://forum.robotis.com/t/ros-2-foxy-openxmanuipaltor-bringup-issues/2142/9

https://github.com/ROBOTIS-GIT/open_manipulator/issues/212

https://github.com/ROBOTIS-GIT/open_manipulator/issues/209

https://www.classes.cs.uchicago.edu/archive/2022/fall/20600-1/turtlebot_assembly_setup.html#arm-first-time

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) 

4 - ROS2 - Manipulation Cobot

4 - ROS2 - Manipulation Cobot

Universal Robot ROS2 Driver

Le Driver ROS2 pour les cobots Universal Robot a été développé en collaboration entre Universal Robots, le Forschungszentrum für Informatik (INRIA allemand) et PickNik Robotics. Plus précisément par nos voisins de Karlsruhe, en particulier Felix Exner (https://github.com/fmauch)). Le FZI est également à l'origine d'une proposition d'interface ROS standard pour les trajectoires Cartésiennes, qui est désormais implémentée dans les contrôleurs ROS Cartésiens d'Universal Robots. La proposition repose sur un état de l'art très intéressant des interfaces de programmation des marques de robot majeures.

Installation des paquets UR pour ROS2

sudo apt install ros-humble-ur
sudo apt install python3-rosdep
sudo rosdep init
rosdep update
sudo apt update
sudo apt dist-upgrade

Installation du simulateur hors-ligne URSim

https://github.com/UniversalRobots/Universal_Robots_ROS2_Driver#getting-started

https://github.com/UniversalRobots/Universal_Robots_ROS2_Driver#install-from-binary-packages

Le moyen le plus simple de découvrir et commencer à utiliser un robot UR avec ROS2 est d'utiliser la simulation de la console de programmation (teach panel) de son contrôleur. URSim est le simulateur hors-ligne de Universal Robots. Il permet de reproduire le comportement réel d'un robot quasiment à l'identique en se connectant à son adresse IP. Il est possible d'installer URSim 5 sur un Ubuntu <18 (non inclus!) ou dans une machine virtuelle (VirtualBox). Il faut se créer un compte pour télécharger le fichier URSim 5.13. Ubuntu 18 n'est plus supporté, et MoveIt2 tourne sur Ubuntu 22.

Sur Ubuntu 22

En attendant la sortie de URSim/Polyscope 6, la manière la plus simple d'installer URSim 5 sur Ubuntu 22 est via conteneur Docker créé par UR Lab (pas maintenu officiellement).

Installer Docker

Depuis les dépôts officiels Ubuntu :

sudo apt update
sudo apt install docker-compose

Ajouter votre utilisateur au groupe docker afin de manipuler les containers sans avoir à utiliser sudo systématiquement :

sudo usermod -aG docker $USER

Tester la bonne installation :

sudo service docker start
docker run hello-world

Installer le conteneur URSim

On suit le tutoriel fourni dans la documentation du driver UR ROS. Il existe une image docker fournie sur hub.docker.com, c'est très simple :

docker pull universalrobots/ursim_e-series
ros2 run ur_robot_driver start_ursim.sh -m <ur_type>

Sur Windows 10/11

Pour les systèmes non-Linux, UR fournit une VM LUbuntu 14.04 qui peut tourner sous VirtualBox (gratuit) ou sur VMware (gratuit pour usage non commercial).

Installer VirtualBox

Télécharger et configurer la Machine Virtuelle

Ajouter l'URCap External Control

 

Configurer le réseau pour que les VMs communiquent

Démarrage et configuration URSim

image.png

Programmation hors-ligne avec URSim et MoveIt2/RViz

sudo apt install python3-rosdep
sudo rosdep init
rosdep update
sudo apt update
sudo apt dist-upgrade
sudo apt install python3-colcon-common-extensions
sudo apt install python3-colcon-mixin
colcon mixin add default https://raw.githubusercontent.com/colcon/colcon-mixin-repository/master/index.yaml
colcon mixin update default

NOTES IMPORTANTES

sudo apt update && rosdep install -r --from-paths . --ignore-src --rosdistro $ROS_DISTRO -y --os=ubuntu:jammy
colcon build --mixin release --parallel-workers 1

Déploiement du code source des Tutoriels de MoveIt

mkdir -p ~/ws_moveit2/src
cd ~/ws_moveit2/src
git clone https://github.com/ros-planning/moveit2_tutorials -b humble --depth 1

Optionnel : Installation d'un environnement de développement MoveIt2 avec les dernières améliorations et résolutions de bug

Installation de MoveIt2 Humble sur Ubuntu 22.04 :

sudo apt install python3-vcstool
cd ~/ws_moveit2/src
vcs import < moveit2_tutorials/moveit2_tutorials.repos

Note : si `vcs import` vous demande vos identifiants GitHub, tapez Entrer jusqu'à ce que ça continue. Pas besoin d'identifiant pour récupérer un dépôt GitHub public.

Installation des dépendances et compilation

sudo apt update && rosdep install -r --from-paths . --ignore-src --rosdistro $ROS_DISTRO -y
cd ~/ws_moveit2
colcon build --mixin release
cd ~/ws_moveit2
source ~/ws_moveit2/install/setup.bash
echo 'source ~/ws_moveit2/install/setup.bash' >> ~/.bashrc

Tester la communication entre ROS et URSim

https://docs.ros.org/en/ros2_packages/rolling/api/ur_robot_driver/usage.html#usage-with-official-ur-simulator

ros2 run ur_robot_driver start_ursim.sh -m ur5e
ros2 launch ur_robot_driver ur_control.launch.py ur_type:=ur5e robot_ip:=192.168.56.101

https://docs.ros.org/en/ros2_packages/rolling/api/ur_robot_driver/usage.html#example-commands-for-testing-the-driver

Envoyer des commandes au contrôleur

Avant d'envoyer des commandes, vérifier l'état des contrôleurs en utilisant ros2 control list_controllers

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) 


4 - ROS2 - Manipulation Cobot

Commander un robot UR avec le driver ROS2

Installation d'Ubuntu avec des capacités temps-réel

Pour un usage basique, un Ubuntu (ou Linux Mint) classique permet de piloter le robot : 

Pour éviter des instabilités il est conseillé d'installer un noyau Linux avec des capacités temps-réel (PREEMPT_RT kernel). En particulier avec un robot de la Série-E, la fréquence de contrôle plus élevée peut entraîner des trajectoires non fluides sans noyau temps-réel.

mkdir -p ~/rt_kernel_build
cd ~/rt_kernel_build
tar xf linux-4.14.139.tar
cd linux-4.14.139
xzcat ../patch-4.14.139-rt66.patch.xz | patch -p1
make oldconfig

Récupérer les sources du noyau temps-réel

wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/5.15/patch-5.15.107-rt62.patch.xz
wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/5.15/patch-5.15.107-rt62.patch.sign
wget https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.15.107.tar.xz
wget https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.15.107.tar.sign
xz -dk patch-5.15.107-rt62.patch.xz
xz -d linux-5.15.107.tar.xz
gpg2 --locate-keys torvalds@kernel.org gregkh@kernel.org
gpg2 --keyserver hkp://keys.gnupg.net --search-keys salisbury
gpg2 --verify linux-5.15.107.tar.sign

gpg: Good signature from "Greg Kroah-Hartman <gregkh@kernel.org>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.

gpg2 --verify patch-5.15.107-rt62.patch.sign

gpg: Good signature from "Tom Zanussi <tom.zanussi@linux.intel.com>" [unknown]
gpg:                 aka "Tom Zanussi <zanussi@kernel.org>" [unknown]
gpg:                 aka "Tom Zanussi <tzanussi@gmail.com>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.

Compiler le noyau temps réel

tar xf linux-5.15.107.tar
cd linux-5.15.107
xzcat ../patch-5.15.107-rt62.patch.xz | patch -p1
make oldconfig

Preemption Model
  1. No Forced Preemption (Server) (PREEMPT_NONE)
> 2. Voluntary Kernel Preemption (Desktop) (PREEMPT_VOLUNTARY)
  3. Preemptible Kernel (Low-Latency Desktop) (PREEMPT)
  4. Fully Preemptible Kernel (RT) (PREEMPT_RT_FULL) (NEW)
choice[1-4]: 4

make -j `getconf _NPROCESSORS_ONLN` deb-pkg
sudo apt install ../linux-headers-5.15.107-rt62_*.deb ../linux-image-5.15.107-rt62_*.deb

Définir les permissions utilisateur pour exécuter des tâches temps-réel

sudo groupadd realtime
sudo usermod -aG realtime $(whoami)
@realtime soft rtprio 99
@realtime soft priority 99
@realtime soft memlock 102400
@realtime hard rtprio 99
@realtime hard priority 99
@realtime hard memlock 102400

Note: Pour que ces changements soient pris en compte il faut se déconnecter et se reconncter. On redémarrera plus tard.

https://github.com/HowardWhile/Ubunutu22.04-RT-Kernel

Configurer GRUB pour toujours booter le noyau temps-réel

awk -F\' '/menuentry |submenu / {print $1 $2}' /boot/grub/grub.cfg
menuentry Ubuntu
submenu Advanced options for Ubuntu

    menuentry Ubuntu, with Linux 5.15.107-rt62
    menuentry Ubuntu, with Linux 5.15.107-rt62 (recovery mode)
sudo sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT="Advanced options for Ubuntu>Ubuntu, with Linux 5.15.107-rt62"/' /etc/default/grub
$ sudo update-grub

Vérification de la capacité de préemption temps-réel

uname -v | cut -d" " -f1-4

#1 SMP PREEMPT RT

Optionnel : Désactiver le CPU speed scaling

Les threads planifiés en temps-réel s'exécutent sans problème. Cependant, des composants externes tels que les systèmes de visual servoing, non planifiés pour le temps réel peuvent être interrompus par les fonctionnalités d'économie d'énergie des processeurs récents qui changent leur fréquence d'horloge de manière dynamique.

sudo apt install cpufrequtils
cpufreq-info

current CPU frequency is XXX MhZ

sudo systemctl disable ondemand
sudo systemctl enable cpufrequtils
sudo sh -c 'echo "GOVERNOR=performance" > /etc/default/cpufrequtils'
sudo systemctl daemon-reload && sudo systemctl restart cpufrequtils

Configuration du robot UR

https://docs.ros.org/en/ros2_packages/rolling/api/ur_robot_driver/installation/robot_setup.html

Récupération de la calibration usine

Les robots sont calibrés en usine. Pour que les calculs cinématiques effectués dans ROS soient exacts, il faut récupérer les données de calibration. Sinon la précision des trajectoires envoyées depuis ROS et exécutées sur le robot risquent d'être de l'ordre du centimètre (au lieu du dixième de millimètre en temps normal).

https://docs.ros.org/en/ros2_packages/rolling/api/ur_robot_driver/installation/robot_setup.html#extract-calibration-information

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) 

4 - ROS2 - Manipulation Cobot

Programmer un robot avec MoveIt2 - Jumeau Numérique

Prérequis : être arrivé au bout du tutoriel sur le Driver UR ROS2

Comment fonctionne la manipulation avec MoveIt ?

MoveIt2 est la plateforme de manipulation robotique pour ROS2. Il implémente un nombre important des dernières innovations en termes de :

https://moveit.picknik.ai/humble/doc/concepts/concepts.html

Premiers pas avec MoveIt dans RViz

Pour débuter avec MoveIt, on peut utiliser ses fonctionnalités de planification de trajectoire via le plugin MoveIt Display du logiciel de visualisation 3D de ROS RViz. C'est un outils très puissant pour débuguer des applications robotiques ROS. On verra que RViz est alors un jumeau numérique du vrai robot.

Les tutoriels pour débuter et approfondir ses compétences avec MoveIt sont en Anglais et fonctionnent avec le robot Panda de Franka Emika.

Nous reprenons ici le tutoriel pour débuter avec MoveIt, et l'appliquons à un UR5e.

Avec un hardware simulé par ROS

ros2 launch ur_robot_driver ur_control.launch.py ur_type:=ur5e robot_ip:=yyy.yyy.yyy.yyy fake_hardware:=true launch_rviz:=false

Avec la simulation URSim

Voir https://innovation.iha.unistra.fr/books/robotique-open-source/page/universal-robot-ros2-driver#bkmrk-installation-du-simu 

Sous Ubuntu 22 - docker

ros2 run ur_robot_driver start_ursim.sh -m ur5e
ros2 launch ur_robot_driver ur_control.launch.py ur_type:=ur5e robot_ip:=192.168.56.101 launch_rviz:=false

Sous Windows - VirtualBox

Avec le vrai robot

ros2 launch ur_robot_driver ur_control.launch.py ur_type:=ur5e robot_ip:=192.168.0.10 launch_rviz:=false

Lancer MoveIt et RViz

ros2 launch ur_moveit_config ur_moveit.launch.py ur_type:=ur5e launch_rviz:=true

https://ur-documentation.readthedocs.io/en/latest/index.html ?

Déplacer le Robot avec le Plugin MoveIt dans RViz

Résultat

ros2_moveit2_ros2control_commande_externet_UR5e.mp4

Planification de trajectoire avec OMPL

Ajouter un obstacle

ros2_moveit2_OMPL_RRTconnect_evitement_collision_automatique

Tester différents algorithmes d'OMPL

ros2_moveit2_OMPL_RRTstar_evitement_collision_longueur_optimisee

Résultat

En optimisant la trajectoire avec RRTstar, on obtient un mouvement fluide, qui évite les collision avec l'environnement et de longueur minimisée. Voir la vidéo réalisée en salle robotique de l'IUT. 

-----

Auteur: Gauthier Hentz, sur le wiki de l'innovation de l'IUT de Haguenau

 Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0)