     lePotar.refresh();
 }
 
+
+//------------------------------------------------------------------------------
+//La tache Scoop
 defineTask(reflechi)
-    void reflechi::setup()
-	{
-
-	}
-    
+    void reflechi::setup(){ }
     void reflechi::loop()
     //defineTimerRun(reflechi,40)
-	{
-    //Serial.println("proute");
-    //Serial.println("reflechi");
+/*
+  AFFICHERIEN,
+  AFFICHEUSB,
+  AFFICHESWEEP,
+  AFFICHEPOTAR,
+  AFFICHEMILIEU,
+  AFFICHEADAFRUIT,
+  AFFICHECLASSIQUE
+  */
+    {
     byte i;
-		if (boutonP.hasBeenLongClicked())
-			{ 
-				dateChangeServo=(millis());
-				changeTypeServo=true;
-				if (leServo.getType())
-					{
-						leServo.setType(false);
-						affichage.affiche(5);
-						Serial.println(F("servo de type Adafruit"));
-					}
-				else
-					{
-						leServo.setType(true);
-						affichage.affiche(6);
-						Serial.println(F("servo de type Classique"));
-					}
-				//sleep( 3000);
-				boutonP.acquit();
-			}
-		if (millis()>dateChangeServo+3000 && changeTypeServo)
-			{
-				affichage.affiche(etatCalibrateur);
-				changeTypeServo=false;
-			}
-
-		
-		switch (etatCalibrateur)
-			{
-				case USB :
-					
-                                        
-          Serial.println(F("Double Clic pour procéder à mesure via USB, sinon simple clic change de mode"));                              
-					etatCalibrateur=ETALORSWEEP;
-					break;
-
-				case ETALORSWEEP :
-          
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-							etatCalibrateur=SWEEPTOMIN;
-							affichage.affiche(SWEEPTOMIN);
-							leServo.setObjectif(leServo.getMin());
-              lePotar.acquit();
-						}
-				 
-					if (boutonP.hasBeenDoubleClicked())
-					{
-						boutonP.acquit();
-            leServo.setVitesse(VITESSEMAXSERVO);
-            leServo.setObjectif(leServo.getMilieu());
-         // pour etre certain qu'on aprt du milieu et que le servo 
+        if (boutonP.hasBeenLongClicked())
+            { 
+                dateChangeServo=(millis());
+                changeTypeServo=true;
+                if (leServo.getType())
+                    {
+                        leServo.setType(false);
+                        affichage.affiche(AFFICHEADAFRUIT);
+                        Serial.println(F("servo de type Adafruit"));
+                    }
+                else
+                    {
+                        leServo.setType(true);
+                        affichage.affiche(AFFICHECLASSIQUE);
+                        Serial.println(F("servo de type Classique"));
+                    }
+                //sleep( 3000);
+                boutonP.acquit();
+            }
+        if (millis()>dateChangeServo+3000 && changeTypeServo)
+            {
+                affichage.affiche(etatCalibrateur);
+                changeTypeServo=false;
+            }
+
+        
+        switch (etatCalibrateur)
+            {
+                case USB :
+                    Serial.println(F(\
+          "Double Clic pour procéder à mesure via USB, sinon simple clic change de mode"));                              
+                    etatCalibrateur=ETALORSWEEP;
+                    break;
+
+                case ETALORSWEEP :
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            etatCalibrateur=SWEEPTOMIN;
+                            affichage.affiche(SWEEPTOMIN);
+                            leServo.setObjectif(leServo.getMin());
+                            lePotar.acquit();
+                        }
+                 
+                    if (boutonP.hasBeenDoubleClicked())
+                    {
+                        boutonP.acquit();
+                        leServo.setVitesse(VITESSEMAXSERVO);
+                        leServo.setObjectif(leServo.getMilieu());
+         // pour etre certain qu'on part du milieu et que le servo 
           //n'est pas n'importe ou suite à des manip de type sweep
           //ou potar par ex
-						
-						//Serial.println(F("si lecture EEPROM pour potence Simple clic, si reglage potence double clic"));
-						etatCalibrateur=LECTURE_OU_ECRITURE_EEEPROM;
-            etatCalibrateur=MESREFPULSE;
-					} 
-					break;   
-
-//				case LECTURE_OU_ECRITURE_EEEPROM :
-//					if (boutonP.hasBeenClicked())
-//						{
-//							boutonP.acquit();
-//							EEPROM.get(ADRESSE_EEPROM, bonnePositionPotence); //lire la prom
-//
-//              Serial.println(F("j'ai lu"));
-//              Serial.println(bonnePositionPotence);
-//              potence.setObjectif(bonnePositionPotence);
-//              sleep( TEMPOSLEEP );
-//              etatCalibrateur=MESREFPULSE;
-//
-//						}
-//				 
-//					if (boutonP.hasBeenDoubleClicked())
-//					{
-//						boutonP.acquit();
-//						
-//						Serial.println(F("tourner potar à fond à gauche"));
-//						etatCalibrateur=REGPOTENCINVIT;
-//					} 
-//					break;
-//
-//          
-//          case REGPOTENCINVIT :
-//					
-//					if (lePotar.getValue()>1000)
-//					{
-//						etatCalibrateur=REGLPOTENC;
-//						Serial.println(F("quand potence reglé (sur le disque optique) faire 1 clic"));
-//					}   
-//					break;   
-//
-//				case REGLPOTENC :
-//					// Serial.print("obj potence=");
-//					// Serial.print(potence.getObjectif());
-//					// Serial.print("   Encours potence=");
-//					// Serial.print(potence.getEnCours());
-//					// Serial.print("   obj Pot=");
-//					// Serial.println(map(lePotar.getValue(),0,1023,potence.getMin(),potence.getMax()));
-//					// Serial.println("_____");
-//					potence.setObjectif(map(lePotar.getValue(),0,1023,potence.getMin(),potence.getMax()));
-//					if (boutonP.hasBeenClicked())
-//						{
-//							bonnePositionPotence=map(lePotar.getValue(),0,1023,potence.getMin(),potence.getMax());
-//							boutonP.acquit();
-//              EEPROM.put(ADRESSE_EEPROM, bonnePositionPotence);//enregistre en eeprom
-//              Serial.print(F("sauver en prom = ")); Serial.println( bonnePositionPotence );
-//
-//							etatCalibrateur=MESREFPULSE;
-//						}
-//					break;
-			 
-				case MESREFPULSE: //mesure des impulsion de reference sur une rotation de delta faite X fois pour plus de certitude
-       
-          compteurRef=0;
-          compteur=0;
-          for (i=0;i<NBRCYCLE_AR;i=i+1)
-          {
-    					Serial.print(F("iteration de mesure de ref="));
-    					
-    					
-    					leServo.setObjectif(leServo.getMilieu()+DELTA);
-    					sleep(TEMPOSLEEP);
-              mesureRef[i]=compteur;
-              leServo.setObjectif(leServo.getMilieu());
-              sleep(TEMPOSLEEP);
-              compteur=0;
-              Serial.println(mesureRef[i]);
-          }
-          
-
-
-          
-					etatCalibrateur=FINDMINMAX;
-					compteurRef=moyenne(NBRCYCLE_AR,mesureRef);
-          Serial.print(F(" SUPERcmpteurRefMoyenne="));
-          Serial.print(compteurRef);
-          Serial.print(F(" (ecart type : "));
-          Serial.println(ecartType(NBRCYCLE_AR,mesureRef));
-          
-					if (compteurRef==0)
-						{
-							Serial.println(F("PB : compteur Ref=0 aucune impulsion fourche optique détecté"));
-							Serial.println(F("retour au début de procédure"));
-							etatCalibrateur=USB;
-						}
-
-          if (ERREURCOMPTAGE*3>compteurRef)
-             {
-              Serial.println(F("ce serait bien que la marge d'erreur soit de l'ordre de 30% de la mesure de reference"));
-							Serial.println(F("je vais faire autre chose.... Programme a recompiler"));
-              Serial.println(F("modifier macro ERREURCOMPTAGE et DELTA"));
-
-
-							etatCalibrateur=POTAR;
-              affichage.affiche(POTAR);
-              }
-					break;
-				case FINDMINMAX: 
-					//Serial.println("lalalal");
-					//sequence pour aller au max puis au min et de déterminer les pwm Min et Max du servo
-					compteur=compteurRef;
-					while (compteur>compteurRef-ERREURCOMPTAGE && compteur<compteurRef+ERREURCOMPTAGE)
-						{
-							Serial.print("M+.....");
-//            Serial.print(" ObjTest=");
-//            Serial.println(objTest);
-                                                        
-							compteur=0;
-							//objTest=objTest+DELTA;
-							leServo.setObjectif(leServo.getObjectif()+DELTA);
-							sleep(TEMPOSLEEP);
-//            Serial.print(" Objectif =");
-//            Serial.println(leServo.getObjectif());
-                                                   
-              Serial.print(" cmptr=");
-              Serial.println(compteur);
-					
-
-						}
-					leServo.setMax(leServo.getObjectif()-DELTA);
-					leServo.setObjectif(leServo.getMilieu());
-          Serial.print("MAX=");
-          Serial.println(leServo.getMax());
-          Serial.println("retourneMilieu");
-					sleep(TEMPOSLEEP);
-					compteur=compteurRef;
-					while (compteur>compteurRef-ERREURCOMPTAGE && compteur<compteurRef+ERREURCOMPTAGE  )
-						{
-							Serial.print(F("M-......"));
-							compteur=0;
-							//objTest=objTest-DELTA;
-							leServo.setObjectif(leServo.getObjectif()-DELTA);
-							sleep(TEMPOSLEEP);
-              //Serial.print(" Objectif =");
-              //Serial.print(leServo.getObjectif());
-                                                        
-              Serial.print(" cmpteur=");
-              Serial.println(compteur);
-						}
-					leServo.setMin(leServo.getObjectif()+DELTA);
-					leServo.setObjectif(leServo.getObjectif()+DELTA);
-          Serial.print("MIN=");
-          Serial.println(leServo.getMin());
-					sleep(TEMPOSLEEP);
-					Serial.println("la le servo est au min et va faire grande course");
-          leServo.setObjectif(leServo.getMin());
-					//séquence pour mesurer une vitesse et amplitude moyenne
-					//(10 cycle d'aller et retour et enregistrement systématique des mesures)
-					
-					for (i=0;i<NBRCYCLE_AR;i=i+1)
-						{
-							compteur=0;
-							compteurRef=0;//compteur ref utilisé différement dans la suite par rapport à ce qui était fait jusque là. Compteur ref est utilisé pour voir si le servo continue de bouger
-							tempsMesureVitesse=millis();
-              Serial.print("tempsMesureVitesse=");
-              Serial.println(tempsMesureVitesse);
-							leServo.setObjectif(leServo.getMax());
-							sleep(TEMPO_STAT);
-              Serial.print("cmpt=");
-              Serial.println(compteur);
-								while (compteur>compteurRef+20)
-								{
-									
-									compteurRef=compteur;
-									
-                  Serial.print("yop");
-                  Serial.print(" cmpt=");
-                  Serial.println(compteur);
-                  sleep(TEMPO_STAT);
-								}
-							resultatImpulsionMax[i]=compteur;
-							resultatTempsMax[i]=millis()-tempsMesureVitesse-TEMPO_STAT;
-              Serial.print(F("Cycle "));
-              Serial.print(i);
-              Serial.print(F(" imp= "));
-              Serial.print(resultatImpulsionMax[i]);
-              Serial.print(F(" temps= "));
-              Serial.println(resultatTempsMax[i]);
-						
-							compteur=0;
-							compteurRef=0;
-							tempsMesureVitesse=millis();
-							leServo.setObjectif(leServo.getMin());
-							sleep(TEMPO_STAT);
-								while (compteur>compteurRef+20)
-									{
-									compteurRef=compteur;
-									
-                  Serial.print("yup ");
-                  Serial.print("cmpt=");
-                  Serial.println(compteur);
-                  sleep(TEMPO_STAT);
-									}
-							resultatImpulsionMin[i]=compteur;
-							resultatTempsMin[i]=millis()-tempsMesureVitesse-TEMPO_STAT;
-              Serial.print(F("Cycle "));
-              Serial.print(i+1);
-              Serial.print(F(" imp= "));
-              Serial.print(resultatImpulsionMin[i]);
-              Serial.print(F(" temps= "));
-              Serial.println(resultatTempsMin[i]);
-                                                        
-						}
+                        //etatCalibrateur=LECTURE_OU_ECRITURE_EEEPROM;
+                        etatCalibrateur=MESREFPULSE;
+                    } 
+                    break;   
+
+                case MESREFPULSE:
+                //mesure des impulsion de reference sur une rotation
+                //de delta faite X fois pour plus de certitude
+                    compteurRef=0;
+                    compteur=0;
+                    for (i=0;i<NBRCYCLE_AR;i=i+1)
+                    {
+                        Serial.print(F("iteration de mesure de ref="));
+                        leServo.setObjectif(leServo.getMilieu()+DELTA);
+                        sleep(TEMPOSLEEP);
+                        mesureRef[i]=compteur;
+                        leServo.setObjectif(leServo.getMilieu());
+                        sleep(TEMPOSLEEP);
+                        compteur=0;
+                        Serial.println(mesureRef[i]);
+                    }
+                    etatCalibrateur=FINDMINMAX;
+                    compteurRef=moyenne(NBRCYCLE_AR,mesureRef);
+                    Serial.print(F(" SUPERcmpteurRefMoyenne="));
+                    Serial.print(compteurRef);
+                    Serial.print(F(" (ecart type : "));
+                    Serial.println(ecartType(NBRCYCLE_AR,mesureRef));
+                    if (compteurRef==0)
+                        {
+                            Serial.println(F("PB : compteur Ref=0 aucune impulsion fourche optique détecté"));
+                            Serial.println(F("retour au début de procédure"));
+                            etatCalibrateur=USB;
+                        }
+                    if (ERREURCOMPTAGE*3>compteurRef)
+                    {
+                        Serial.println(F("ce serait bien que la marge d'erreur soit de l'ordre de 30% de la mesure de reference"));
+                        Serial.println(F("je vais faire autre chose.... Programme a recompiler"));
+                        Serial.println(F("modifier macro ERREURCOMPTAGE et DELTA"));
+                        etatCalibrateur=POTAR;
+                        affichage.affiche(POTAR);
+                    }
+                    break;
+                case FINDMINMAX: 
+                    //Serial.println("lalalal");
+                    //sequence pour aller au max puis au min et de déterminer
+                    //les pwm Min et Max du servo
+                    //----------------------------------------------------------
+                    //find max
+                    compteur=compteurRef;
+                    while (compteur>compteurRef-ERREURCOMPTAGE\
+                            && compteur<compteurRef+ERREURCOMPTAGE)
+                        {
+                            Serial.print("M+.....");
+                            compteur=0;
+                            //objTest=objTest+DELTA;
+                            leServo.setObjectif(leServo.getObjectif()+DELTA);
+                            sleep(TEMPOSLEEP);
+                            Serial.print(" cmptr="); Serial.println(compteur);
+                        }
+                    leServo.setMax(leServo.getObjectif()-DELTA);
+                    leServo.setObjectif(leServo.getMilieu());
+                    Serial.print("MAX="); Serial.println(leServo.getMax());
+                    Serial.println("retourneMilieu");
+                    sleep(TEMPOSLEEP);
+                    //----------------------------------------------------------
+                    //find mmin
+                    compteur=compteurRef;
+                    while (compteur>compteurRef-ERREURCOMPTAGE\
+                            && compteur<compteurRef+ERREURCOMPTAGE  )
+                        {
+                            Serial.print(F("M-......"));
+                            compteur=0;
+                            //objTest=objTest-DELTA;
+                            leServo.setObjectif(leServo.getObjectif()-DELTA);
+                            sleep(TEMPOSLEEP); 
+                            Serial.print(" cmpteur="); Serial.println(compteur);
+                        }
+                    leServo.setMin(leServo.getObjectif()+DELTA);
+                    leServo.setObjectif(leServo.getObjectif()+DELTA);
+                    Serial.print("MIN="); Serial.println(leServo.getMin());
+                    sleep(TEMPOSLEEP);
+                    Serial.println("la le servo est au min et va faire grande course");
+                    leServo.setObjectif(leServo.getMin());
+                    //----------------------------------------------------------
+                    //séquence pour mesurer une vitesse et amplitude moyenne
+                    //(10 cycles d'aller et retour de min à max
+                    //et enregistrement systématique des mesures)
+                    for (i=0;i<NBRCYCLE_AR;i=i+1)
+                        {
+                            compteur=0;
+                            compteurRef=0;
+                            //compteur ref utilisé différement dans la suite 
+                            //par rapport à ce qui était fait jusque là. Compteur 
+                            //ref est utilisé pour voir si le servo continue
+                            //de bouger
+                            tempsMesureVitesse=millis();
+                            Serial.print("tempsMesureVitesse=");
+                            Serial.println(tempsMesureVitesse);
+                            // Mesure de min vers max
+                            leServo.setObjectif(leServo.getMax());
+                            sleep(TEMPO_STAT);
+                            Serial.print("cmpt="); Serial.println(compteur);
+                            while (compteur>compteurRef+20)
+                                {
+                                    compteurRef=compteur;   
+                                    Serial.print("yop");
+                                    Serial.print(" cmpt=");
+                                    Serial.println(compteur);
+                                    sleep(TEMPO_STAT);
+                                }
+                            resultatImpulsionMax[i]=compteur;
+                            resultatTempsMax[i]=millis()-tempsMesureVitesse-\
+                                                    TEMPO_STAT;
+                            Serial.print(F("Cycle "));
+                            Serial.print(i);
+                            Serial.print(F(" imp= "));
+                            Serial.print(resultatImpulsionMax[i]);
+                            Serial.print(F(" temps= "));
+                            Serial.println(resultatTempsMax[i]);
+                        
+                            compteur=0;
+                            compteurRef=0;
+                            tempsMesureVitesse=millis();
+                            // Mesure de max vers min
+                            leServo.setObjectif(leServo.getMin());
+                            sleep(TEMPO_STAT);
+                            while (compteur>compteurRef+20)
+                                {
+                                    compteurRef=compteur;
+                                    Serial.print("yup ");
+                                    Serial.print("cmpt=");
+                                    Serial.println(compteur);
+                                    sleep(TEMPO_STAT);
+                                }
+                            resultatImpulsionMin[i]=compteur;
+                            resultatTempsMin[i]=millis()-tempsMesureVitesse-TEMPO_STAT;
+                            Serial.print(F("Cycle "));
+                            Serial.print(i+1);
+                            Serial.print(F(" imp= "));
+                            Serial.print(resultatImpulsionMin[i]);
+                            Serial.print(F(" temps= "));
+                            Serial.println(resultatTempsMin[i]);
+                        } //fin for NBCYCLES
    
          
              
-					Serial.println(F("ATTENTION regarder  et noter le sens de rotation du premier mouvement "));
-					Serial.println(F("si pret faire un clic "));
-					etatCalibrateur=WAITCLIC;
-				  
-				  
-				case WAITCLIC:
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-							etatCalibrateur=DISPRESULT;
-							leServo.setObjectif(leServo.getMax());
-						} 
-					break;
-
-				case DISPRESULT:  
-					
-                                        
-                              
-                                       Serial.println();
-                                       Serial.println();
-                                       
-                                       Serial.println(F("Alors quelle sens de rotation ?") ); 
-                                       Serial.println();
-                                       Serial.println();
-				                               Serial.print(F(" Dans le sens croissant pwm, moyenne : "));
-                                       Serial.print(moyenne(NBRCYCLE_AR,resultatImpulsionMax));
-                                       Serial.print(F(" impulsions (Ecart type : "));
-                                       Serial.print(ecartType(NBRCYCLE_AR,resultatImpulsionMax));
-                                       Serial.print(F(") atteintes en un temps moyen de : "));
-                                       Serial.print(moyenne(NBRCYCLE_AR,resultatTempsMax));
-                                       Serial.print(F(" ms (ecart type : "));
-                                       Serial.print(ecartType(NBRCYCLE_AR,resultatTempsMax));
-                                       Serial.println(F(" ms)"));
-
-                                       Serial.print(F(" Dans le sens decroissant pwm, moyenne  : "));
-                                       Serial.print(moyenne(NBRCYCLE_AR,resultatImpulsionMin));
-                                       Serial.print(F("impulsions (Ecart type : "));
-                                       Serial.print(ecartType(NBRCYCLE_AR,resultatImpulsionMin));
-                                       Serial.print(F(") atteintes en un temps moyen de : "));
-                                       Serial.print(moyenne(NBRCYCLE_AR,resultatTempsMin));
-                                       Serial.print(F(" ms (ecart type : "));
-                                       Serial.print(ecartType(NBRCYCLE_AR,resultatTempsMin));
-                                       Serial.println(F(" ms)"));
-                                       
-				                            
-                             			
-                            					//potence.setObjectif(potence.getMax());
-                            					Serial.println(F("si nouveau servo : doubleClic, si changement mode clic"));
-                            					etatCalibrateur=WAITCLIC2;               
-                            					break;
-				   
-				case WAITCLIC2: 
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-							etatCalibrateur=SWEEPTOMIN;
-							affichage.affiche(SWEEPTOMIN);
-							leServo.setObjectif(leServo.getMin());
+                    Serial.println(F("ATTENTION regarder  et noter le sens de rotation du premier mouvement "));
+                    Serial.println(F("si pret faire un clic "));
+                    etatCalibrateur=WAITCLIC;
+                  
+                  
+                case WAITCLIC:
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            etatCalibrateur=DISPRESULT;
+                            leServo.setObjectif(leServo.getMax());
+                        } 
+                    break;
+
+                case DISPRESULT:  
+                    Serial.println();
+                    Serial.println();
+                    Serial.println(F("Alors quelle sens de rotation ?") ); 
+                    Serial.println();
+                    Serial.println();
+                    Serial.print(F(" Dans le sens croissant pwm, moyenne : "));
+                    Serial.print(moyenne(NBRCYCLE_AR,resultatImpulsionMax));
+                    Serial.print(F(" impulsions (Ecart type : "));
+                    Serial.print(ecartType(NBRCYCLE_AR,resultatImpulsionMax));
+                    Serial.print(F(") atteintes en un temps moyen de : "));
+                    Serial.print(moyenne(NBRCYCLE_AR,resultatTempsMax));
+                    Serial.print(F(" ms (ecart type : "));
+                    Serial.print(ecartType(NBRCYCLE_AR,resultatTempsMax));
+                    Serial.println(F(" ms)"));
+                    Serial.print(F(" Dans le sens decroissant pwm, moyenne  : "));
+                    Serial.print(moyenne(NBRCYCLE_AR,resultatImpulsionMin));
+                    Serial.print(F("impulsions (Ecart type : "));
+                    Serial.print(ecartType(NBRCYCLE_AR,resultatImpulsionMin));
+                    Serial.print(F(") atteintes en un temps moyen de : "));
+                    Serial.print(moyenne(NBRCYCLE_AR,resultatTempsMin));
+                    Serial.print(F(" ms (ecart type : "));
+                    Serial.print(ecartType(NBRCYCLE_AR,resultatTempsMin));
+                    Serial.println(F(" ms)"));
+                    //potence.setObjectif(potence.getMax());
+                    Serial.println(F("si nouveau servo : doubleClic, si changement mode clic"));
+                    etatCalibrateur=WAITCLIC2;               
+                    break;
+                   
+                case WAITCLIC2: 
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            etatCalibrateur=SWEEPTOMIN;
+                            affichage.affiche(SWEEPTOMIN);
+                            leServo.setObjectif(leServo.getMin());
               Serial.print(F("bouger le potar modifie la vitesse, double click la sauve en prom "));
