Documentation Projet

Documentation visuelle

Les images suivantes ont été ajoutées au projet et illustrent le robot ainsi que les membres de l'équipe Nova Tech.

– Modélisation 3D du robot.

Présentation et objectifs

Le projet consiste à concevoir un robot autonome capable de :

1. Suivre une ligne noire tracée sur une piste.
2. Détecter et contourner les obstacles rencontrés.
3. Rester performant, précis et réactif.
4. Permettre à l'équipe Nova Tech de viser la victoire au concours UCAO TECH.

Liste du matériel

Matériel requis selon le cahier de charge.

Technologie principale utilisée : Arduino.

Financement

Le budget projet inclut les coûts obligatoires et les dépenses de fonctionnement.

Capteurs — Vue d'ensemble

Le robot utilise 3 capteurs infrarouges pour détecter la ligne noire (gauche, centre, droite), plus un module dédié à l'évitement d'obstacles.

Schéma de la barrette

  Position :  Gauche   Centre   Droite
              |          |         |
  ════════════●══════════●═════════●════════
              
  Sortie analogique : noir / blanc
  Décision : correction gauche, droite ou maintien

Principe de décision

Le microcontrôleur compare les trois lectures IR et corrige les moteurs :

si capteur_gauche détecte la ligne → tourner à gauche
si capteur_droite détecte la ligne  → tourner à droite
si capteur_centre détecte la ligne  → avancer
si obstacle détecté                  → contourner l'obstacle

Calibration et Ajustement des Seuils

Les capteurs IR retournent une valeur analogique entre 0 et 1023. Il est important de calibrer les seuils pour bien distinguer la ligne noire du fond blanc.

Procédure de calibration

1. Placer le robot sur une surface blanche (fond).
2. Mesurer les valeurs analogiques pour les 3 capteurs (afficher via Serial.println).
3. Placer le robot sur la ligne noire.
4. Mesurer à nouveau les 3 valeurs.
5. Calculer le seuil comme la moyenne : seuil = (valeur_blanche + valeur_noire) / 2
6. Utiliser ces seuils dans la logique de détection.

Code exemple

// Seuils calibrés (à adapter selon votre robot)
const int SEUIL = 500;

void readSensors() {
  left = analogRead(IR_LEFT);
  center = analogRead(IR_CENTER);
  right = analogRead(IR_RIGHT);
  
  // 1 = ligne détectée, 0 = pas de ligne
  detecL = (left > SEUIL) ? 1 : 0;
  detecC = (center > SEUIL) ? 1 : 0;
  detecR = (right > SEUIL) ? 1 : 0;
}

Logique de Contrôle des Moteurs

Sur l'Arduino UNO avec 3 capteurs IR, le contrôle est simple : chaque configuration de capteurs correspond à une action moteur.

Table de vérité

Implémentation

void followLine() {
  readSensors();
  
  if (detecL && !detecC && !detecR) {
    setMotors(80, 200);  // Tourner à gauche
  } 
  else if (!detecL && !detecC && detecR) {
    setMotors(200, 80);   // Tourner à droite
  }
  else {
    setMotors(150, 150);   // Avancer
  }
}

Vitesses adaptatives

Optionnel : augmenter la vitesse en ligne droite, la réduire en virage :

int vitesseBase = 180;
int reductionVirage = 40;

// En virage : réduire la vitesse
if (detecL || detecR) {
  vitesseBase = 140;
}
          

            
Seulement si le robot a un biais constant d'un côté.
            
Commencer très bas : Ki = 0.0001.
            
Augmenter doucement. L'anti-windup est critique ici.
          

          
Profils sauvegardés
          

            
Profil
Kp
Ki
Kd
Usage
            

              
Safe
0.10
0.0001
1.5
Premiers tests, piste inconnue
              
Normal
0.15
0.0001
2.5
Entraînement standard
              
Aggressif
0.22
0.0002
3.8
Compétition, piste connue
            
          

          

            💡 Conseil
            Toujours tester sur au minimum 3 types de pistes : ligne droite, virage large, virage serré à 90°.
          
        

