chaine de caracteres et calcul

bonjour,

Alors voila je débute sur arduino et j'aurais besoin d'aide pour le programme, J'ai bidouillé comme j'ai pu et sa donne sa :

 int brightness = 0;    
int fadeAmount = 5;  
const int ledPin =  9;
int ledState = 0;     // ledState used to set the LED
unsigned long DELMIC = 0;
long previousMillis = 0;        // will store last time LED was updated
long interval = 1000;


void setup()
{
  Serial.begin(9600);

  // prints title with ending line break
  Serial.println("mise au point affichage");
  Serial.println("selection du mode de commande");
  Serial.println("1 : test led");
  Serial.println("2 : frequence de xhz");
  Serial.println("3 : definir une frequence entre 1 et 1 000 000");
  
  pinMode(ledPin, OUTPUT); 
  
}



void loop()
{
  
  unsigned long currentMillis = millis();
    if (Serial.available() > 0) {
      int DELMIC = Serial.read();
      Serial.println(DELMIC, DEC);
      // do something different depending on the character received.  
      // The switch statement expects single number values for each case;
      // in this exmaple, though, you're using single quotes to tell
      // the controller to get the ASCII value for the character.  For
      // example 'a' = 97, 'b' = 98, and so forth:


      switch (DELMIC) {
        
        
        case '1':  
         for(;DELMIC < 50;) {  
                  analogWrite(ledPin, brightness);   
               
                   DELMIC = Serial.read();
                
                  // change the brightness for next time through the loop:
                  brightness = brightness + fadeAmount;

                  // reverse the direction of the fading at the ends of the fade:
                    if (brightness == 0 || brightness == 255) {
                      fadeAmount = -fadeAmount ;
                      
                     }    
                  // wait for 30 milliseconds to see the dimming effect    
                  delay(5); 
                 }
            break;
          
          
          
          
        case '2': 
            if (DELMIC==50) {
             for(;DELMIC < 51;){  
              DELMIC = Serial.read();
              analogWrite(ledPin, 0);   // set the LED on
              delay(100);              // wait for a second
              analogWrite(ledPin, 255);    // set the LED off
              delay(100);   
            }
            
            }
          break;
          
       /* case '3':    
         for(;DELMIC == 51;) {
          
            Serial.println("definir une frequence");
        
          
            Serial.read();
              Serial.print("I received: ");
              
              
              
              
              if (DELMIC == 113){
               
                

	        Serial.println(DELMIC, DEC);



              DELMIC = 1/DELMIC;
              DELMIC = DELMIC*500000;
              Serial.println(DELMIC, DEC);
              Serial.println('A');
              }
          analogWrite(ledPin, 0);   // sets the pin on
          delayMicroseconds(DELMIC);        // pauses      
          analogWrite(ledPin, 255);    // sets the pin off
          delayMicroseconds(DELMIC);        // pauses     
         }
          
         
          break;
    
*/
        default:
          // turn all the LEDs off:
          
          Serial.println("erreur");
          
        //  if (DELMIC == 'q') {
                          analogWrite(ledPin, 255);
             //             }
      }
    } 
}

Alors ce programme donne le choix entre éclairer progressivement la led la faire clignoter, et donc définir une fréquence via le port série...
J'ai du mal avec les conditions de sortie des boucles, mais c'est surtout la récupération de la donné sur le port série ( la fréquence doit allez de 1 à 1 000 000)que je ne comprend pas trop comment prendre les caractères dans le tableau et les "rassembler", si quelqu'un pouvais m'expliquer.

Je vous remercie d'avance pour le coup de pousse

Pour la boucle for(;DELMIC < 50;) ( while(DELMIC < 50) ça revient au même) comme ton '1' vaut 49 la condition d'arrêt est directement validé non ?
Un do while pour être au moin certain de rentré un fois dans la boucle?

for(;DELMIC < 51;)

idem, tu dis temps que DELMIC (qui vaut '2' ou 50) est inférieure à 51, donc pas d'entrée dans la boucle ?

