Uncategorised

Détails

Clics : 311

Bienvenue sur la page du projet de MT3

Objectif du projet: découvrir ROS2

Sommaire:

1. Quelques concepts de ROS2
2. Liste du matériel
3. Les étapes du challenge MT3
4. Les contraintes et ce qui est évalué
5. Les dates de projet
6. ESP32 et sa vidéo
7. Tâches à effectuer sur l'ESP32
8. ROS2 et sa vidéo
9. Vidéo de démonstration
10. Tâches à effectuer sur la partie ROS2

Quelques concepts de ROS

La distribution ROS2 est jazzy (echo $ROS_DISTRO)

• Les nodes: Chaque noeud dans ROS doit être responsable d'une seule tâche (par exemple, commander les moteurs de roue ou publier une image de caméra).
  -> Pour lister les noeuds: ros2 node list
  ou, pour avoir plus d'infos: ros2 node info <node_name>
• Les topics: Les topics sont un élément essentiel dans ROS: ils jouent le rôle d'un bus permettant aux noeuds d'échanger des messages.
  
  
  Un nœud peut publier des données sur un nombre quelconque de topics et, simultanément, être abonné à un nombre quelconque de topics
  
  Pour lister les topics: ros2 topic list
  ou avec plus d'informations ros2 topic list -t
Pour voir les informations d'un topic en particulier: ros2 topic info
  Pour voir les données publiées sur un topic: ros2 topic echo <topic_name>
• rqt_graph est un utilitaire très important pour observer les nodes et les topics

Liste du matériel sur le robot:

• Machine virtuelle de Pierre Blazevic avec ROS2 et des exemples
• Servomoteur SG92R 360°
• Roues pour servomoteur
• Roue folle (bille)
• ESP32 WROOM-32S
• Batterie externe

Liste du matériel commun:

• Caméra en douche connectée sur un PC
• Node accessible

Présentation du Projet Robotique

Objectif général

Chaque binôme devra concevoir, programmer et tester un robot autonome capable de se déplacer de manière intelligente sur un parcours défini.

Contexte commun

• Tous les binômes utilisent le même matériel et travaillent sur la même plateforme de développement.

• Le projet est progressif : vous développerez votre robot par étapes successives, en ajoutant des fonctionnalités à chaque phase.

Le schéma de principe:

Les 3 Étapes du Challenge MT3

🟢 Étape 1 : Parcours libre

Objectif : Aller le plus rapidement possible d'une zone de départ vers une zone d’arrivée, sans obstacle et sans intervention humaine.

• Première prise en main du robot.

• Mise en place de la navigation de base.

• Analyse du parcours et optimisation de la trajectoire.

🟡 Étape 2 : Parcours avec obstacles

Objectif : Aller le plus rapidement possible d'une zone de départ vers une zone d’arrivée, avec des obstacles fixes, sans intervention humaine.

• Implémentation de la détection d’obstacles (capteurs).

• Algorithmes d’évitement.

• Adaptation dynamique de la trajectoire.

🔴 Étape 3 : Parcours avec concurrence

Objectif : Aller le plus rapidement possible d'une zone de départ vers une zone d’arrivée, avec obstacles et en présence d’un robot concurrent.

• Capacité à s’adapter à un environnement dynamique.

• Anticipation des mouvements d’un autre robot.

• Gestion de priorités, trajectoires partagées, et compétition.

Contraintes et Évaluation

• Aucun contrôle manuel pendant les phases de test.
• ROS2 obligatoire
• Respect des consignes de sécurité et des règles de la plateforme.
• L’évaluation prendra en compte :
  • Les performances (vitesse, fiabilité)
  • L’intelligence du comportement (adaptabilité, prise de décision)
  • La rigueur du développement (propreté du code, tests, documentation)
  • Le design du robot: humour, frayeur, originalité, ....
  • Un poster A3 de présentation du robot et de sa programmation
  • Une vidéo de démonstration de moins de 2 minutes

Dates des projets MT3 (24h)