-						} 
-					if (boutonP.hasBeenDoubleClicked())
-						{
-							boutonP.acquit();
-							etatCalibrateur=MESREFPULSE;
-              leServo=servoTest(PINSERVO);
-							leServo.setObjectif(leServo.getMilieu());
-							//potence.setObjectif(bonnePositionPotence);
-							sleep(TEMPOSLEEP*3);
-						}    
-					break ;    
-					  
-				case SWEEPTOMIN:
-					if (leServo.isMin())
-						{
-							etatCalibrateur=SWEEPTOMAX;
-							leServo.setObjectif(leServo.getMax());
-						}
-
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-             lePotar.acquit();
-							etatCalibrateur=POTAR;
-							affichage.affiche(POTAR);
-						}
-
+                        } 
+                    if (boutonP.hasBeenDoubleClicked())
+                        {
+                            boutonP.acquit();
+                            etatCalibrateur=MESREFPULSE;
+                            leServo=servoTest(PINSERVO);
+                            leServo.setObjectif(leServo.getMilieu());
+                            //potence.setObjectif(bonnePositionPotence);
+                            sleep(TEMPOSLEEP*3);
+                        }    
+                    break ;    
+                      
+                case SWEEPTOMIN:
+                    if (leServo.isMin())
+                        {
+                            etatCalibrateur=SWEEPTOMAX;
+                            leServo.setObjectif(leServo.getMax());
+                        }
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            lePotar.acquit();
+                            etatCalibrateur=POTAR;
+                            affichage.affiche(POTAR);
+                        }
+                    if (lePotar.hasBeenMovedALot())
+                        {
+                         //Serial.println("plip");
+                          leServo.setVitesse(map(lePotar.getValue()\
+                                                ,0,1023,0,VITESSEMAXSERVO));
+                        }
+                    if (boutonP.hasBeenDoubleClicked())
+                        {
+                            boutonP.acquit();
+                            lePotar.getValue();
+                            //enregistre en eeprom
+                            EEPROM.put(ADRESSE_EEPROM, lePotar.getValue());
+                            Serial.print(F("sauver en prom vitesse = "));
+                            Serial.print( lePotar.getValue());
+                            Serial.print(F("microsec de PWM par seconde"));
+                        }
            