case '2': 
            if (DELMIC==50) {

ici pourquoi vérifié si DELMIC==50 puisque case '2' vaut 50 ?

comment prendre les caractères dans le tableau et les "rassembler"

Quel tableau ? Ce qui doit être dans le buffer du port série ?
Peut être d'abord récupéré toute les entrées série et traité après ?
:wink:

bonjour,

Avec ton aide et quelque recherche j'ai un peut avancé,

int brightness = 0;    
int fadeAmount = 5;  
const int ledPin =  9;
int ledState = 0;     // ledState used to set the LED
unsigned long DELMIC = 0;
long previousMillis = 0;        // will store last time LED was updated
long interval = 1000;


void setup()
{
  Serial.begin(9600);

  // prints title with ending line break
  Serial.println("mise au point affichage");
  Serial.println("selection du mode de commande");
  Serial.println("1 : test led");
  Serial.println("2 : frequence de xhz");
  Serial.println("3 : definir une frequence entre 1 et 1 000 000");
  
  pinMode(ledPin, OUTPUT); 
  
}



void loop()
{
  
  unsigned long currentMillis = millis();
    if (Serial.available() > 0) {
      int DELMIC = Serial.read();
      Serial.println(DELMIC, DEC);
      // do something different depending on the character received.  
      // The switch statement expects single number values for each case;
      // in this exmaple, though, you're using single quotes to tell
      // the controller to get the ASCII value for the character.  For
      // example 'a' = 97, 'b' = 98, and so forth:


      switch (DELMIC) {
        
        
        case '1':  
         do {  
                  analogWrite(ledPin, brightness);   
               
                   DELMIC = Serial.read();
                
                  // change the brightness for next time through the loop:
                  brightness = brightness + fadeAmount;

                  // reverse the direction of the fading at the ends of the fade:
                    if (brightness == 0 || brightness == 255) {
                      fadeAmount = -fadeAmount ;
                      
                     }    
                  // wait for 30 milliseconds to see the dimming effect    
                  delay(5); 
                 }while (DELMIC < 50);
            break;
          
          
          
          
        case '2': 
            if (DELMIC==50) {
             for(;DELMIC < 51;){  
              DELMIC = Serial.read();
              analogWrite(ledPin, 0);       // set the LED on
              delay(100);                  // wait for a second
              analogWrite(ledPin, 255);    // set the LED off
              delay(100);   
            }
            
            }
          break;
          
       case '3':    
        
          if (DELMIC==51) {
         for(;DELMIC < 113;) {
          
           
              int tableau[8] = {};        //tableau ou je vais mettre les valeurs
              int val = -1;               //differente variable pour les boucles et le calcul
              int X;
              int FIN;
              int j;
            Serial.println("definir une frequence et finir par un .");
  
             

             while(Serial.available() > 0) {
             
             for(j=7; j==0 ;j--)
             {          //remplissage du tableau
              
                  
                  tableau[j]= Serial.read();
                  Serial.println(tableau[j], DEC);
                  
              }
             
              /*while (val == -1)                  //je voulais un retour mais j'ai simplifié pour mieux comprendre
              {
              val= Serial.read();
             Serial.println(val, DEC);
              }*/
              
              //for(FIN=7;FIN==0;FIN--){          //test de fin de tableau
               Serial.println(tableau[0], DEC);   //test du tableau
               Serial.println(tableau[1], DEC);
               Serial.println(tableau[2], DEC);
               Serial.println(tableau[3], DEC);
               Serial.println(tableau[4], DEC);
               Serial.println(tableau[5], DEC);
               Serial.println(tableau[6], DEC);                                             
               Serial.println(tableau[7], DEC);
              //}
              //Serial.flush();
             }
              /*
              Tab=7-Fin;                        //facteur mise a niveaux pour l'ordre de passage 
              int u=1;
              int tab = Tab
              for(;tab<0;tab--) {
              U=U*10;
              }
              
              int Frek = 0;                    //creation de la valeur
              for(;Tab==0;Tab--){
              Frek =Frek+tableau[7-Tab]*U;
              U/10;
              }
              
              */
        
              
              
              
              
              
              
              
              
              
            //  frequ = frequ + Tableau [i]10^i
              
              
              
              
              
              
              
              
              
              if (DELMIC == 113){
               
                

	        Serial.println(DELMIC, DEC);



              DELMIC = 1/DELMIC;
              DELMIC = DELMIC*500000;
              Serial.println(DELMIC, DEC);
              Serial.println('A');
              }
          analogWrite(ledPin, 0);   // sets the pin on
          delayMicroseconds(DELMIC);        // pauses      
          analogWrite(ledPin, 255);    // sets the pin off
          delayMicroseconds(DELMIC);        // pauses     
         }
        
          } 
          break;
   

       /* default:
          // turn all the LEDs off:
          
          Serial.println("erreur");
          
        //  if (DELMIC == 'q') {
                          analogWrite(ledPin, 255);
             //             }*/
      }

}
}

j'ai modifié mes boucles mais le système de récupération de la donné ne fonctionne pas ma boucle fort ne remplie pas le tableau je vais jeté un œil au buffer merci :slight_smile:

Salut,

Tes boucles sont un peu compliquées (ça fait vraiment "bricolage"...). Il faudrait que tu saches exactement comment devrait réagir ton prog en fonction des données que tu lui envoies.

Le fait d'avoir DELMIC = Serial.read() dans les boucles n'est pas très heureux, car si tu n'envoies rien, tu obtiens -1. je remplacerais par if (Serial.available()) DELMIC = Serial.read(); ce qui te permet de conserver la première valeur de commande ('1', '2' ou '3' selon la boucle).

Essaies aussi de déclarer tes variables en global (en dehors de la fonction loop()), car tu risques de ne pas pouvoir les utiliser plus tard.

Ton remplissage de tableau ne peut pas marches pour les mêmes raisons du DELMIC que je t'ai proposé. Serial.read() renvoie -1 si le buffer est vide. donc avant de lire la valeur reçue, attends qu'elle arrive...

Tu as une boucle "while (Serial.available()>0)" dans laquelle tu ne rentreras jamais : il faut traduire de temps en temps, ça donne "tant qu'il y a des données séries dans le buffer" : comme au moment du test d'entrée de boucle, le buffer est vide (ça va trop vite pour qu'une donnée série soit arrivée entre temps), alors on n'entre pas dans la boucle, donc on ne remplit pas le tableau!

