else if (taste>0)                     // détection d'un aimant à l'aide de K6 => Bit0=1
{
   compteur();
}
}

//--------------------------------------------------
//   Compteur
//--------------------------------------------------

void compteur(void)
{
   int i;
      
      for(i = 0; i < 3; i++)
   {
      if (i==0)
{
   detection_aimant();
}
      else
{
   demi_tour();
}
   }
}

//--------------------------------------------------
//  ATTENTE UNE SECONDE (1000 * 1ms)
//--------------------------------------------------
void vAttenteUneSeconde(void){

  int i;

  //1000 times
  for(i=0;i<1000;i++){

    //attente 73 * 13,75us = 1ms     (13,75us = 8.000.000 / 110)
    Sleep(73);
   
  }//for
 
}


//--------------------------------------------------
//   Compteur
//--------------------------------------------------

void compteur(void){

  int i;
     
  for(i = 0; i < 3; i++){

    if (i==0){
   
      detection_aimant();
     
    }

    else{
   
      demi_tour();

    }

    //attente
    vAttenteUneSeconde();

  }

}

      else if (taste>0)                     // détection d'un aimant à l'aide de K6 => Bit0=1
{   
   position = position + 1;
   
   switch (position)
   {
      case Debut_parcours : // égal à 0
      case Fin_parcours : // égal à 2
      {
         demi_tour();                        // appel à la fonction pour faire demi-tour
      }
         break;   
   
      case Depose_balle : // égal à 1
      {
         detection_aimant();                     // appel à la fonction sur la détection de l'aimant
      }
         break;
   }
}

#include "asuro.h"   

      
//--------------------------------------------------
//   Déclaration de fonction
//--------------------------------------------------

void Suivi_ligne(void);
void detection_aimant(void);
void demi_tour(void);

//--------------------------------------------------
//   Fonction principale
//--------------------------------------------------

int main(void)
{
   Init();
      
      while(1)                            // Boucle sans fin
{
   Suivi_ligne();
   
}
      return 0;
}

//--------------------------------------------------
//   Fonction du suivi de ligne
//--------------------------------------------------

void Suivi_ligne(void)
{
   unsigned int lineData[2];                  //Allocation de la mémoire
   unsigned char taste;

   taste=PollSwitch();
   FrontLED(ON);                           // La LED frontale (D11) est allumée
   StatusLED(GREEN);                        // Diode d’état sur vert
   LineData(lineData);                        // Lire les valeurs de luminosité actuelle des phototransistors
   
//--------------------------------------------------
//  Trajectoire du robot : suivi de ligne            //data[0] contient la valeur du phototransistor gauche (T9).
//--------------------------------------------------   //data[1] contient la valeur du phototransistor droit (T10).

      if (lineData[0]<lineData[1]) {            // à gauche moins lumineux qu'à droite...
   MotorDir(FWD,FWD);                        // Les deux moteurs avancent
   MotorSpeed (60,200);                     // ...accélérer plus à droite
   BackLED(ON,OFF);                        // Allumer Led arrière gauche... Led arrière droite éteinte
}
      else if (lineData[0]>lineData[1]) {      // à gauche plus lumineux qu’à droite...
   MotorDir(FWD,FWD);                        // Les deux moteurs avancent
   MotorSpeed (200,40);                     // ... accélérer plus à gauche
   BackLED(OFF,ON);                        // Eteindre Led arrière gauche... Led arrière droite allumée
}
      else if (taste>0)                     // détection d'un aimant à l'aide de K6 => Bit0=1
{
   compteur();
}
}

//--------------------------------------------------
//   Compteur
//--------------------------------------------------

void compteur(void)
{
   int i;
     
      for(i = 0; i < 3; i++)
   {
      if (i==0)
{
   detection_aimant();
   break;
}
   
      else
{
   demi_tour();
}
   }
}

//--------------------------------------------------
//   Détection d'un aimant
//--------------------------------------------------

void detection_aimant(void)
{
   int i;
   
   StatusLED(YELLOW);                        // Diode d'état jaune
   FrontLED(OFF);                           // LED frontale éteinte car ne suit plus la ligne
   
// avance légèrement avant le quart de tour

      for(i = 0; i < 255; i++)                                                   
{                                       
   MotorDir(FWD,FWD);                        // Les deux moteurs avancent
   MotorSpeed(i,i);                        // accélération progressive du moteur droit
   Sleep(255);                              // temporisation de quelques millisecondes
}

// 1/4 de tour en avant vers la gauche   

      for(i = 0; i < 255; i++)                                                   
{                                       
   MotorDir(FWD,FWD);                        // Les deux moteurs avancent
   MotorSpeed(0,i);                        // accélération progressive du moteur droit
   Sleep(255);                              // temporisation de quelques millisecondes
}

// 1/4 de tour en arrière pour revenir en position initiale

      for(i = 0; i < 255; i++)
{
   MotorDir(RWD,RWD);                        // Les deux moteurs reculent
   MotorSpeed(0,i);                        // accélération progressive du moteur droit
   Sleep(255);                              // temporisation de quelques millisecondes
}
}

