Cours:SaeRobotique : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(Répéter une action régulièrement)
(Diagramme d'état)
 
(55 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
https://www.youtube.com/watch?v=xH8EIqh-2_Y
 
  
 
[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]
 
[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]
  
=Organisation=
 
  
*Fonctionnement en trinôme sur 12 jours
+
[[Cours:SaeRobotiqueSuiviLigne]]
*{{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
 
  
=Tâches élémentaires (4 jours)=
 
  
 +
[[Cours:SaeRobotiqueTennis]]
  
* Trois tâches principales (déplacements) : un étudiant sur chaque tâche
 
** aller vers la balle (caméra Pixy)
 
** détecter les lignes (suivre petites lignes, s’arrêter sur ligne centrale) : capteurs de ligne => carte à faire (prototypage puis shield)
 
** s’orienter : magnétomètre (MPU9250)
 
  
* À faire globalement : câblage robot, sécurité
+
=Ressources communes=
 
 
==Livrable==
 
* faire des recherches pour rendre un dossier (pour le lundi qui suit) expliquant : le pont en H, schéma sécurité et chaque partie (a, b, c)
 
* mini-concours à la fin des quatre jours :
 
** traversée la plus rapide en ligne droite (avec magnéto)
 
** aller vers la balle le plus rapidement possible
 
** suivre ligne et stop ligne centrale le plus rapidement possible
 
 
 
=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 ==
 
 
 
* À la fin du premier jour :
 
** donner une organisation (en tâches, qui fait quoi)
 
* Rapport final :
 
** '''À envoyer au format pdf par mail avant le jeudi 9 juin 12h'''
 
** 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.
 
 
 
=Ressources=
 
  
 
==structure du programme==
 
==structure du programme==
Ligne 76 : 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 109 : 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 121 : Ligne 65 :
  
 
===Répéter une action régulièrement===
 
===Répéter une action régulièrement===
 +
{| class="wikitable"
 +
|-
 +
|
 
<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>
 +
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;
 +
  }
 +
}
 +
</source>
 +
|}
  
 
===Affichage provisoire pour deboggage===
 
===Affichage provisoire pour deboggage===
  
 +
 +
{|
 +
|-
 +
|
 
<source lang=cpp>
 
<source lang=cpp>
#define debugg   // mode debugg
+
#define debug   // mode debug
//#define debugg // mode sans debugg
+
//ou
 +
#undef debug // mode sans debug
  
void loop()
+
int main()
 
{
 
{
  #ifdef debugg
+
  ...
       Serial.println("juste si debugg");
+
  while(1)
  #endif
+
  {
 +
    #ifdef debug
 +
       Serial.println("juste si debug");
 +
    #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>
*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
 
**CNY70
 
***http://pierrecaulet.free.fr/Stage_BEN_02-20020/_%20Stage_02_2020_Seance-04/Detection_IR/index_IR.html
 
***http://electro.patgue.com/Ressources_isi2/Robot%20ISI2%20Etude%20du%20capteur.pdf
 
**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]]
 
*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 :
 
**** attendre que la fonction mpu.available() renvoie ''true''
 
**** appel de la fonction update_mag()
 
**** puis appel des fonctions getMagX() et getMagY() pour récupérer les composantes x et y. L'angle vers le nord magnétique est obtenu avec l'inverse de la tangente (attention au signe)
 
*Robot Arrex :
 
** [[Cours:RobotArrex]] (section documents)
 
** avec shield moteur
 
 
 
==liens==
 
  
*[[Media:Coupe_GEII_-_Règlement_-_2020.pdf| règlement de la coupe de robotique]]
+
==Diagramme d'état==
  
==Composants eagle==
+
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 :
  
{| class="wikitable sortable"
+
[[Media:TestFiniteStateMachine.zip]]
|-
 
! Type !! Composant/Boitier !! Librairie Eagle !! Référence eagle
 
|-
 
| Résistance || CMS : 1206 || rcl || R-EU_R1206
 
|-
 
| Photocoupleur || CNY70 || CNY70 ||  CNY70
 
  
|-
+
==Composants Kicad==
| 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
+
*Résistances :
*[[Media:Troyesgeii.lbr]] : Divers composants utilisés en ER.
+
**symbole R
*[[Media:LibrairieEagleAdafruit.lbr]] : librairie du site http://www.adafruit.com/
+
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*[[Media:Connector.lbr]] : librairie connecteurs
+
*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

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