besoin d'aide pour un retraité qui se met à l'arduino

bonjour à tous

Et bien pour le fun l'arduino a excité ma curiosité .Donc pour le fun j'ai entrpri de faire un programme qui mesure la période d'un signal cilyque de forme carré .(je me contente au départ d'une fréquence basse de 50Hz [sortie d'une horloge cmos en 5V {NE555 en multivribateur )
Mais cela ne marche pas tout à fait comme je le désire car comme on peut le voir sur l'image ci jointe que périodiquement j'ai des valeurs aberrantes (entourées en rouge ) et très bonnes (entourée en vert).
La mesure de la période en µS est très juste comparée à la valeur mesurée par l'oscillo .

DONC mon PROBLEME est de trouver pourquoi !!! je cherche depuis un moment et je n'ai pas trouvé et je n'ai plus d'idées >:( .Je pense que c'est ma programmation qui ne va pas mais ou ? C'est pour cela que je fais appelle à votre connaissance de la programmation arduino ou en C++ .
Je joins mon programme en espèrant qu'il assez bien renseigné et bien indenté (je debute ). [
:confused:

//***************************************************
/*nomdu programme: "periodemetre" le 17/06/2020 
en cours d'elaboration */
//***************************************************

//*************************************************** 
/* ce proogramme permet de mesurer la période d'un signal
donc sa frequence F =1/T .Dans le cas présent le prediviseur 
scalaire (frequence de comtage entre deux front montant du signal)
et programmée sur / par 8 soit 40000 impulsions pour 20ms soit 50HZ.
valper la variable de mesure et un Word soit (65000) au max */   
//*************************************************** 

//***************************************************
// declaration et initialisation des variable globales
//***************************************************** 
          float freq = 0 ;
     volatile byte mempint = 0 ; /*memoire de la première 
                                   interruption sur front montant*/  
     volatile byte memdint = 0; /*memoire de la deuxieme 
                                  interruption sur front montant*/ 
 
     volatile unsigned long  valeurdebut = 0;// valeur horloge interne de debut de mesure 
     volatile unsigned long  valeurfin = 0;//valeur horloge interne de fin de mesure 
     volatile unsigned long  Valper  = 0 ; /*valeur mesurée de la période 
                                            entre deux front montant*/                          
//************************************************
// setup (initialisation des varaiables    
//************************************************     
void setup() {//debut setup
              //======================================
              //prépositionnement du bus de lecture serie
              //======================================
                Serial.begin(115200);
              //======================================
              //declaration de la pin d'entée signal
              //====================================== 
               
                pinMode(2,INPUT_PULLUP);
              //======================================
              //Relie l'interuption la pin d'entrée N°2
              //====================================== 
              attachInterrupt(INT0,(isr1),RISING); 
       
             }//fin du setup 
             
//************************************************
// programme principal (loop)  
//************************************************
void loop() {// debut du loop
                delay(1000); //en ms impair par rapport à 20000µs pour temps de calcul 
                Valper = 0;//remise à zero de la valeur mesuree de la periode d'enrée   
                Valper =  valeurfin - valeurdebut;// calul de la valeur de la periode
                freq = 1/(float(Valper)/1000000) ; 
                Serial.println("Valper");
                Serial.println(Valper);
                Serial.println("freq");
                Serial.println(freq);
               /*Serial.println("valeurdebut");
                Serial.println(valeurdebut);
                Serial.println("valeurfin");
                Serial.println(valeurfin);*/
                
                
                   
                /* affichage provisoire de la valeur 
                 de la période du signal d'entrée */ 
                 interrupts();
            }//fin du loop 
            
//************************************************
// programme fonctions 
//************************************************

//-----------------------------------------------------------------------------
//Fonctions  d'interruption sur front montant (RISING)du signal d'entree 
//-----------------------------------------------------------------------------
void isr1()
          { // debut programme d'interruption sur front montant 
            noInterrupts();
            if (mempint == false) //condition du debut de mesure sur front montant  
               {valeurdebut = micros();//releve de la valeur de l'horloge interne 
                mempint = true ;// preparation pour relever front montant suivant  
                return valeurdebut;// remontee de valeur de debut de mesure vers le loop 
               }
                 
            else
          
             if (mempint == true) ;//condition de la fin de mesure sur front montant  
               {valeurfin = micros();//releve de la valeur de l'horloge interne 
                mempint = false;memdint = false;/* preparation pour relever front
                                                   montant suivant */
                                                    
                return valeurfin;//remontee de valeur de fin de mesure vers le loop  
               }  
          } // fin de programme d'interruption sur front montant

image de la sortie série sur IDE

https://drive.google.com/file/d/1-dfcjoMlqk_nIxJYTq0zz0WeAXpQm8TN/view?usp=sharing

image de la carte Arduino sur la quelle je travaille .

https://drive.google.com/file/d/1s5zjiCGnJa1R5RwPHIeyzca8Lun2CHBL/view?usp=sharing

en vous remerciant de votre aides

Bonjour,

Je n'ai pas compris ce que tu veux faire avec mempint et memdint
C'est beaucoup plus simple que ça: l'interruption est générée à chaque front montant donc il suffit de mesurer le temps entre deux interruptions pour avoir la période.

void isr1()
{ // debut programme d'interruption sur front montant
  valeurfin=micros();
  Valper=valeurfin-valeurdebut;   // calcul de la période
  valeurdebut=valeurfin;
} // fin de programme d'interruption sur front montant

Bien sur il faut supprimer le calcul de Valper dans la loop.

Remarque: une fonction void ne retourne rien. Le compilateur aurait du te retourner une erreur avec les return valeurdebut et return valeurfin.

merci faraday member

je viens d'essayer et cela fonctionne du tonnerre .

ce je voulais faire avc mempint (mémoire du premier front montant ) et memdint (mémoire du deuxième front montant ) pour pouvoir les différentier.Mas mauvaise analyse de ma part ,désolé

Maintenant il me reste plus qu'a l'afiché sur mon LCD LM16A21 mais là je posséde . Cela à été mon premier exercice sur arduino d'afficher l'heure en H ,m ; S?
J'ai maintenant un autre projet c'est le programme pour faire tourner un moteur triphasé .J'ai déja fait le circuit en composants discrets et cela fonctionne .Donc je vais maintenant essayer de le faire en programmation maintenant .
Encore merci de ton aide et j'aurais encore sûrement besoin d'éclaircissements sans nul doute :slight_smile: :o

bonne soirée

NB : Le "problème" est résolu grâce à faraday member