• Mardi 6 mai AM:
  1/ venir votre PC et avec la VM qui fonctionne (et avec les add-ons installés)
  2/ objectif 1: Commander les moteurs avec une rampe d'accélération et de décélération
• Mercredi 7 mai PM
  3/ objectif 2: se connecter sur le noeud de vision
  4/ objectif 3: générer une trajectoire entre un point A et un point B
• Mercredi 14 mai AM + PM
  5/ objectif 4: le robot va du point A au point B seul
  6/ objectif 5: la vision traite les obstacles
  7/ objectif 6: le robot va du point A au point B, en évitant les obstacles, seul.
• Jeudi 27 mai AM + PM
  8/ AM: Tests et homologations
  9/ PM: Compétitions
• Dimanche 8 juin à minuit:
  10/ Rendu du travail

Notes ESP32 WROOM 32D:

Attention au cablage: plusieurs broches bloquent la programmation... Regardez la datasheet.

Le document de référence de l'ESP32 est ici

1. Prendre ESP32 DEV MODULE, vitesse de transfert de 115200  et Flash mode: DIO
2. Les broches 21 (I2C Clock) et 22 (I2C Data) seront utilisées pour l'afficheur
3. Connecter les servomoteurs sur GPIO 0 et GPIO 2 pour les "data" des 2 servomoteurs.
4. Le +5V à coté de l'USB.
5. Le GND, entre le GPIO12 et GPIO13.

Le programme que j'ai utilisé pour l'ESP32:

Partie ROS2

Détails

Clics : 608

Programmation Orientée Objet (POO) & C++

1er cours

2nd cours

3ème cours

4ème cours: les pointeurs

5ème cours: Rappels, le pointeur this, les getters et setters

Cours sur les actionneurs (30 heures -> 8 séances, 7 de 4 heures et 1 de  2heures (DS))

1. MCC (Séance 1)
2. Une excellente série d'exercices sur les MCC (Merci à Fabrice Sincère pour cette aide)
3. MS (Séance 2)
4. Une excellente série d'exercices sur les MS (Merci à Fabrice Sincère pour cette aide)
5. MAS (Séance 3)
6. Une excellente série d'exercices sur les MAS (Merci à Fabrice Sincère pour cette aide)
7. Le système triphasé (Séance 4)
8. Le moteur pas à pas (Séance 5)
9. Le transformateur de tension (Séance 6)
10. Une excellente série d'exercices sur le transformateur (Merci à Fabrice Sincère pour son aide)
11. Séance 7: Hydraulique et pneumatique

Détails

Clics : 199

Modélisation de systèmes physiques

1. Cellules photovoltaïques, le cours et TD
2. Sujet d'agrégation + annexes + doc réponses
3. Lidar
4. Sujet d'agrégation autour du Lidar

Détails

Clics : 527

La carte Sabertooth est un driver de 2 moteurs (moteurs à courant continu):

• 2 x 12A -> La carte peut alimenter des moteurs jusqu'à 12A par moteur
• Tension d'alimentation: 6 à 30Vcc (NiCd, NiMH, Lithium, accu au plomb)
• Tension de sortie: de 0 à 33.6V
• à l'ISTY, nous pilotons cette carte Sabertooth au travers de la liaison série de la caret Arduino Mega.
• L'adresse est soit 128, soit 129.
• La fiche technique
• La librairie Arduino

Le schéma de câblage:

Les programmes

Phase 1 : Commande des 2 moteurs sous Arduino sans ROS:

1. Il faut avoir câblé le robot Dagu
2. Il faut avoir téléchargé la librairie Sabertooth.h pour Arduino

Le programme Arduino sans ROS

#define nullptr NULL

// Sweep Sample for Packet Serial
// Copyright (c) 2012 Dimension Engineering LLC
// See license.txt for license details.

#include <Sabertooth.h>

