Bonjours à tous ! 

Bon voilà, je suis actuellement en classe de terminal S avec l’option ISN ( Informatique et Science du Numérique ) apparue pour la première fois cette année dans mon lycée. 

Pour notre projet final nous devons, par groupe de 3, réaliser un programme pour un robot suiveur de ligne, et cela en plusieurs étapes. 

Nous avons donc réussi à réaliser parfaitement les deux premières étapes qui étaient de faire suivre la ligne au robot, puis d’optimisé ça trajectoire. Cependant nous n’avons pas réussi la troisième étape qui est : «Lien plus général avec la régulation». Cette étape doit permettre d'optimisé encore plus la trajectoire du robot. 

C’est la première année que je fais vraiment de programmation et la je sèche vraiment, donc si quelqu’un pourrais m’aider sa serais vraiment génial. 

Voici le robot utilisé : 

http://www.zartronic.fr/robot-zarblue-4wd-miniq-p-282.html

Et le programme ( fait avec Arduino ) :

#define facteur 0.0048875855 ; // Facteur de proportionnalité entre la valeur analogique lue et la tension en Volts 

//------------------------------------ Capteurs IR --------------------------------------

int CIR_M = 2 ; // Broche analogique 2 pour le capteur infrarouge du milieu
int CIR_G = 1 ; // Broche analogique 1 pour le capteur infrarouge du gauche
int CIR_eG = 0 ; //  Broche analogique 0 pour le capteur infrarouge du extreme gauche
int CIR_D = 3 ; // Broche analogique 3 pour le capteur infrarouge du droite
int CIR_eD = 7 ; // Broche analogique 7 pour le capteur infrarouge du extreme droit

//------------------------------------ Entier lue ----------------------------------------

int entierLuM ; // entier lu (entre 0 et 1023) sur la broche analogique 2
int entierLuG ; // entier lu (entre 0 et 1023) sur la broche analogique 1
int entierLueG ;// entier lu (entre 0 et 1023) sur la broche analogique 0
int entierLuD ; // entier lu (entre 0 et 1023) sur la broche analogique 3
int entierLueD ; // entier lu (entre 0 et 1023) sur la broche analogique 7

// ------------------------------------ Tension --------------------------------------------
float TMilieu ; // tension (entre 0V et 5V) proportionnelle à l'entier lu
float TGauche ; 
float TeGauche ;
float TDroite ;
float TeDroite ;

// ------------------------------------ Variable -------------------------------------------
float x = 4.5 ;



// ------------------------------------ Moteurs -------------------------------------------

#define AV 1 // Pour faire tourner un moteur vers l'avant
#define AR 0 // Pour faire tourner un moteur vers l'arrière
#define SENS_G 4 // Broche 4 pour fixer le sens de rotation du moteur gauche
#define SENS_D 7 // Broche 7 pour fixer le sens de rotation du moteur droit 
#define VIT_G 5 // Broche 5 pour fixer la vitesse du moteur gauche
#define VIT_D 6 // Broche 6 pour fixer la vitesse du moteur droit

//--------------------------------------Vitesse ---------------------------------------


#define VIT1 50 // Bas
#define VIT2 57  // Moyen
#define VIT3 65  // Haut
#define VIT4 85 // Très haut 



// --------------------------------------------- FONCTION SETUP ( ) --------------------------------------------------------- 


void setup ( )
{
  pinMode ( 4 , OUTPUT ) ; // On definit la broche 4 comme une sortie 
  pinMode ( 5 , OUTPUT ) ; // On definit la broche 5 comme une sortie 
  pinMode ( 6 , OUTPUT ) ; // On definit la broche 6 comme une sortie 
  pinMode ( 7 , OUTPUT ) ; // On definit la broche 7 comme une sortie 
  Serial.begin (115200) ;
}


// ------------------------------------------- FONCTION LOOP ( ) ------------------------------------------------------------- 