//--------------------------------------------------
//   Demi tour, arrivé à la fin du parcours
//--------------------------------------------------

void demi_tour(void)
{
   int i;
   
   StatusLED(RED);                           
   FrontLED(OFF);                           

      for(i = 0; i < 255; i++)
{
   MotorDir(RWD,RWD);                  
   MotorSpeed(0,i);
   Sleep(255);
}

      for(i = 0; i < 255; i++)
{
   MotorDir(FWD,FWD);
   MotorSpeed(i,0);
   Sleep(255);
}
}

#include "asuro.h"         


//--------------------------------------------------
// Déclaration de types
//--------------------------------------------------
typedef enum
{
    MAGNET_POSITON_START = 0,
    MAGNET_POSITON_BALL  = 1,
    MAGNET_POSITON_END   = 2,
}TMagnetPosition;

//--------------------------------------------------
// Déclaration de fonction
//--------------------------------------------------

void Suivi_ligne(TMagnetPosition eMagnetPositon);
void detection_aimant(void);
void demi_tour(void);

//--------------------------------------------------
// Fonction principale
//--------------------------------------------------

int main(void)
{
    TMagnetPosition eMagnetPositon = MAGNET_POSITON_START;
    Init();
   
    while(1)          // Boucle sans fin
    {
      Suivi_ligne(eMagnetPositon);
       
    }
    return 0;
}

//--------------------------------------------------
// Fonction du suivi de ligne
//--------------------------------------------------

void Suivi_ligne(TMagnetPosition eMagnetPositon)
{
    unsigned int lineData[2];      //Allocation de la mémoire
    unsigned char taste;
   
    taste = PollSwitch();
    FrontLED(ON);         // La LED frontale (D11) est allumée
    StatusLED(GREEN);        // Diode d’état sur vert
    LineData(lineData);        // Lire les valeurs de luminosité actuelle des phototransistors
   
    //-------------------------------
    // Test de la aimant
    //-------------------------------
    if (taste > 0)       
    {
        // on increment la position de l aimant detecte
        eMagnetPositon = eMagnetPositon + 1;

        // on ramene la valeur de l aimant (3 valeurs possibles)
        eMagnetPositon = eMagnetPositon % 3;

        switch(eMagnetPositon)
        {
            case MAGNET_POSITON_START :
            case MAGNET_POSITON_END  :
            {
                demi_tour();
            }break;
            case MAGNET_POSITON_BALL :
            {
                // appel à la fonction sur la détection de l'aimant
                detection_aimant();
            }break;

           
        }
    }


    //--------------------------------------------------
    //  Trajectoire du robot : suivi de ligne    //data[0] contient la valeur du phototransistor gauche (T9).
    //-------------------------------------------------- //data[1] contient la valeur du phototransistor droit (T10).
    if (lineData[0]<lineData[1])
    {
         // à gauche moins lumineux qu'à droite..
        MotorDir(FWD,FWD);        // Les deux moteurs avancent
        MotorSpeed (60,200);       // ...accélérer plus à droite
        BackLED(ON,OFF);        // Allumer Led arrière gauche... Led arrière droite éteinte
    }
    else if (lineData[0]>lineData[1])
    { 
        // à gauche plus lumineux qu’à droite...
        MotorDir(FWD,FWD);        // Les deux moteurs avancent
        MotorSpeed (200,40);       // ... accélérer plus à gauche
        BackLED(OFF,ON);        // Eteindre Led arrière gauche... Led arrière droite allumée
    }
   
   return eMagnetPositon;
}

//--------------------------------------------------
// Détection d'un aimant
//--------------------------------------------------

