Bonjour.
En faisant  des recherches concernant l'analyse de signaux je  ne trouve que  des programmes extrêmement complexe qui  utilise la transformée de fourrier discrète.  

Je  suis donc en train de réaliser  un programme plus compréhensible  à la porté d'un amateur tel que moi.
Je part sur l'idée que j’étudierai principalement des signaux simple "sinusoïdale , carré , continue , triangulaire ". 
Actuellement je travail sur l’étude d'un signal sinusoïdale. 

J'ai a ma disposition un osciloscope , un génerateur de tension  et une carte arduino Mega2560

Voici les caractéristiques de mon signal 
frequence : 400hz
Un tension entre 0-4V

Pour la partie Programmation 
j'ai utilisé les registres TIMER : Dans mon programme ci-dessou j'utilise le TIMER2, afin d'apprendre à utiliser les registres timer. 
j’utiliserai plus tard le TIMER1 beaucoup plus précis. 
Mon  TIMER 2 est programmé  avec un Prescaler=32 ,  et  N=249 . Je voulais une précision pour obtenir un signal le plus précis.  
En visualisant le traceur séries je n'obtiens pas un signal ressemblant a celui émis dans l'arduino 

Mon probrleme  c'est que je n'arrive pas a mesurer  correctement la fréquence de mon signal.

Pourriez vous m'aidez a corriger mon programme. 

/*
 * Programme visant à déterminer la fréquence et l'amplitude d'un signal simple compris entre 0/5V
 * pour une frequence de 400Hz , tension entre 0/4V
 * Soit une periode de 2.5ms , nous prendrons toute les 0.014ms
 * Nous uiliserons le TIMER2 de l'arduino Mega2560;
 * 
 */


#define S_SBT1 A0 
#define L_SBT1 13
int i=5;
int flag=0;
float Tension_SBT1=0;
float Interval_Time_Cpt_SBT1;
float Time_SBT1[5];

float Frequence_SBT1=0;





void setup()
{


  TCCR2A |= 0b00000000;
  TCCR2B |= 0b00000011;
  TIMSK2 |= 0b00000001;
  sei();
  pinMode(S_SBT1,INPUT);
  pinMode(L_SBT1,OUTPUT);
  Serial.begin(500000);
  analogReference(DEFAULT);
}

void loop() 
{
  
  if(flag==1)
   {
    Tension_SBT1= (analogRead(S_SBT1)*5.0)/1023.0;
    Serial.println(Tension_SBT1);
        if(Tension_SBT1==0)
        {
           Time_SBT1[i]=micros();
           Serial.println("*****");
           Serial.println("Le temps mis est :  ");
           Serial.print(Time_SBT1[i]);
           Serial.println("*****");
           i++;
        
        }

       
   }
   if(i==5)
   {
     for(i=0;i<=5;i++)
     {
      Interval_Time_Cpt_SBT1= Time_SBT1[i] +  Interval_Time_Cpt_SBT1 ;
     }
     i=0;
     Interval_Time_Cpt_SBT1=Interval_Time_Cpt_SBT1/(5.0*100000);
    Frequence_SBT1=1/Interval_Time_Cpt_SBT1;
     Serial.println("********************");
     Serial.println("la frequence est ");
     Serial.print(Frequence_SBT1); 
     Serial.println("******");
   }
  

}

  
ISR (TIMER2_OVF_vect)
{
  TCNT2=249;

  if(flag++ == 1)
  {
    flag=0;
  }
}

-
Edité par storyboard 6 juillet 2020 à 13:38:42

/***Definition des ports d'entrée */
#define S_SBT1 A0 
#define L_SBT1 13
 

int i=0;
int flag=0;
boolean var=0;


float Te_SBT1=0.01;
float Tension_SBT1_instant;
float Tension_SBT1_Prec=0; 

float Tension_SBT1_Tab[500];
float Timer_SBT1_Tab[500];

boolean x=1;

 
void setup()
{
  TCCR2A |= 0b00000000;
  TCCR2B |= 0b00000010; //prescaler=8 et TCNT2=236 soit un overflow tout les 0.01ms
  TIMSK2 |= 0b00000001;
  sei();

  
  pinMode(S_SBT1,INPUT);
  pinMode(L_SBT1,OUTPUT);
  Serial.begin(9600);
  analogReference(DEFAULT);
}