Sabertooth ST(128,Serial3); // The Sabertooth is on address 128. We'll name its object ST.
                    // If you've set up your Sabertooth on a different address, of course change
                    // that here. For how to configure address, etc. see the DIP Switch Wizard for
                    //   Sabertooth - http://www.dimensionengineering.com/datasheets/SabertoothDIPWizard/start.htm
                    //   SyRen      - http://www.dimensionengineering.com/datasheets/SyrenDIPWizard/start.htm
                    // Be sure to select Packetized Serial Mode for use with this library.
                    //
                    // On that note, you can use this library for SyRen just as easily.
                    // The diff-drive commands (drive, turn) do not work on a SyRen, of course, but it will respond correctly
                    // if you command motor 1 to do something (ST.motor(1, ...)), just like a Sabertooth.
                    //
                    // In this sample, hardware serial TX connects to S1.
                    // See the SoftwareSerial example in 3.Advanced for how to use other pins.

void setup()
{
  SabertoothTXPinSerial.begin(9600); // 9600 is the default baud rate for Sabertooth packet serial.
  Serial3.begin(9600);
  ST.autobaud(); // Send the autobaud command to the Sabertooth controller(s).
                 // NOTE: *Not all* Sabertooth controllers need this command.
                 //       It doesn't hurt anything, but V2 controllers use an
                 //       EEPROM setting (changeable with the function setBaudRate) to set
                 //       the baud rate instead of detecting with autobaud.
                 //
                 //       If you have a 2x12, 2x25 V2, 2x60 or SyRen 50, you can remove
                 //       the autobaud line and save yourself two seconds of startup delay.
}

void loop()
{
  int power;
  
  // Ramp motor 1 from -127 to 127 (full reverse to full forward),
  // waiting 20 ms (1/50th of a second) per value.
  for (power = -127; power <= 127; power ++)
  {
    ST.motor(1, power);
    ST.motor(2, power);
    delay(20);
  }
  
  // Now go back the way we came.
  for (power = 127; power >= -127; power --)
  {
    ST.motor(2, power); // Tip for SyRen users: Typing ST.motor(power) does the same thing as ST.motor(1, power).
    ST.motor(1, power);
    delay(20);          //                      Since SyRen doesn't have a motor 2, this alternative can save you typing.
  }
}

Note: J'ai modifié la librairie Sabertooth.h comme suit:

#if defined(USBCON)
#define SabertoothTXPinSerial Serial3 // Arduino Leonardo has TX->1 on Serial1, not Serial.
#else
#define SabertoothTXPinSerial Serial3
#endif

Phase 2 : Commande des 2 moteurs sous Arduino avec ROS:

Voici le programme Arduino:

#define nullptr NULL

#include <ros.h>
#include <std_msgs/Int16.h>

#include <Sabertooth.h>

Sabertooth ST(128, Serial3); // The Sabertooth is on address 128. We'll name its object ST.
                    // If you've set up your Sabertooth on a different address, of course change
                    // that here. For how to configure address, etc. see the DIP Switch Wizard for
                    //   Sabertooth - http://www.dimensionengineering.com/datasheets/SabertoothDIPWizard/start.htm
                    //   SyRen      - http://www.dimensionengineering.com/datasheets/SyrenDIPWizard/start.htm
//adresse Sabertooth est 128
// Port TX3

ros::NodeHandle nh;

// Variables pour stocker les commandes des moteurs
int motor1_speed = 0;
int motor2_speed = 0;

// Callback pour le moteur 1
void motor1Callback(const std_msgs::Int16& cmd_msg) {
  motor1_speed = constrain(cmd_msg.data, -127, 127); // Limiter entre -127 et 127
  sendMotorCommand(1, motor1_speed);
}

// Callback pour le moteur 2
void motor2Callback(const std_msgs::Int16& cmd_msg) {
  motor2_speed = constrain(cmd_msg.data, -127, 127); // Limiter entre -127 et 127
  sendMotorCommand(2, motor2_speed);
}

// Fonction pour envoyer une commande à la Sabertooth
void sendMotorCommand(int motor, int speed) {

  ST.motor(motor, speed);
  delay(10);
}