if (DELMIC == 113){ (...) ce test n'a aucune valeur, voir les commentaires que j'ai mis, et pense aux types de variables (capacités!), essaies de penser comme à l'école primaire : tu travailles avec un entier, alors ne tient pas compte des décimales : 1/113 = 0.

Comme je suis gentil, j'ai réorganisé ton code, il était illisible (faut penser à ça, moi, je n'utilise jamais de tabulations, toujours des espaces).

J'ai commencé à le réécrire, changer tes boucles etc etc, mais je comprends pourquoi ça ne marche pas : tout est erroné! ça part dans tous les sens, genre une boucle for, qui se traduit par "Pour (initialisation), tant que (condition), (incrémentation)". Dans ton cas, tu codes "for (j=7; j==0; j--)", ça donne en français "Pour j=7, tant que j est égal à 0, décrémenter j". forcément, dès le premier test, on sort de la boucle.

// variables à déclarer en début de programme

  int tableau[8] = {};        //tableau ou je vais mettre les valeurs
  int val = -1;               //differente variable pour les boucles et le calcul
  byte FIN;
  byte j;

// cas N°3

  case '3':     
    if (DELMIC==51) {

      while(DELMIC < 113) {  
         
        Serial.println("definir une frequence et finir par un .");
        while(!Serial.available());  // boucle d'attente d'arrivée d'une valeur série

        for(j=7; j>0 ;j--){          //remplissage du tableau
          while (!Serial.available());   // boucle d'attente d'arrivée d'une valeur série
          tableau[j]= Serial.read();
          Serial.println(tableau[j], DEC);
        }

        for(j=0; j<=7 ;j++){          //remplissage du tableau
          Serial.println(tableau[j], DEC);   //test du tableau
        }

        if (DELMIC == 113){
          Serial.println(DELMIC, DEC);
          DELMIC = 1/DELMIC;              // DELMIC = 113, donc 1/113 = 0!!!
          DELMIC = DELMIC*500000;          // un int est limité à +/- 32767, donc pourquoi le multiplier par 500 000???
          Serial.println(DELMIC, DEC);
          Serial.println('A');
        }

        analogWrite(ledPin, 0);   // sets the pin on
        delayMicroseconds(DELMIC);        // pauses      
        analogWrite(ledPin, 255);    // sets the pin off
        delayMicroseconds(DELMIC);        // pauses     
      }

    } 
    break;

