Cours:SaeRobotiqueSuiviLigne : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(→‎Utiliser des librairies arduino avec un main)
(→‎Utiliser des librairies arduino avec un main)
Ligne 32 : Ligne 32 :
 
   }
 
   }
 
}
 
}
 +
</source>
 +
 +
 +
Exemple pour le capteur vl53l1x :
 +
 +
<source lang=cpp>
 +
/*
 +
This example shows how to take simple range measurements with the VL53L1X. The
 +
range readings are in units of mm.
 +
*/
 +
 +
#include <Wire.h>
 +
#include <VL53L1X.h>
 +
 +
VL53L1X sensor;
 +
 +
void initFonctionsTempsArduino()
 +
{
 +
  sei();
 +
  // marche pour 328p et 2560
 +
  // à adapter pour d'autres µ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 (!Serial) {}
 +
  Serial.begin(115200);
 +
  Wire.begin();
 +
  Wire.setClock(400000); // use 400 kHz I2C
 +
  sensor.setTimeout(500);
 +
  if (!sensor.init())
 +
  {
 +
    Serial.println("Failed to detect and initialize sensor!");
 +
    while (1);
 +
  }
 +
  // Use long distance mode and allow up to 50000 us (50 ms) for a measurement.
 +
  // You can change these settings to adjust the performance of the sensor, but
 +
  // the minimum timing budget is 20 ms for short distance mode and 33 ms for
 +
  // medium and long distance modes. See the VL53L1X datasheet for more
 +
  // information on range and timing limits.
 +
  sensor.setDistanceMode(VL53L1X::Long);
 +
  sensor.setMeasurementTimingBudget(50000);
 +
  // Start continuous readings at a rate of one measurement every 50 ms (the
 +
  // inter-measurement period). This period should be at least as long as the
 +
  // timing budget.
 +
  sensor.startContinuous(50);
 +
  while(1)
 +
  {
 +
    Serial.print(sensor.read());
 +
    if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
 +
    Serial.println();
 +
}
 +
}
 +
 
</source>
 
</source>
  

Version du 21 mai 2024 à 21:45

Utiliser des librairies arduino avec un main

Un certain nombre de librairies utilisent les fontions arduino delay/delayMicroseconds/millis/micros

Ces fonctions utilisent le Timer0 et en particulier l'interruption de débordement.

Ce Timer est configuré dans la fonction init(), qui est appelée dans le "main arduino"

On peut donc initialiser ce Timer0 pour qu'il génère un débordement tel que les fonctions de gestion du temps Arduino puisse fonctionner et ainsi pouvoir utiliser les librairies qui en dépendent : 

void initFonctionsTempsArduino()
{
  sei();
  // marche pour 328p et 2560
  // à adapter pour d'autres µ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();
  Serial.begin(115200);
  while(1)
  {
    delay(100);
    Serial.println(millis());
  }
}


Exemple pour le capteur vl53l1x : 

/*
This example shows how to take simple range measurements with the VL53L1X. The
range readings are in units of mm.
*/

#include <Wire.h>
#include <VL53L1X.h>

VL53L1X sensor;

void initFonctionsTempsArduino()
{
  sei();
  // marche pour 328p et 2560
  // à adapter pour d'autres µ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 (!Serial) {}
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000); // use 400 kHz I2C
  sensor.setTimeout(500);
  if (!sensor.init())
  {
    Serial.println("Failed to detect and initialize sensor!");
    while (1);
  }
  // Use long distance mode and allow up to 50000 us (50 ms) for a measurement.
  // You can change these settings to adjust the performance of the sensor, but
  // the minimum timing budget is 20 ms for short distance mode and 33 ms for
  // medium and long distance modes. See the VL53L1X datasheet for more
  // information on range and timing limits.
  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
  // Start continuous readings at a rate of one measurement every 50 ms (the
  // inter-measurement period). This period should be at least as long as the
  // timing budget.
  sensor.startContinuous(50);
  while(1)
  {
    Serial.print(sensor.read());
    if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
    Serial.println();
}
}

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.


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=18953 »