void loop() 
{
  if(flag==1)
   {
     Tension_SBT1_instant=analogRead(S_SBT1)*(5.00/1023);
    
        if((Tension_SBT1_instant==0) && (Tension_SBT1_instant != Tension_SBT1_Prec) && x==1)
        {  
           Serial.println("");
           Serial.println("debut de l'acquisitions du signal");
           Serial.println("");
           var=1;
           x=0;
        }
        
        if(var == 1)
        {
         Serial.println("La tension lu est: ");
         Serial.print(Tension_SBT1_instant);
         Serial.println("");
         Tension_SBT1_Tab[i]=Tension_SBT1_instant; 
         Timer_SBT1_Tab[i]= 0.01*i ;
         i++;
         
           if(i==500)
           {
              for(i=0;i<=500;i++)
              {
               Serial.println("la tension mesurée est: "); 
               Serial.print(Tension_SBT1_Tab[i]);
               Serial.print("V ");
               Serial.print("Pour un temps donnée : "); 
               Serial.print(Timer_SBT1_Tab[i]);
               Serial.print("ms");
               Serial.println(""); 
              }
            //compteRendue
            i=0;
            var=0;
            x=1;
           }
       }
   Tension_SBT1_Prec= Tension_SBT1_instant;     
  }
    
}


ISR (TIMER2_OVF_vect)
{
  TCNT2=255;

  if(flag++ >= 1)
  {
    flag=0;
  }
}

-
Edité par storyboard 7 juillet 2020 à 14:46:05

/*
 * Programme viisant a determiner la frequence et l'amplitude d'un signal simple compris entre 0/5V
 * pour un frequence de (50Hz , tension entre 0/5V
 * Soit une periode de 20ms , nous prendrons toute les 0.1 ms
 * 
 * Nous uiliserons le TIMER2 de l'arduino Mega2560;
 * 
*/





/***Signal SBT1 **************************************************************************/
void Signal_SBT1(float Tension_SBT1_instant);

#define S_SBT1 A0
#define Val_SBT1 400

int i=0;

boolean var=0;

 // Le registres initialisé posséde un overflow toute les 0.1ms

float Tension_SBT1_instant;
float Tension_SBT1_Tab[Val_SBT1]; 

int   Nbr_x_0=0;

boolean x=1;
/******************************************************************************************/
/******************************************************************************************/

void setup()
{  
  pinMode(S_SBT1,INPUT);
 
  cli();
  bitClear (TCCR2A, WGM20); // WGM20 = 0
  bitClear (TCCR2A, WGM21); // WGM21 = 0 
  
  TCCR2B = 0b00000010; // Clock /8 soit 
  TIMSK2 = 0b00000001; // Interruption locale autorisée par TOIE2
  sei();
  Serial.begin(9600);

}


/****Fonction d'interrutption du timer*****/
byte flag=0;

ISR (TIMER2_OVF_vect)
{
    TCNT2=56;   // coreespond a 0.1ms 
    
   if(flag++ >= 1)
   {
    flag=0;
    
   }
}


void loop() 
{   

    if(flag==0)
    {
    Tension_SBT1_instant=(analogRead(S_SBT1)*(5.000/1023));
    Signal_SBT1(Tension_SBT1_instant);
  
    }
}


/**FONCTION ANALYSANT LE SIGNAL SBT1**/
void Signal_SBT1(float Tension_SBT1_instant)
{

    if((Tension_SBT1_instant==0) && x==1)    //fonction permettant de debuter l'acquisition a 0, verification du passage a 0; 
        {  
          //Serial.println("debut de l'acquisition");
           var=1;
           x=0;
           i=0;
        }
        
        if(var == 1) // si la passage a 0 a été verifiéé on lance son acquisition 
        { 
           Tension_SBT1_Tab[i]= Tension_SBT1_instant; 
           
           
           if(i==Val_SBT1)  // SI l'ensemble du tableau a été remplie 
           {
            // Serial.println("********NOUS REGARDONS LES  VALEURS********");
             for(i=0;i<=Val_SBT1;i++)           //analyse complet du tabeleau 
             {
               //Serial.println();
               //Serial.print("Pour la valeurs : ");
               //Serial.println(i) ;
              // Serial.print("du tableau, nous observons une tension de: ");
               Serial.println(Tension_SBT1_Tab[i]) ;
               //Serial.print("  Volt");
              // Serial.println();
                    
             } 
            delay(10000);  
            //compteRendue , on remet tout a 0 sauf le x qui sera egale a un pour relancer une bonne acquisition 
             i=0;
             var=0;
             x=1;
           }
          i++;
         }
  
}

-
Edité par storyboard 9 juillet 2020 à 12:07:32