Ne cherche pas, ce bout de code ne marche toujours pas (je vais pas y passer ma matinée...), un conseil, mets tout à la poubelle, et recommence sur une feuille blanche, c'est trop brouillon et tu en as rajouté dans tous les sens. attention aux copier / coller, et pense à faire une mise en page propres, tu t'y retrouveras bien mieux.

va voir sur http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ReferenceEtendue, c'est là que tu comprendras les fonctions que tu utilises. copier un code qu'on ne comprend pas ne mène souvent à rien!

Bon courage!

cinci

Super_Cinci:
un conseil, mets tout à la poubelle, et recommence sur une feuille blanche

Sage conseil, parfois on gagne plus de temps de tout reprendre à 0 plutôt que de s’obstiné et resté bloqué.
Procède par étapes, commence par voir pour la récupération des données série, ensuite tu agis en conséquence.

Bon après avoir retravaillé tout sa j'ai réussi (sans tout jeter) ^^

le code donne sa :

int brightness = 0;    
int fadeAmount = 5;  
const int ledPin =  9;
int ledState = 0;     // ledState used to set the LED
unsigned long DELMIC = 0;
long previousMillis = 0;        // will store last time LED was updated
long interval = 1000;


void setup()
{
  Serial.begin(9600);

  // prints title with ending line break
  Serial.println("mise au point affichage");
  Serial.println("selection du mode de commande");
  Serial.println("1 : test led");
  Serial.println("2 : frequence de xhz");
  Serial.println("3 : definir une frequence entre 1 et 1 000 000");
  
  pinMode(ledPin, OUTPUT); 
  
}



void loop()
{
  
              byte tableau[8] = {};        //tableau ou je vais mettre les valeurs
             // int val = -1;               //differente variable pour les boucles et le calcul
              int X;
              int FIN= 0;
              int j =7;
              unsigned long U=1;
              int tab;
              int Tab;
              unsigned long Frek = 0;
          
            
  unsigned long currentMillis = millis();
    if (Serial.available() > 0) {
      int DELMIC = Serial.read();
      Serial.println(DELMIC, DEC);
      // do something different depending on the character received.  
      // The switch statement expects single number values for each case;
      // in this exmaple, though, you're using single quotes to tell
      // the controller to get the ASCII value for the character.  For
      // example 'a' = 97, 'b' = 98, and so forth:


      switch (DELMIC) {
        
        
        case '1':  
         do {  
                  analogWrite(ledPin, brightness);   
               
                   DELMIC = Serial.read();
                
                  // change the brightness for next time through the loop:
                  brightness = brightness + fadeAmount;

                  // reverse the direction of the fading at the ends of the fade:
                    if (brightness == 0 || brightness == 255) {
                      fadeAmount = -fadeAmount ;
                      
                     }    
                  // wait for 30 milliseconds to see the dimming effect    
                  delay(5); 
                 }while (DELMIC < 50);
            break;
          
          
          
          
        case '2': 
            if (DELMIC==50) {
             for(;DELMIC < 51;){  
              DELMIC = Serial.read();
              analogWrite(ledPin, 0);       // set the LED on
              delay(100);                  // wait for a second
              analogWrite(ledPin, 255);    // set the LED off
              delay(100);   
            }
            
            }
          break;
          
       case '3':    
        
          if (DELMIC==51) {
         for(;DELMIC < 113;) {
          int 	calc = 0;
           
         
            Serial.println("definir une frequence et finir par un .");
  
             do
             {                        //remplissage du tableau
                  
                   if (Serial.available() > 0) { // si des données entrantes sont présentes

                                                 tableau[j]= Serial.read();  //remplissage du tableau
                                                 calc++;                     //incrementation du nombre de case utilisé
                                      
                                      if (tableau[j]== '.') {                //sortie si on à le point
                                      
                                                            j=0;
                                                            }
                                                   j--;
                                              
                                               }
                  
              }while(j>0);

               do{                                  
              
              Tab=calc-1;                        //ordre de passage 
              tab = Tab-1;                       //nombre de passage
              while(tab>0)       {
                                 U=U*10;           //mise a niveau des centaines dizaines unités
                                 tab--;
                                 }
              
           
                 j=7;          //au commence a l'emplacement 7 du tableau ou se trouve la premiere donné(non pas 0?)
                               //creation de la valeur
              do                {

                                Frek = Frek+(tableau[j]-48)*U;  //calcul de la frequence, le -48 car il garde la designation ascii
                                U=U/10;                         //toujours les centaines dizaines unités
                                j--;
                                Tab--;
                                }while(Tab>0);


             
              Serial.println(Frek);                            //affichage de la frequence obtenue par calcul, correct
              Frek = Frek/2;                          
              Frek = 1000000/Frek;
              Serial.println(Frek);                            //toujours correct j'ai donc une demi periode de la frequence donné exprimmé en µs
              Serial.println("end");
          
            
          
        
         }while(FIN>0);
              
         do{
          analogWrite(ledPin, 0);         //la on rigole moin vue qu'en fonction de la frequence j'ai fais des mesures
          delayMicroseconds(Frek);        //pour 10hz  100 1000 10000 
          analogWrite(ledPin, 255);       //on a 146hz 137  247  2.38khz
         delayMicroseconds(Frek);         //
          }while(DELMIC < 113);           //le while est juste la pour boucler

       }
        
     }
          
          
          
          break;
   

        default:
         Serial.println("erreur");
                          analogWrite(ledPin, 0);

      }

    }
}