Stratégie Vitesse

La vitesse de base n'est pas fixe : elle s'adapte en fonction de la déviation de la ligne.

Principe

• Ligne droite (erreur faible) → vitesse maximale.
• Virage (erreur élevée) → vitesse réduite progressivement.
• Transition douce pour éviter les à-coups mécaniques.

int vitesseAdaptative(float erreur) {
  float absErr = abs(erreur);
  
  if (absErr < 500)  return MAX_SPEED;      // 255 - ligne droite
  if (absErr < 1500) return MED_SPEED;      // 200 - virage léger
  if (absErr < 2500) return SLOW_SPEED;     // 150 - virage serré
  return MIN_SPEED;                        // 100 - urgence
}

Programmation Arduino

Le programme embarqué est développé en langage Arduino (C++ simplifié) pour l'Arduino UNO.

Structure du programme

Le programme comprend :

• setup() : Initialisation des pins et des capteurs.
• readSensors() : Lecture des 3 capteurs IR (Gauche, Centre, Droit).
• followLine() : Logique de suivi de la ligne noire.
• avoidObstacle() : Logique d'évitement d'obstacle.
• controlMotors() : Pilotage des 2 moteurs DC (vitesse + direction).
• loop() : Boucle principale répétée continuellement (~100 Hz).

Configuration des pins Arduino

// Capteurs infrarouges
const int IR_LEFT   = A0;
const int IR_CENTER = A1;
const int IR_RIGHT  = A2;

// Moteur gauche
const int MOT_L_IN1 = 8;
const int MOT_L_IN2 = 9;
const int MOT_L_PWM = 10;

// Moteur droit
const int MOT_R_IN1 = 11;
const int MOT_R_IN2 = 12;
const int MOT_R_PWM = 5;

// Détecteur d'obstacle (capteur IR numérique)
const int OBSTACLE_PIN = 2;

Déploiement

1. Télécharger l'IDE Arduino officiel (arduino.cc).
2. Sélectionner "Arduino UNO" dans Outils → Carte.
3. Charger votre sketch (.ino).
4. Cliquer "Vérifier" pour compiler, puis "Téléverser" pour charger dans le microcontrôleur.
5. Ouvrir le Moniteur série (9600 baud) pour suivre l'exécution.

Tests et Optimisation

Procédure systématique pour tester et affiner les performances du robot avant la compétition.

Étapes de test

1. Test de ligne droite : Robot suit une ligne noire d'1 mètre sans obstacle. Vérifier la stabilité (pas d'oscillation).
2. Test de virages : Ajouter une courbe à 90° puis en S. Mesurer le temps et la trajectoire.
3. Test d'obstacle : Placer un obstacle à 10 cm. Vérifier que le robot le détecte et s'arrête ou contourne.
4. Test de performance : Chronomètrer le parcours complet de la piste UCAO TECH.
5. Test d'endurance : Répéter 5 fois consécutives, noter les variations de temps.

Enregistrement des résultats

Pour chaque session de test, documenter :

• Date et heure du test.
• Tension batterie (V) au début et à la fin.
• Conditions d'éclairage et état de la piste.
• Paramètres du firmware (seuils capteurs, vitesses).
• Temps d'exécution et nombre d'erreurs (sorties de ligne, non-détection obstacle).
• Observations qualitatives et ajustements effectués.

Ces données permettent d'optimiser progressivement le robot et de détecter les problèmes intermittents.

Maintenance et Vérifications

Procédures pour garder le robot en état optimal avant la compétition.

Check-list pré-compétition

Entretien des batteries

Les batteries alcalines perdent de la charge progressivement. Signes de remplacement :

• Tension inférieure à 7.0V (mesurer avec un multimètre).
• Robot visiblement plus lent (moins de couple moteur).
• Comportement instable après 30 minutes d'utilisation.

Dépannage

Solutions rapides aux problèmes courants rencontrés avec l'Arduino UNO et le robot.