Cours:SaeRobotique : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(Diagramme d'état)
 
(106 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
=Cahier des charges=
 
  
* Fonctionnement en trinôme sur 12 jours (préparer des groupes de niveaux)
+
[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]
* De 9h-12h / 14h-17h, sauf jeudi 9h-12h uniquement
 
  
=Tâches élémentaires (4 jours)=
 
  
-> ajouter liste matériel avec liens vers doc
+
[[Cours:SaeRobotiqueSuiviLigne]]
  
* Trois tâches principales (déplacements) : un étudiant sur chaque tâche
 
** aller vers la balle : caméra
 
** 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
 
  
* À faire globalement : câblage robot, sécurité
+
[[Cours:SaeRobotiqueTennis]]
  
==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"=
+
=Ressources communes=
  
Point de départ sur Arduino Uno : éventuellement switcher si besoin.
+
==structure du programme==
  
==Tâches matérielles (8 jours)==
+
Vous pourrez utiliser la structure de programme suivante :
  
(Logiciel fabrication : freecad ou openscad. Leur faire une démonstration (2 heures env.)
+
<source lang=cpp>
 +
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};
  
* 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
+
state etapeSuivante=etapeInit;
* système perçage ballon
+
state etapeActive=etapeInit;
* 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)
+
int main()
 +
{
 +
  while(1)
 +
  {
 +
    // lecture des capteurs en début de boucle
 +
    switch (etapeActive)
 +
    {
 +
      case etapeInit:
  
== Livrable ==
+
            // si ... etapeSuivante=
 +
            break;
 +
      case etapeChercheBalle:
  
* À la fin du premier jour :
+
            // si ... etapeSuivante=
** donner une organisation (en tâches, qui fait quoi)
+
            break;
* Rapport :
+
      case etapeDeplacementVersBalle:
** 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).
 
  
=Ressources=
+
            // si ... etapeSuivante=
*[[Media:Coupe_GEII_-_Règlement_-_2020.pdf| règlement de la coupe de robotique]]
+
            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>
 +
while(1)
 +
{
 +
  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 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
 +
    }
 +
  }
 +
}
 +
</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===
 +
 
 +
 
 +
{|
 +
|-
 +
|
 +
<source lang=cpp>
 +
#define debug  // mode debug
 +
//ou
 +
#undef debug // mode sans debug
 +
 
 +
int main()
 +
{
 +
  ...
 +
  while(1)
 +
  {
 +
    #ifdef debug
 +
      Serial.println("juste si debug");
 +
    #endif
 +
  }
 +
}
 +
 
 +
</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");
 +
  }
 +
}
 +
 
 +
</source>
 +
|}
 +
 
 +
==Diagramme d'état==
 +
 
 +
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 :
 +
 
 +
[[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

Version actuelle datée du 9 juin 2024 à 15: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