void loop ( )
{
  
 //--------------------------------------- Calcule des Tensions --------------------------------------
 
 
  entierLuM = analogRead ( CIR_M ) ; // On lit la valeur entière (entre 0 et 1023) sur la broche analogique 2 
  TMilieu = entierLuM * facteur ; // On calcule la tension correspondante
  Serial.println ( "TMilieu :" ) ;
  Serial.println ( TMilieu ) ; // On affiche cette tension dans le terminal série

  entierLuG = analogRead ( CIR_G ) ; // On lit la valeur entière (entre 0 et 1023) sur la broche analogique 1
  TGauche = entierLuG * facteur ; // On calcule la tension correspondante
  Serial.println ( "TGauche :" );
  Serial.println ( TGauche ) ; // On affiche cette tension dans le terminal série

    entierLueG = analogRead ( CIR_eG ) ; // On lit la valeur entière (entre 0 et 1023) sur la broche analogique 0 
  TeGauche = entierLueG * facteur ; // On calcule la tension correspondante
  Serial.println ( "TeGauche :" );
  Serial.println ( TeGauche ) ; // On affiche cette tension dans le terminal série

    entierLuD = analogRead ( CIR_D ) ; // On lit la valeur entière (entre 0 et 1023) sur la broche analogique 3 
  TDroite = entierLuD * facteur ; // On calcule la tension correspondante
  Serial.println ( "TDroite :" );
  Serial.println ( TDroite ) ; // On affiche cette tension dans le terminal série

    entierLueD = analogRead ( CIR_eD ) ; // On lit la valeur entière (entre 0 et 1023) sur la broche analogique 7
  TeDroite = entierLueD * facteur ; // On calcule la tension correspondante
  Serial.println ( "TeDroite :" );
  Serial.println ( TeDroite ) ; // On affiche cette tension dans le terminal série


// ----------------------------------------- AVANCER --------------------------------------------



    if (TMilieu < x && TGauche > x && TDroite > x && TeGauche > x && TeDroite > x) // Milieu : Avancer

  {
    digitalWrite ( SENS_G , AV ) ; // ------> Moteur Gauche : AVANT
    analogWrite ( VIT_G , VIT2 ) ; // ------> Vitesse Gauche : BAS 
    digitalWrite ( SENS_D , AV ) ; // ------> Moteur Droit : AVANT 
    analogWrite ( VIT_D , VIT2 ) ; // ------> Vitesse Droit : BAS 
    Serial.println ("avance") ; 
  }
    if (TMilieu < x && TGauche < x && TDroite < x && TeGauche > x && TeDroite > x) // Milieu : bis Milieu + Droit + Gauche 

  {
    digitalWrite ( SENS_G , AV ) ; // ------> Moteur Gauche : AVANT 
    analogWrite ( VIT_G , VIT1 ) ; // ------> Vitesse Gauche : MOYEN
    digitalWrite ( SENS_D , AV ) ; // ------> Moteur Gauche : AVANT
    analogWrite ( VIT_D , VIT1 ) ; // ------> Vitesse Gauche : MOYEN
    Serial.println ("avance") ; 
  }


// ------------------------------------- Tourner à GAUCHE ---------------------------------------



  if (TMilieu < x && TGauche < x && TDroite > x && TeGauche > x && TeDroite > x) // mG : capteur du Milieu + Gauche 
  {
    digitalWrite ( SENS_G , AR ) ; //  ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_G , VIT1 ) ; //  ------> Vitesse Gauche : BAS
    digitalWrite ( SENS_D , AV ) ; //  ------> Moteur Gauche : AVANT 
    analogWrite ( VIT_D , VIT2 ) ; //  ------> Vitesse Gauche : MOYEN
    Serial.println ("tourne très doucement à gauche") ;
  }

  if (TMilieu > x && TGauche < x && TDroite > x && TeGauche > x && TeDroite > x) // G : capteur Gauche 
  {
    digitalWrite ( SENS_G , AR ) ; //  ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_G , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    digitalWrite ( SENS_D , AV ) ; // ------> Moteur Gauche : AVANT 
    analogWrite ( VIT_D , VIT2 ) ; // ------> Vitesse Gauche : MOYEN  
    Serial.println ("tourne doucement à gauche") ;
  }
  
    if (TMilieu > x && TGauche < x && TDroite > x && TeGauche < x && TeDroite > x) // meGauche : capteur Gauche + Capteur eGauche 
  {
    digitalWrite ( SENS_G , AR ) ; //  ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_G , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    digitalWrite ( SENS_D , AV ) ; // ------> Moteur Gauche : AVANT 
    analogWrite ( VIT_D , VIT3 ) ; // ------> Vitesse Gauche : HAUT
    Serial.println ("tourne à gauche rapidement") ;   
  }
  
  if (TMilieu > x && TGauche > x && TDroite > x && TeGauche < x && TeDroite > x) // eG : Capteur eGauche
  {
    digitalWrite ( SENS_G , AR ) ; //  ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_G , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    digitalWrite ( SENS_D , AV ) ; // ------> Moteur Gauche : AVANT 
    analogWrite ( VIT_D , VIT4 ) ; // ------> Vitesse Gauche : TRES 
    Serial.println ("tourne à gauche tres rapidement") ; 
  }
  
  
  // ---------------------------------------- Tourner à DROITE ---------------------------------------------
  
  
  if (TMilieu < x && TGauche > x && TDroite < x && TeGauche > x && TeDroite > x) // mD : Milieu + Droit 
  {
    digitalWrite ( SENS_G , AV ) ; // ------> Moteur Gauche : AVANT
    analogWrite ( VIT_G , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    digitalWrite ( SENS_D , AR ) ; // ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_D , VIT1 ) ; // ------> Vitesse Gauche : BAS
    Serial.println ("tourne très doucement à droite") ; 
  }
  
   if (TMilieu > x && TGauche > x && TDroite < x && TeGauche > x && TeDroite > x) // D : capteur Droit 
  {
    digitalWrite ( SENS_G , AV ) ; // ------> Moteur Gauche : AVANT
    analogWrite ( VIT_G , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    digitalWrite ( SENS_D , AR ) ; // ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_D , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    Serial.println ("tourne doucement à droite") ; 
  }

  if (TMilieu > x && TGauche > x && TDroite < x && TeGauche > x && TeDroite < x) // meD : cateur Droit + eDroit 
  {
    digitalWrite ( SENS_G , AV ) ; // ------> Moteur Gauche : AVANT
    analogWrite ( VIT_G , VIT3 ) ; // ------> Vitesse Gauche : HAUT
    digitalWrite ( SENS_D , AR) ;  // ------> Moteur Gauche : ARRIERE  
    analogWrite ( VIT_D , VIT2 ) ; // ------> Vitesse Gauche : MOYEN 
    Serial.println ("tourne à droite rapidement") ; 
  }
  
  if (TMilieu > x && TGauche > x && TDroite > x && TeGauche > x && TeDroite < x) // eD : capteur  eDroit 
  {
    digitalWrite ( SENS_G , AV ) ; // ------> Moteur Gauche : AVANT
    analogWrite ( VIT_G , VIT4 ) ; // ------> Vitesse Gauche : TRES HAUT
    digitalWrite ( SENS_D , AR) ;  // ------> Moteur Gauche : ARRIERE  
    analogWrite ( VIT_D , VIT2 ) ; // ------> Vitesse Gauche : MOYEN
    Serial.println ("tourne à droite tres rapidement") ;
  }

// --------------------------------------- RECULER ------------------------------------------------------


  if (TMilieu > x && TGauche > x && TDroite > x && TeGauche > x && TeDroite > x) // Aucun capteurs 

  {
    digitalWrite ( SENS_G , AR ) ; //  ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_G , VIT1 ) ; // ------> Vitesse Gauche : BAS
    digitalWrite ( SENS_D , AR ) ; //  ------> Moteur Gauche : ARRIERE 
    analogWrite ( VIT_D , VIT1 ) ; // ------> Vitesse Gauche : BAS
    Serial.println ("reculer") ; // On marque dans le moniteur serie "s'arrete"
  }
}

Si vous ne comprenez pas tous au niveau du programme demander moi. 

Merci d'avance ! =)

Déjà merci pour avoir répondu aussi rapidement AmarOk1412

Alors d'après se que j'ai compris il faudrait pouvoir anticipé la trajectoire de la ligne noire que le robot doit suivre pour appliquer un correction au robot plus rapide et ainsi qu'il y est moins de saccade sur son déplacement, notre professeur nous a dis que sa ressemble au contrôle PID, mais en moins complex, j'ai essayé de regardé se que c'était exactement mais j'ai pas réussi à tous comprendre ^^' 

A ce que j'ai compris pour faire ça il faudrait utilisé la moyen de toutes tensions lue par les capteurs.

Enfin voilà, je sais que se que je dis c'est pas très clair, mais je voulais voir si quelqu'un comprenais pour qu'il puisse nous aider. 

Pour prédire la trajectoire. Si elle est connue, bah, faudrait mettre des données. Sinon, pour prédire un style de ligne par probabilité, y aurait bien les théories de Markov, mais ça va dépasser le niveau de terminal et ça ne va jamais caser sur l'arduino.

EDIT : en fait, je pense plutot qu'il veut que vous vous baser sur de la régulation. Donc voilà quelques liens utiles :

http://fr.wikipedia.org/wiki/Strat%C3%A9gie_de_r%C3%A9gulation

et ici : http://fr.wikipedia.org/wiki/Automatique#Exemple_de_boucle_de_r.C3.A9gulation 

-
Edité par AmarOk1412 26 avril 2013 à 17:47:42

Je vais lire tous ça pour essayé d'avancé, en tout cas merci beaucoup =)

š il vous plait je veux quelqu'un m'aider pour la programation d un robot suiveur de ligne