Cours:SaeRobotique : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(Diagramme d'état)
 
(10 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 2 : Ligne 2 :
 
[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]
 
[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]
  
=Evaluations=
 
  
==2ème évaluation==
+
[[Cours:SaeRobotiqueSuiviLigne]]
  
La 2ème évaluation portera sur :
 
*l'assemblage de votre robot :
 
**aspect mécanique (propulseur principalement)
 
**aspect électrique
 
***cartes fabriquées
 
***câblage
 
*la "fusion" de l'étude de la 1ère semaine avec un robot qui devra
 
**{{Rouge|au strict minimum}}
 
***se déplacer(suivre) vers une balle pendant un certain temps
 
***ensuite se tourner vers le terrain adverse
 
***avancer en direction du terrain adverse jusqu'à la ligne du milieu
 
***s'arrêter sur la ligne du milieu
 
**{{Rouge|pour obtenir la note maximum}}
 
***attendre l'appui sur un bouton pour que le robot démarre
 
***chercher une balle
 
***se déplacer(suivre) vers la balle
 
***attraper la balle
 
***s'orienter vers le terrain adverse
 
***propulser la balle dans le terrain adverse
 
***avancer jusqu'à la ligne centrale
 
***s'arrêter
 
  
 +
[[Cours:SaeRobotiqueTennis]]
  
=Robot "joueur de tennis"=
 
  
 
+
=Ressources communes=
==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 15 juin pour le groupe 1'''
 
** 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==
 
==structure du programme==
Ligne 89 : Ligne 22 :
  
  
void setup() {
+
int main()
 
+
{
}
+
   while(1)
 
 
void loop() {
 
 
 
  // lecture des capteurs
 
 
 
   switch (etapeActive)
 
 
   {
 
   {
     case etapeInit:
+
     // lecture des capteurs en début de boucle
 +
    switch (etapeActive)
 +
    {
 +
      case etapeInit:
  
 
             // si ... etapeSuivante=
 
             // si ... etapeSuivante=
 
             break;
 
             break;
    case etapeChercheBalle:
+
      case etapeChercheBalle:
  
 
             // si ... etapeSuivante=
 
             // si ... etapeSuivante=
 
             break;
 
             break;
    case etapeDeplacementVersBalle:
+
      case etapeDeplacementVersBalle:
  
 
             // si ... etapeSuivante=
 
             // si ... etapeSuivante=
 
             break;
 
             break;
 +
    }
 +
 +
    // on modifie l'étape active pour la prochaine boucle
 +
    etapeActive=etapeSuivante;
 
   }
 
   }
 
  // on modifie l'étape active pour la prochaine boucle
 
  etapeActive=etapeSuivante;
 
 
}
 
}
 
</source>
 
</source>
Ligne 122 : Ligne 53 :
 
===Exécuter une action une seule fois :===
 
===Exécuter une action une seule fois :===
 
<source lang=cpp>
 
<source lang=cpp>
void loop()
+
while(1)
 
{
 
{
 
   static bool dejaFait=false;
 
   static bool dejaFait=false;
Ligne 138 : Ligne 69 :
 
|
 
|
 
<source lang=cpp>
 
<source lang=cpp>
void loop()
+
void initFonctionsTempsArduino()
 
{
 
{
  static uint32_t triggerTime=millis();
+
  sei();
  uint32_t currentTime=millis();
+
  // marche pour 328p et 2560 et autres ...
 +
  // à adapter suivant le µc
 +
  // cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
 +
  TCCR0A=(1<<WGM01)|(1<<WGM00);
 +
  TCCR0B=(1<<CS01)|(1<<CS00);
 +
  TIMSK0=(1<<TOIE0);
 +
}
  
  if (currentTime>=triggerTime)
+
int main()
  {
+
{
 +
  initFonctionsTempsArduino();
 +
  while(1)
 +
  {
 +
    static uint32_t triggerTime=millis();
 +
    uint32_t currentTime=millis();
 +
    if (currentTime>=triggerTime)
 +
    {
 
       faireMonAction();
 
       faireMonAction();
 
       triggerTime += 500; // prochaine exécution dans 500ms
 
       triggerTime += 500; // prochaine exécution dans 500ms
  }
+
    }
 +
  }
 
}
 
}
 
</source>
 
</source>
 
||
 
||
 
<source lang=cpp>
 
<source lang=cpp>
void loop()
+
void initFonctionsTempsArduino()
 
{
 
{
  static uint32_t triggerTime=0;
+
  sei();
  uint32_t currentTime=millis();
+
  // marche pour 328p et 2560 et autres ...
 +
  // à adapter suivant le µc
 +
  // cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
 +
  TCCR0A=(1<<WGM01)|(1<<WGM00);
 +
  TCCR0B=(1<<CS01)|(1<<CS00);
 +
  TIMSK0=(1<<TOIE0);
 +
}
  
   switch (etapeActive)
+
int main()
 +
{
 +
  initFonctionsTempsArduino();
 +
   while(1)
 
   {
 
   {
     ....
+
     static uint32_t triggerTime=0;
     case etapeX:
+
     uint32_t currentTime=millis();
 +
 
 +
    switch (etapeActive)
 +
    {
 +
      case etapeX:
 
             if ( qqch)
 
             if ( qqch)
 
             {
 
             {
Ligne 167 : Ligne 125 :
 
             }
 
             }
 
             break;
 
             break;
    case etapeY:
+
      case etapeY:
 
             if ( currentTime >= (triggerTime + duree ) )
 
             if ( currentTime >= (triggerTime + duree ) )
 
             {
 
             {
Ligne 173 : Ligne 131 :
 
             }
 
             }
 
             break;
 
             break;
    case etapeZ:
+
      case etapeZ:
 
             ...
 
             ...
 
             break;
 
             break;
 +
    }
 +
    etapeActive=etapeSuivante;
 
   }
 
   }
  etapeActive=etapeSuivante;
 
 
}
 
}
 
</source>
 
</source>
Ligne 184 : Ligne 143 :
 
===Affichage provisoire pour deboggage===
 
===Affichage provisoire pour deboggage===
  
 +
 +
{|
 +
|-
 +
|
 
<source lang=cpp>
 
<source lang=cpp>
 
#define debug  // mode debug
 
#define debug  // mode debug
Ligne 189 : Ligne 152 :
 
#undef debug // mode sans debug
 
#undef debug // mode sans debug
  
void loop()
+
int main()
 
{
 
{
  #ifdef debug
+
  ...
 +
  while(1)
 +
  {
 +
    #ifdef debug
 
       Serial.println("juste si debug");
 
       Serial.println("juste si debug");
  #endif
+
    #endif
 +
  }
 
}
 
}
  
 
</source>
 
</source>
 +
||
 +
<source lang=cpp>
 +
#define DEBUG  //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
 +
#ifdef DEBUG    //Macros are usually in all capital letters.
 +
  #define DEBUG_PRINT(...)    Serial.print(__VA_ARGS__)    //DEBUG_PRINT is a macro, debug print
 +
  #define DEBUG_PRINTLN(...)  Serial.println(__VA_ARGS__)  //DEBUG_PRINTLN is a macro, debug print with new line
 +
#else
 +
  #define DEBUG_PRINT(...)    //now defines a blank line
 +
  #define DEBUG_PRINTLN(...)  //now defines a blank line
 +
#endif
 +
int main()
 +
{
 +
  while(1)
 +
  {
 +
    DEBUG_PRINTLN("juste si debug");
 +
  }
 +
}
  
==Composants/cartes==
+
</source>
*[[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) ==
+
==Diagramme d'état==
* 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]]
+
Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :
*[[Cours:archive SAÉ suivi de ligne]]
+
 
*https://www.youtube.com/watch?v=xH8EIqh-2_Y
+
[[Media:TestFiniteStateMachine.zip]]
  
 
==Composants Kicad==
 
==Composants Kicad==
Ligne 268 : Ligne 208 :
 
****rotation Z 90
 
****rotation Z 90
 
****décalage Z 2,5mm
 
****décalage Z 2,5mm
 
==Composants eagle==
 
 
{| class="wikitable sortable"
 
|-
 
! Type !! Composant/Boitier !! Librairie Eagle !! Référence eagle
 
|-
 
| Résistance || CMS : 1206 || rcl || R-EU_R1206
 
|-
 
| Photocoupleur || CNY70 || CNY70 ||  CNY70
 
 
|-
 
| Led || 5mm ou 3mm || led || LED5MM ou LED3MM
 
|-
 
| Connecteur || barrette femelle sécable || con-lstb || MA06-1
 
|-
 
| Connecteur grove || carte driver moteur ... || Connector || TWIG-4P-2.0
 
|}
 
 
*[[Media:CNY70.lbr]] : librairie pour le photocoupleur par réflexion CNY70
 
*[[Media:Troyesgeii.lbr]] : Divers composants utilisés en ER.
 
*[[Media:LibrairieEagleAdafruit.lbr]] : librairie du site http://www.adafruit.com/
 
*[[Media:Connector.lbr]] : librairie connecteurs
 

Version actuelle datée du 9 juin 2024 à 16:50

Corrections enseignants


Cours:SaeRobotiqueSuiviLigne


Cours:SaeRobotiqueTennis


Ressources communes

structure du programme

Vous pourrez utiliser la structure de programme suivante :

enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;


int main()
{
  while(1)
  {
    // lecture des capteurs en début de boucle
    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 :

while(1)
{
   static bool dejaFait=false;
   if (dejaFait==false)
   {
      executerMonAction();
      dejaFait=true;
   }
}

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

void initFonctionsTempsArduino()
{
  sei();
  // marche pour 328p et 2560 et autres ...
  // à adapter suivant le µc
  // cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
  TCCR0A=(1<<WGM01)|(1<<WGM00);
  TCCR0B=(1<<CS01)|(1<<CS00);
  TIMSK0=(1<<TOIE0);
}

int main()
{
  initFonctionsTempsArduino();
  while(1)
  {
    static uint32_t triggerTime=millis();
    uint32_t currentTime=millis();
    if (currentTime>=triggerTime)
    {
       faireMonAction();
       triggerTime += 500; // prochaine exécution dans 500ms
    }
  }
}
void initFonctionsTempsArduino()
{
  sei();
  // marche pour 328p et 2560 et autres ...
  // à adapter suivant le µc
  // cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
  TCCR0A=(1<<WGM01)|(1<<WGM00);
  TCCR0B=(1<<CS01)|(1<<CS00);
  TIMSK0=(1<<TOIE0);
}

int main()
{
  initFonctionsTempsArduino();
  while(1)
  {
    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

int main()
{
  ...
  while(1)
  {
    #ifdef debug
       Serial.println("juste si debug");
    #endif
  }
}
#define DEBUG   //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG    //Macros are usually in all capital letters.
   #define DEBUG_PRINT(...)    Serial.print(__VA_ARGS__)     //DEBUG_PRINT is a macro, debug print
   #define DEBUG_PRINTLN(...)  Serial.println(__VA_ARGS__)   //DEBUG_PRINTLN is a macro, debug print with new line
#else
   #define DEBUG_PRINT(...)     //now defines a blank line
   #define DEBUG_PRINTLN(...)   //now defines a blank line
#endif
int main()
{
  while(1)
  {
    DEBUG_PRINTLN("juste si debug");
  }
}

Diagramme d'état

Pour aller plus loin dans la programmation sous forme de machine à état fini, vous utiliserez comme base le programme suivant :

Media:TestFiniteStateMachine.zip

Composants Kicad

  • Résistances :
    • symbole R
    • boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
  • Condensateur
    • symbole C
    • boitier suivant la valeur 1206(CMS)
  • Arduino Nano
    • symbole Arduino_Nano_v2.x
    • modèle 3d
      • télécharger et décompresser : Media:Arduino_nano.STEP.zip
      • dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
        • ajouter le fichier téléchargé
        • rotation X -90
        • rotation Z 90
        • décalage Z 2,5mm