ros::Subscriber<std_msgs::Int16> motor1_sub("motor1_speed", motor1Callback);
ros::Subscriber<std_msgs::Int16> motor2_sub("motor2_speed", motor2Callback);

void setup()
{
  SabertoothTXPinSerial.begin(9600); // 9600 is the default baud rate for Sabertooth packet serial.
  ST.autobaud(); // Send the autobaud command to the Sabertooth controller(s).
                 // NOTE: *Not all* Sabertooth controllers need this command.
                 //       It doesn't hurt anything, but V2 controllers use an
                 //       EEPROM setting (changeable with the function setBaudRate) to set
                 //       the baud rate instead of detecting with autobaud.
                 //
                 //       If you have a 2x12, 2x25 V2, 2x60 or SyRen 50, you can remove
                 //       the autobaud line and save yourself two seconds of startup delay.
  // Initialiser le nœud ROS
  nh.initNode();
  nh.subscribe(motor1_sub);
  nh.subscribe(motor2_sub);
}

void loop()
{
    nh.spinOnce(); // Processus des messages ROS
  delay(10);

}

Notes:

1. Il y a 2 subscribers: motor1_sub et motor2_sub qui attendent un entier sur 16 bits (de -32,768 à +32,767).
2. ros::Subscriber<std_msgs::Int16> motor1_sub("motor1_speed", motor1Callback);
   1. 1. Crée un subscriber ROS nommé motor1_sub.
      2. Écoute le topic "motor1_speed".
      3. Déclenche la fonction motor1Callback chaque fois qu’un message de type std_msgs::Int16 est reçu.
      4. Permet de traiter les commandes pour le moteur 1, en relayant les données vers la Sabertooth.
3. motor1_speed = constrain(cmd_msg.data, -127, 127); // Limiter entre -127 et 127
   1. 1. La liaison série de la Sabertooth (en mode simplifié (simplified serial mode)) accepte 1 octet pour la vitesse:
      2. 8 bits (0 à 256)  avec 0 pour arrêt et 256 pour la vitesse maximale dans un sens
      3. 8 bits (-127 à +127)  avec 0 pour arrêt et -127 pour la vitesse maximale dans un sens et +127 pour la vitesse maximale dans l'autre sens
4. void motor1Callback(const std_msgs::Int16& cmd_msg)
   1. 1. Déclare une fonction appelée chaque fois qu’un message est reçu sur le topic correspondant.
      2. Elle reçoit comme paramètre une référence constante au message de type std_msgs::Int16.
      3. Le champ cmd_msg.data contient la donnée utile (valeur de vitesse pour le moteur 1).
      4. La fonction peut alors utiliser cette donnée pour effectuer une action, comme commander un moteur.

Ouvrez une fenêtre de terminal (Ctrl+Alt+T): roscore

Ouvrez un nouvel onglet dans votre terminal (Ctrl+Shift+T): rosrun rosserial_python serial_node.py /dev/ttyACM0

Ouvrez un nouvel onglet dans votre terminal (Ctrl+Shift+T): rostopic list et vous devez voie apparaître les 2 topics:
[INFO] [1731855306.441580]: Setup subscriber on motor1_speed [std_msgs/Int16]
[INFO] [1731855306.453146]: Setup subscriber on motor2_speed [std_msgs/Int16]

Ouvrez un nouvel onglet dans votre terminal (Ctrl+Shift+T): rostopic pub /motor1_speed std_msgs/Int16 "data: 50"

Ouvrez un nouvel onglet dans votre terminal (Ctrl+Shift+T): rostopic pub /motor2_speed std_msgs/Int16 "data: 50"

 

Voir les 2 topics (motor1_speed et motor2_speed) et le noeud serial_node:

Ouvrez un nouvel onglet dans votre terminal (Ctrl+Shift+T): rostopic list ou mieux,

Ouvrez un nouvel onglet dans votre terminal (Ctrl+Shift+T): rqt_graph

Maintenant, il est envisageable de créer une application python (avec tkinter par exemple) pour publier la vitesse des 2 moteurs ou, de piloter le robot Dagu avec une manette de jeu....