void detection_aimant(void)
{
    int i;
   
    StatusLED(YELLOW);        // Diode d'état jaune
    FrontLED(OFF);         // LED frontale éteinte car ne suit plus la ligne
   
    // avance légèrement avant le quart de tour pour ne pa retomber sur l'aimant
   
    for(i = 0; i < 255; i++)                 
    {             
        MotorDir(FWD,FWD);        // Les deux moteurs avancent
        MotorSpeed(i,i);        // accélération progressive du moteur droit
        Sleep(255);          // temporisation de quelques millisecondes
    }
   
    // 1/4 de tour en avant vers la gauche
   
    for(i = 0; i < 255; i++)                 
    {             
        MotorDir(FWD,FWD);        // Les deux moteurs avancent
        MotorSpeed(0,i);        // accélération progressive du moteur droit
        Sleep(255);          // temporisation de quelques millisecondes
    }
   
    // 1/4 de tour en arrière pour revenir en position initiale
   
    for(i = 0; i < 255; i++)
    {
        MotorDir(RWD,RWD);        // Les deux moteurs reculent
        MotorSpeed(0,i);        // accélération progressive du moteur droit
        Sleep(255);          // temporisation de quelques millisecondes
    }
}

//--------------------------------------------------
// Demi tour, arrivé à la fin du parcours
//--------------------------------------------------

void demi_tour(void)
{
    int i;
   
    StatusLED(RED);         // Diode d'état rouge
    FrontLED(OFF);         // LED frontale éteinte
   
    // 1/4 de tour en arrière
   
    for(i = 0; i < 255; i++)
    {
        MotorDir(RWD,RWD);       
        MotorSpeed(0,i);
        Sleep(255);
    }
   
    // 1/4 de tour en avant
   
    for(i = 0; i < 255; i++)
    {
        MotorDir(FWD,FWD);
        MotorSpeed(i,0);
        Sleep(255);
    }
   
}

//============================================================
// POLL SWITCH 2
//============================================================
// Une détection rapide et fiable de TOUT commutateur.
// A fast and reliable detection of ANY switch.
//============================================================
unsigned char ucPollSwitch2(void){

  //var
  unsigned char ucSwi;
  unsigned char i;
   
  //supposez qu'aucun commutateur n'est actionné
  //assume that no switch is activated
  ucSwi=0;
   
  //----------------------------------------
  //En ce moment, la borne 27 est un "output"
  //at this moment, pin 27 is an output
  //----------------------------------------

  //----------------------------------------
  // Une petite impulsion positive pour charger le condensateur C7.
  // A small positive pulse to charge capacitor C7
  //----------------------------------------

  //pin 27: pull-up (high)
  PORTC|= (1<<PC4);
  //pin 27: output (high)
  DDRC |= (1<<PC4);
  //pin 27: input (pull-up high)
  DDRC &=~(1<<PC4);
  //pin 27: input (no pull-up)
  PORTC&=~(1<<PC4);

  //----------------------------------------
  //Attendez un moment pour faire charger C7.
  //Wait one moment to charge C7.
  //----------------------------------------

  //wait for 2ms
  Sleep(146);
 
  //----------------------------------------
  // vérifiez si n'importe quelle clef est pressée (C7 est discharge)
  // check if ANY key is pressed (C7 is discharged)
  //----------------------------------------

  //Si n'importe quel frontswitch est activé.
  //if any frontswitch is pressed
  if ( ~PINC & ( 1 << PC4 ) ) {

    //----------------------------------------
    // arrêtez les moteurs de bot
    // stop both motors
    //----------------------------------------
   
    //arrêtez le moteur gauche
    //turn off the left engine
    PORTD&=~((1<<PD5)|(1<<PD4));

    //arrêtez le moteur droit
    //turn off the right engine
    PORTB&=~((1<<PB5)|(1<<PB4));

    //----------------------------------------
    // attente 100 millisecondes. Attente la puissance de batterie de stabiliser.
    // wait for 100 milliseconds. Wait for the battery voltage to stabilize.
    //----------------------------------------

    //faites 50 fois
    //do 50 times
    for(i=0;i<50;i++){
   
      //attente 2ms
      //wait for 2ms
      Sleep(146);
     
    }//for

    //----------------------------------------
    //découvrez quels commutateurs sont actionnés
    // find out what switches are activated
    //----------------------------------------

    // exécutez le pollswitch
    // execute pollswitch
    ucSwi = PollSwitch();
   
    //----------------------------------------
    // définissez la borne PD3 comme 'input' (le pollswitch l'a placé comme 'output')
    // define pin PD3 as 'input' (pollswitch sets it as 'output')
    //----------------------------------------

    //PD3 = 'input'
    DDRD &= ~( 1 << PD3);
   
  }//if

  //renvoyez la valeur mesurée de commutateur
  //return the measured switch value
  return ucSwi;
 
}//ucPollSwitch2