Bon tout marche a part que la fréquence de sortie est a coté de la plaque, je sais pas je vais revoir mes calculs...

         do{
          analogWrite(ledPin, 0);         //la on rigole moin vue qu'en fonction de la frequence j'ai fais des mesures
          delayMicroseconds(Frek);        //pour 10hz  100 1000 10000 
          analogWrite(ledPin, 255);       //on a 146hz 137  247  2.38khz
         delayMicroseconds(Frek);         //
          }while(DELMIC < 113);           //le while est juste la pour boucler

Pourquoi un analogWrite? un digitalWrite serait plus simple (plus précis). Il faut savoir que le délaiµs n'est déjà pas très précis, et qu'il faut rajouter le traitement, et les interruptions, si un jours t'as le temps, regarde de plus près les timers, tu verras qu'en mettant juste le bout des doigts dans le cambouis (en accédant directement aux registres des timers, pas par la librairie timer2 qui est une usine à gaz très très mal programmée), on arrive à des choses merveilleuses d'une stabilité et précision à toute épreuve!

Il y a des tests inutiles qui compliquent l'interprétation.
Quand tu fais

        case '2': 
            if (DELMIC==50) {
                 .........

ou

        case '3': 
            if (DELMIC==51) {
                 .........

C'est totalement inutile puisque tu vient d'entrer dans ce case avec le code du caractère que tu testes. DELMIC ne peut pas valoir autre chose.

for(;DELMIC < 113;) {

C'est pas très parlant il serait préférable d'écrire

for(;DELMIC < 'q';) {

Au lieu de mettre de dizaines de lignes de code dans chaque case il est beaucoup plus clair de faire des fonctions qui sont appelées dans le case.
En plus ces petites fonctions peuvent testées individuellement beaucoup plus facilement.

Parce que ta saisie de la fréquence c'est pas un cadeau.

Bonjour,

J'ai enlevé les tests inutile, j'ai testé le digitalwrite Puis j'ai modifié le calcul qui était faux en inversant la division par deux et celle par 1000000, la bonne valeur est utilisé et le composant me donne la valeur de fréquence sur une plage allant de 5us à 16832 je croie "lue sur le site et testé", par contre je ne comprend pas pourquoi il ne descend pas à moins de 5 us correctement "on peut aller jusqu'à 3 d'après le site" je regarde actuellement La librairie timer2, sa fonctionne sauf que c'est de l'ordre de la millisecondes et je voudrais des microsecondes...mais je pense m'en servir pour arriver à mes fin.

salut bon je viens vous demander encore un coup de main voila pour faire ma variation de fréquence je suis parti sur sa :

void setup()
{
  pinMode(11, OUTPUT); 
  //on interdit les interruptions.
  TIMSK2 &= ~(1<<TOIE2);
  //configuration timer
  TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/ | 1<<CS20  |  1<<CS22 /* prescaler a 128*/);
  //valeur a compter dans tcnt2
  OCR2A=10;
  //autorisation d'interruption 
  //TIMSK2 |=(1<<TOIE2);
}
  

void loop()
{
  Serial.println("test");
  sei();
  Serial.println("test");
}

et sa ne marche pas sa ne fais meme pas les print...du coups je voulais savoir si quelqu'un avais une idée merci

salut,

j'essaie de comprendre...

Première chose : les bits CS2:0 sont sur le registre TCCR2B... tu modifies donc WGM0, je ne suis pas sur que c'était ça que tu voulais faire...

Que cherches tu réellement à faire (fréquence? PWM?)? Pourquoi un sei() dans loop? ça ne sert a rien dans ton cas...

et si tu mets un Serial.begin() dans le setup, ça marchera peut-être mieux...

Les timers sont assez complexes car ils permettent de faire énormément de choses, donc tout dépend de ce que tu attends du timer

Salut,

Je cherche a faire sortir un signale carré, de fréquence assez élevé, le sei est la pour réactiver les interruptions, en fait c'était un test, car je n'est en sortie ni la fréquence ni aucun des print (qui sont totalement secondaire). Je pensais que les CS20, CS21 et CS22 servaient à régler le prescaler, mais je voie se que tu veut dire je viens de regarder la doc atmel qui différente de celle que j'avais pour travailler au début , dans l'ancienne les CS était dans tccr2a.

après relecture de la bonne doc sa donne sa et sa marche :

void setup()
{
  
  pinMode(11, OUTPUT); 


  //configuration timer 
  //mise a zeros des registres
  TCCR2B = 0;
  TCCR2A = 0;
  
  
  TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
  TCCR2B = (  1<<CS21   |  1<<CS22 |  1<<CS20 /* prescaler a 128*/);
  //valeur a compter dans tcnt2
  OCR2A=1023;
  

   ASSR &= ~(1 << AS2);         // horloge interne Timer/Counter2
  
}
  

void loop()
{
}

Reste plus qu'a intégrer sa dans le programme précédant et c'est gagné ^^

ok,

n'oublie pas un serial.begin() dans setup{} pour "ouvrir" le port série!

Je commence à me dire qu'il serait intéressant d'avoir un fichier genre excel ou une page PHP (encore mieux) qui permette de calculer rapidement les valeurs à mettre dans les registres selon les fonctions et valeurs que l'on cherche en sortie, que ce soit en timer (ISR, PWM, compteur...), liaisons série... Je crois que je vais plancher là-dessus... car je me prends souvent la tête à cause de ça, je ne mémorise jamais l'emplacement des bits dans les registres, et je dois toujours reprendre la doc pendant 1h...

Oui, les CSx servent au prescaler (CS = Clock Selection), en gros : CS = 0 => pas d'horloge, CS = 1 => horloge 16MHz, CS = (2, 3, 4...) => Prescaler (/8, /16)...

EDIT : attention à ta ligne OCR2A = 1023 : le timer2 est en 8 bits (dans ce cas, cette ligne sera interprétée comme OCR2A = 255)!!! donc tes calculs doivent être faux...

Super_Cinci:
Je commence à me dire qu'il serait intéressant d'avoir un fichier genre excel ou une page PHP (encore mieux) qui permette de calculer rapidement les valeurs à mettre dans les registres selon les fonctions et valeurs que l'on cherche en sortie, que ce soit en timer (ISR, PWM, compteur...), liaisons série... Je crois que je vais plancher là-dessus... car je me prends souvent la tête à cause de ça, je ne mémorise jamais l'emplacement des bits dans les registres, et je dois toujours reprendre la doc pendant 1h...

Si quelqu'un me donne les relations, je peux le faire sans soucis.
Probablement aussi en javascript (portable & offline).

D.

Ok j'ai donc fini mon programme je vous l'envoie sa ressemble pas vraiment a se que je prévoyais dans ma tête, mais si sa se passais toujours bien se serais bien moins rigolo XD

int brightness = 0;    
int fadeAmount = 5;  
int ledPin = 11;
int ledState = 0;     // ledState used to set the LED
int DELMIC = 0;
int Freq = 0;


void setup()
{
  Serial.begin(9600);

  // prints title with ending line break
  Serial.println("mise au point affichage");
  Serial.println("selection du mode de commande");
  Serial.println("1 : test led seulment en premier");
  Serial.println("2 : frequence de 5hz");
  Serial.println("3 : definir une frequence entre 100hz et 1Mhz");
  
  pinMode(ledPin, OUTPUT); 
  

 /******************************************************************/
 
  
}



void loop()
{
    
 
    if (Serial.available() > 0) {
      DELMIC = Serial.read();
      Serial.println(DELMIC, DEC);
      
      switch (DELMIC) {
        
        
        case '1':  
         do {  
                  analogWrite(ledPin, brightness);   
               
                   DELMIC = Serial.read();
                
                  // change the brightness for next time through the loop:
                  brightness = brightness + fadeAmount;

                  // reverse the direction of the fading at the ends of the fade:
                    if (brightness == 0 || brightness == 255) {
                      fadeAmount = -fadeAmount ;
                      
                     }    
                  // wait for 30 milliseconds to see the dimming effect    
                  delay(5); 
                 }while (DELMIC < 50);
            break;
/**************************************************************************************************************************
***************************************************************************************************************************
**************************************************************************************************************************/
          
          
          
        case '2': 
          
             for(;DELMIC < 51;){  
              DELMIC = Serial.read();
              analogWrite(ledPin, 0);      // set the LED on
              delay(100);                  // wait for a second
              analogWrite(ledPin, 255);    // set the LED off
              delay(100);   
            }
            
        
          break;
/**************************************************************************************************************************
***************************************************************************************************************************
**************************************************************************************************************************/         
          
       case '3':    
          
          Serial.println("Choisir votre frequence parmi celle-ci");
          Serial.println("1 : 100hz    2 : 500hz    3 : 1khz");
          Serial.println("4 : 2000hz   5 : 5000hz   6 : 10khz");
          Serial.println("7 : 50khz    8 : 100khz   9 : 1Mhz");

          do { 
          if (Serial.available() > 0) {
          Freq = Serial.read();
            //configuration timer 
            //mise a zeros des registres
            TCCR2B = 0;
            TCCR2A = 0;
            OCR2A=0;
            ASSR &= ~(1 << AS2);   // horloge interne Timer/Counter2
            
            
            switch (Freq) {
            
            
            case '1':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS22 | 1<<CS21 | 1<<CS20 /* prescaler  111 1024*/);
            OCR2A=77; //Valeur de ocr pour 10hz
            Serial.println("100hz");
            break;
            
            case '2':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS22 | 1<<CS20 /* prescaler  101 128*/);
            OCR2A=124; //Valeur de ocr pour 500hz
            Serial.println("500hz");
            break;
           
            case '3':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );    
            TCCR2B = ( 1<<CS21 | 1<<CS20 /* prescaler  011 32*/);
            OCR2A=249; //Valeur de ocr pour 1000hz
            Serial.println("1000hz");
            break;
        
            case '4':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS21 | 1<<CS20 /* prescaler  011 32*/);
            OCR2A=124; //Valeur de ocr pour 2000hz
            Serial.println("2000hz");
            break;
            
            case '5':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS21 /* prescaler  010 8*/);
            OCR2A=199; //Valeur de ocr pour 5000hz
            Serial.println("5000hz");
            break;
            
            case '6':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS21 /* prescaler  010 8*/);
            OCR2A=99; //Valeur de ocr pour 10khz
            Serial.println("10khz");
            break;
            
            case '7':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS20 /* prescaler  001 1*/);
            OCR2A=159; //Valeur de ocr pour 50khz
            Serial.println("50khz");
            break;
            
            case '8':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS20 /* prescaler  001 1*/);
            OCR2A=79; //Valeur de ocr pour 100khz
            Serial.println("100khz");
            break;
            
            case '9':
            TCCR2A = ( 1<<WGM21/*ctc mode*/ | 1<<COM2A0 /*toggle mode*/  );
            TCCR2B = ( 1<<CS20 /* prescaler  001 1*/);
            OCR2A=7; //Valeur de ocr pour 1Mhz
            Serial.println("1Mhz");
            break;
           
            default:
            Serial.println("recommencé?");
            analogWrite(ledPin, 0);
            }

        
              
          }
                 
          }while (Freq < 112);           
                  
                 

                         
      
        break;      
/**************************************************************************************************************************
***************************************************************************************************************************
**************************************************************************************************************************/
      
         default:
         Serial.println("fin");
         analogWrite(ledPin, 0);

                  }

            }
}

et encore merci beaucoup pour votre aide