-           if (lePotar.hasBeenMovedALot())
-           {
-             //Serial.println("plip");
-              leServo.setVitesse(map(lePotar.getValue(),0,1023,0,VITESSEMAXSERVO));
-              
+                    break;
+        
+                case SWEEPTOMAX:
+                    if (leServo.isMax())
+                        {
+                            etatCalibrateur=SWEEPTOMIN;
+                            leServo.setObjectif(leServo.getMin());
+                        }
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            lePotar.acquit();
+                            etatCalibrateur=POTAR;
+                            affichage.affiche(POTAR);
+                        }
+                    if (lePotar.hasBeenMovedALot())
+                        {
+                            //Serial.println("plup");
+                            leServo.setVitesse(map(lePotar.getValue(),\
+                                                    0,1023,0,VITESSEMAXSERVO));
+                        }
+                    if (boutonP.hasBeenDoubleClicked())
+                        {
+                            boutonP.acquit();
+                            lePotar.getValue();
+                            //enregistre en eeprom
+                            EEPROM.put(ADRESSE_EEPROM,\
+                                        map(lePotar.getValue(),0,1023,0,\
+                                        VITESSEMAXSERVO));
+                            Serial.print(F("sauver en prom vitesse = "));
+                            Serial.print( map(lePotar.getValue(),\
+                                                0,1023,0,VITESSEMAXSERVO));
+                            Serial.print(F("microsec de PWM par seconde"));
+                        }
+                    break;
+
+                case POTAR:
+                    int temp;
+                    int potarVal;
+                    potarVal=lePotar.getValue();
+                    temp=map(potarVal,0,1023,leServo.getMin(),leServo.getMax());   
+                    leServo.setObjectif(temp);
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            etatCalibrateur=4;
+                            affichage.affiche(4);
+                            //leServo.setObjectif(leServo.getMilieu());
+                        }
+                    break;
+        
+                case MILIEU:
+                    leServo.setObjectif(leServo.getMilieu());
+                    if (boutonP.hasBeenClicked())
+                        {
+                            boutonP.acquit();
+                            etatCalibrateur=1;
+                            affichage.affiche(1);
+                        }
+                    break;
+               
+                case 8:
+                    break;
             }
