Cours:SaeRobotiqueSuiviLigne : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(Page créée avec « = Séquence 1 : tâches élémentaires individuelles = * Tâches de suivi de ligne (un étudiant sur chaque tâche) : ** suivi avec caméra Pixy ** suivi avec capteurs ph... »)
 
Ligne 45 : Ligne 45 :
 
** Mini-concours à la fin pour sélectionner le meilleur robot (évaluation des capacités du robot, par étudiant en fonction de l'organisation prévue).
 
** Mini-concours à la fin pour sélectionner le meilleur robot (évaluation des capacités du robot, par étudiant en fonction de l'organisation prévue).
 
** Chiffrage incluant le matériel ainsi que les ressources humaines.
 
** Chiffrage incluant le matériel ainsi que les ressources humaines.
 +
 +
 +
 +
=Robot "joueur de tennis"=
 +
 +
 +
==Tâches matérielles (8 jours)==
 +
 +
 +
 +
* mat pour tenir ballon : on donne un tube (32) à couper (prévoir boite à onglet et scie) avec la base et les étudiants doivent fabriquer le support ballon
 +
* système perçage ballon
 +
* système démarrage avec ficelle à tirer
 +
* système détection murs : choix du capteur distance avec liste donnée (ultrason, lidar ou infrarouge)
 +
* fabrication shield pour Arduino Uno
 +
 +
== Tâches logicielles==
 +
(1 étudiant sur chaque étape)
 +
# Localiser balle avec caméra Pixy
 +
# Attraper balle (détection opto)
 +
# Renvoyer balle dans le camp adverse en s’orientant avec magnétomètre
 +
# Recommencer
 +
Codage des tâches en explicitant la structure du programme
 +
 +
* Ajouter transmission sans fil pour supervision/débogage (Xbee ou HF) : affichage sur terminal pc de l’étape en cours (et éventuellement état de variables)
 +
 +
== Livrable ==
 +
 +
* Rapport final :
 +
** '''À envoyer au format pdf par mail avant le 27 juin 23h59'''
 +
** Description du problème posé en introduction
 +
** Diagramme de Gantt
 +
** diagramme algorithme général
 +
** stratégie de résolution et description de chaque tâche :
 +
** Chiffrage incluant le matériel ainsi que les ressources humaines.
 +
** Évolution possible
 +
** Conclusion
 +
 +
=Organisation=
 +
 +
*Fonctionnement en trinôme sur 12 jours
 +
**9h-12h
 +
**13h30-16h30
 +
*{{Rouge|Compte rendu écrit quotidien individuel}}
 +
**sera contrôlé chaque matin
 +
**doit indiquer les tâches réalisées la veille
 +
**doit indiquer le travail à réaliser le jour même
 +
 +
 +
 +
=Ressources=
 +
 +
==structure du programme==
 +
 +
Vous pourrez utiliser la structure de programme suivante :
 +
 +
<source lang=cpp>
 +
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};
 +
 +
state etapeSuivante=etapeInit;
 +
state etapeActive=etapeInit;
 +
 +
 +
void setup() {
 +
 +
}
 +
 +
void loop() {
 +
 +
  // lecture des capteurs
 +
 +
  switch (etapeActive)
 +
  {
 +
    case etapeInit:
 +
 +
            // si ... etapeSuivante=
 +
            break;
 +
    case etapeChercheBalle:
 +
 +
            // si ... etapeSuivante=
 +
            break;
 +
    case etapeDeplacementVersBalle:
 +
 +
            // si ... etapeSuivante=
 +
            break;
 +
  }
 +
 +
  // on modifie l'étape active pour la prochaine boucle
 +
  etapeActive=etapeSuivante;
 +
}
 +
</source>
 +
 +
==Programmation : comment faire==
 +
 +
===Exécuter une action une seule fois :===
 +
<source lang=cpp>
 +
void loop()
 +
{
 +
  static bool dejaFait=false;
 +
  if (dejaFait==false)
 +
  {
 +
      executerMonAction();
 +
      dejaFait=true;
 +
  }
 +
}
 +
</source>
 +
 +
===Répéter une action régulièrement===
 +
{| class="wikitable"
 +
|-
 +
|
 +
<source lang=cpp>
 +
void loop()
 +
{
 +
  static uint32_t triggerTime=millis();
 +
  uint32_t currentTime=millis();
 +
 +
  if (currentTime>=triggerTime)
 +
  {
 +
      faireMonAction();
 +
      triggerTime += 500; // prochaine exécution dans 500ms
 +
  }
 +
}
 +
</source>
 +
||
 +
<source lang=cpp>
 +
void loop()
 +
{
 +
  static uint32_t triggerTime=0;
 +
  uint32_t currentTime=millis();
 +
 +
  switch (etapeActive)
 +
  {
 +
    ....
 +
    case etapeX:
 +
            if ( qqch)
 +
            {
 +
              etapeSuivante=etapeY;
 +
              triggerTime=currentTime;
 +
            }
 +
            break;
 +
    case etapeY:
 +
            if ( currentTime >= (triggerTime + duree ) )
 +
            {
 +
              etapeSuivante=etapeZ;
 +
            }
 +
            break;
 +
    case etapeZ:
 +
            ...
 +
            break;
 +
  }
 +
  etapeActive=etapeSuivante;
 +
}
 +
</source>
 +
|}
 +
 +
===Affichage provisoire pour deboggage===
 +
 +
<source lang=cpp>
 +
#define debug  // mode debug
 +
//ou
 +
#undef debug // mode sans debug
 +
 +
void loop()
 +
{
 +
  #ifdef debug
 +
      Serial.println("juste si debug");
 +
  #endif
 +
}
 +
 +
</source>
 +
 +
==Composants/cartes==
 +
*[[Cours:capteurPhotoReflectif|capteur '''photoréflectif''' pour détection de la {{Rouge|ligne}}]]
 +
*Batterie LiFePo4
 +
**assemblage de 4 éléments LiFePo4
 +
**documentation sur les cellules [[Media:CellulesLiFePo4.pdf]]
 +
**tensions à ne pas dépasser :
 +
***maximum : 3,45V/élément
 +
***minimum : 2,65V/élément
 +
***ne pas démarrer le robot : 2,85V/élément
 +
*divers
 +
**Commutateur d'arrêt d'urgence https://fr.farnell.com/idec/yw1b-v4e01r/commut-bp-e-stop-spst-nc-10a-120v/dp/2833849?ost=2833849
 +
**Régulateur ajustable 1,25 à 30 Vcc https://www.gotronic.fr/art-regulateur-ajustable-1-25-a-30-vcc-gt134-26094.htm
 +
*driver de moteur
 +
**https://www.cytron.io/p-13amp-6v-30v-dc-motor-driver
 +
*capteurs de distance/contact
 +
**HC-SR04  cf fiche technique sur la page : https://www.gotronic.fr/art-module-de-detection-us-hc-sr04-20912.htm
 +
**VL53L1X
 +
***https://www.robotshop.com/eu/fr/platine-deploiement-capteur-distance-tof-regulateur-tension-vl53l1x.html
 +
***https://github.com/pololu/vl53l1x-arduino
 +
**Mini Microrupteur - SPDT https://www.robotshop.com/eu/fr/mini-microrupteur-spdt-levier-rouleau.html
 +
**GP2Yxxxx https://www.gotronic.fr/art-capteur-de-mesure-sharp-gp2y0a41sk0f-18338.htm
 +
**lidar tfmini-s
 +
***https://www.robotshop.com/eu/fr/module-micro-lidar-tfmini-s-benewake-i2c-12m.html
 +
***https://www.arduino.cc/reference/en/libraries/tfmpi2c/
 +
**lidar Lite 3
 +
***https://www.robotshop.com/eu/fr/capteur-distance-laser-haute-performance-lidar-lite-3-llv3hp.html
 +
***https://github.com/RobotShop/LIDARLite_v3_Arduino_Library
 +
*caméra
 +
**pixyv2
 +
***https://pixycam.com/pixy2/
 +
***[[Cours:TPS_2103_tp_pixy|TP caméra pixy]]
 +
***Avoir un PixyMon plus rapide dans la g.008 :
 +
****utiliser un 2ème poste
 +
****ne pas se connecter sur nomachine
 +
****lancer un terminal
 +
****lancer la commande PixyMon
 +
*IMU
 +
**Explications du principe du capteur mpu9250 : https://learn.sparkfun.com/tutorials/mpu-9250-hookup-guide/all
 +
**Bibliothèque à utiliser : dans le gestionnaire de bibliothèque => ''by hideakitai'' (v 0.4.8) ou https://github.com/hideakitai/MPU9250
 +
**Étapes :
 +
***Réaliser la calibration et noter les valeurs affichées,
 +
***les entrer dans votre programme (fonctions setMagBias() et setMagScale()
 +
***Pour réaliser une mesure, se servir des programmes d'exemples
 +
*Robot Arrex :
 +
** [[Cours:RobotArrex]] (section documents)
 +
** avec shield moteur
 +
 +
==liens (dont règlement concours) ==
 +
* concours robotique Cachan, lien vers le règlement en pdf : https://robotique-iut-2023.sciencesconf.org/data/pages/Reglement_rencontres_de_robotique_GEII_8_9_10_juin_2023_BUT1.pdf
 +
*[[Cours:archive SAÉ robot joueur de tennis]]
 +
*[[Cours:archive SAÉ suivi de ligne]]
 +
*https://www.youtube.com/watch?v=xH8EIqh-2_Y

Version du 13 mai 2024 à 10:25

Séquence 1 : tâches élémentaires individuelles

  • Tâches de suivi de ligne (un étudiant sur chaque tâche) :
    • suivi avec caméra Pixy
    • suivi avec capteurs photorélectifs (nombre de capteurs à choisir)
    • suivi avec Lidar, en suivant un mur sur le côté
  • s'arrêter à la fin du parcours
  • À faire globalement : câblage robot, sécurité

Livrable 1

  • faire des recherches pour rendre un dossier par groupe (pour mardi 30/05) expliquant : le pont en H, schéma sécurité et chaque partie (a, b, c)
  • évaluation le 26/05 (code + questions + fonctionnement)

Séquence 2 : tâches complexes individuelles + réalisation shield

  • Tâches de suivi
    • Caméra Pixy : gestion des intersections (comportement programmé, par ex : droite puis gauche puis tout droit)
    • Capteurs photoréflectifs : détection de marques à droite (si marque : on tourne à droite à l'intersection, sinon tout droit). Détection des marques à gauche : stop et recul pendant 1 seconde (environ) et on repart (pas d'arrêt sur le second passage)
    • Lidar : suivi de mur à gauche ET à droite (priorité en suivi à droite). Faire tomber une première barre, pas la seconde.
  • Trois cartes à réaliser (une par étudiant)
    • carte avec capteurs photoreflectifs
    • carte pour détection marques gauches et droites
    • carte shield arduino nano

Note : penser à laisser libres PB3, PB4, PB5 et PB6 pour la Pixy (connecteur ICSP, cf https://commons.wikimedia.org/wiki/File:Arduino-nano-pinout.png )

Livrable 2

  • évaluation le 05/06 (code + questions + fonctionnement)

Séquence 3 : Fusion des trois tâches et programmation globale

Livrable 3

Rapport final

  • Rapport final :
    • À envoyer au format pdf par mail avant le DD/MM/YY à HH
    • Diagramme de Gantt
    • diagramme algorithme général
    • stratégie de résolution de chaque tâche
    • Mini-concours à la fin pour sélectionner le meilleur robot (évaluation des capacités du robot, par étudiant en fonction de l'organisation prévue).
    • Chiffrage incluant le matériel ainsi que les ressources humaines.


Robot "joueur de tennis"

Tâches matérielles (8 jours)

  • mat pour tenir ballon : on donne un tube (32) à couper (prévoir boite à onglet et scie) avec la base et les étudiants doivent fabriquer le support ballon
  • système perçage ballon
  • système démarrage avec ficelle à tirer
  • système détection murs : choix du capteur distance avec liste donnée (ultrason, lidar ou infrarouge)
  • fabrication shield pour Arduino Uno

Tâches logicielles

(1 étudiant sur chaque étape)

  1. Localiser balle avec caméra Pixy
  2. Attraper balle (détection opto)
  3. Renvoyer balle dans le camp adverse en s’orientant avec magnétomètre
  4. Recommencer

Codage des tâches en explicitant la structure du programme

  • Ajouter transmission sans fil pour supervision/débogage (Xbee ou HF) : affichage sur terminal pc de l’étape en cours (et éventuellement état de variables)

Livrable

  • Rapport final :
    • À envoyer au format pdf par mail avant le 27 juin 23h59
    • Description du problème posé en introduction
    • Diagramme de Gantt
    • diagramme algorithme général
    • stratégie de résolution et description de chaque tâche :
    • Chiffrage incluant le matériel ainsi que les ressources humaines.
    • Évolution possible
    • Conclusion

Organisation

  • Fonctionnement en trinôme sur 12 jours
    • 9h-12h
    • 13h30-16h30
  • Compte rendu écrit quotidien individuel
    • sera contrôlé chaque matin
    • doit indiquer les tâches réalisées la veille
    • doit indiquer le travail à réaliser le jour même


Ressources

structure du programme

Vous pourrez utiliser la structure de programme suivante : 

enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;


void setup() {

}

void loop() {

  // lecture des capteurs

  switch (etapeActive)
  {
    case etapeInit:

            // si ... etapeSuivante=
            break;
    case etapeChercheBalle:

            // si ... etapeSuivante=
            break;
    case etapeDeplacementVersBalle:

            // si ... etapeSuivante=
            break;
  }

  // on modifie l'étape active pour la prochaine boucle
  etapeActive=etapeSuivante;
}

Programmation : comment faire

Exécuter une action une seule fois :

void loop()
{
   static bool dejaFait=false;
   if (dejaFait==false)
   {
      executerMonAction();
      dejaFait=true;
   }
}

Répéter une action régulièrement

void loop()
{
   static uint32_t triggerTime=millis();
   uint32_t currentTime=millis();

   if (currentTime>=triggerTime)
   {
       faireMonAction();
       triggerTime += 500; // prochaine exécution dans 500ms
   }
}

void loop()
{
   static uint32_t triggerTime=0;
   uint32_t currentTime=millis();

  switch (etapeActive)
  {
    ....
    case etapeX:
            if ( qqch)
            {
               etapeSuivante=etapeY;
               triggerTime=currentTime;
            }
            break;
    case etapeY:
            if ( currentTime >= (triggerTime + duree ) )
            {
               etapeSuivante=etapeZ;
            }
            break;
    case etapeZ:
            ...
            break;
  }
  etapeActive=etapeSuivante;
}

Affichage provisoire pour deboggage

#define debug   // mode debug
//ou
#undef debug // mode sans debug

void loop()
{
   #ifdef debug
       Serial.println("juste si debug");
   #endif
}

Composants/cartes

liens (dont règlement concours)

Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeRobotiqueSuiviLigne&oldid=18928 »