-           
-
-            if (boutonP.hasBeenDoubleClicked())
-           {
-              boutonP.acquit();
-              lePotar.getValue();
-              EEPROM.put(ADRESSE_EEPROM, lePotar.getValue());//enregistre en eeprom
-              Serial.print(F("sauver en prom vitesse = ")); Serial.print( lePotar.getValue());Serial.print(F("microsec de PWM par seconde"));
-            }
-           
-					break;
-		
-				case SWEEPTOMAX:
-					if (leServo.isMax())
-						{
-							etatCalibrateur=SWEEPTOMIN;
-							leServo.setObjectif(leServo.getMin());
-						}
-
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-              lePotar.acquit();
-							etatCalibrateur=POTAR;
-							affichage.affiche(POTAR);
-						}
-
-             if (lePotar.hasBeenMovedALot())
-           {
-              
-              //Serial.println("plup");
-               leServo.setVitesse(map(lePotar.getValue(),0,1023,0,VITESSEMAXSERVO));
-              
-            }
-
-           
-          if (boutonP.hasBeenDoubleClicked())
-           {
-              boutonP.acquit();
-              lePotar.getValue();
-              EEPROM.put(ADRESSE_EEPROM, map(lePotar.getValue(),0,1023,0,VITESSEMAXSERVO));//enregistre en eeprom
-              Serial.print(F("sauver en prom vitesse = ")); Serial.print( map(lePotar.getValue(),0,1023,0,VITESSEMAXSERVO));Serial.print(F("microsec de PWM par seconde"));
-            }
-					break;
-
-				case POTAR:
-					int temp;
-					int potarVal;
-					potarVal=lePotar.getValue();
-					//Serial.print("lepotar : ");
-					//Serial.println(potarVal);
-					temp=map(potarVal,0,1023,leServo.getMin(),leServo.getMax());
-					// if (leServo.getType())
-					// {
-					// temp=map(potarVal,0,1023,300,3000);
-					// }
-					// else
-					// {
-					// temp=map(potarVal,0,1023,100,1000);
-					// }
-					//Serial.print ("OBJECTIF=  ");
-					//Serial.println(temp);   
-					leServo.setObjectif(temp);
-					//potence.setObjectif(temp);
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-							etatCalibrateur=4;
-							affichage.affiche(4);
-							//leServo.setObjectif(leServo.getMilieu());
-						}
-					break;
-		
-				case MILIEU:
-					leServo.setObjectif(leServo.getMilieu());
-					if (boutonP.hasBeenClicked())
-						{
-							boutonP.acquit();
-							etatCalibrateur=1;
-							affichage.affiche(1);
-						}
-					break;
-			   
-				case 8:
-					break;
-			}
 
     
     
     
-	}
+    }
 
 
           
 void setup() 
 { 
   int vitesseDinit;    
-	Serial.begin(57600);
-	//potence.setPotence(); 
+    Serial.begin(57600);
+    //potence.setPotence(); 
   lePotar.init();
-	leServo.setType(true);
+    leServo.setType(true);
   EEPROM.get(ADRESSE_EEPROM, vitesseDinit);
  // Serial.print("vitesse lu=");Serial.println(vitesseDinit);
   if (vitesseDinit<=VITESSEMAXSERVO && vitesseDinit>=0)

         
void loop ()
{
	mySCoop.sleep(1);
	if (millis()>2000+temp)
		{
			temp=millis();
		}

}


//servoTest potence(11);
unsigned long dateChangeServo;
bool changeTypeServo(false);

int compteur(0); //variable compteur d'impulsions
                //mise à jour par interruptions
                
int compteurRef(0);
int resultatImpulsionMax[NBRCYCLE_AR];
long resultatTempsMax[NBRCYCLE_AR];
