Misurazione periodo o frequenza con Arduino

[Lorenzo Ruscitti]

Ciao a tutti

 

quello che devo fare e andare a generare un onda quadra, ad esempio uscente dal pin 5 con la funzione TONE, poi quest'onda andrà in altri dispositivi e poi rientrerà sempre nella stesso Arduino, ad esempio nel pin 5. Quello che devo fare è CONFRONTARE L'ONDA IN USCITA E QUELLA IN INGRESSO E VERIFICARE CHE "COINCIDANO".

 

Per simulare il tutto per ora invio dal pin 4 e ricevo direttamente sul 5 senza andare negli altri dispositivi, come detto sopra.

 

Il codice è quello che inserisco di seguito. L'ultima funzione abilitata da Check_Wave deve essere completata, ma per la domanda che devo porre non è importante.

 

Ho usato la funzione Tone per generare l'onda quadra e la PulseInLong per rilevare i fronti sia positivo che negativo.

 

Le freq che interessano a me sono F1=115200 Hz e F2 = 1 MHz.

 

Allora fino alla freq di 50 Khz riesco ad ottenere dei valori diciamo accettabili ma oltre i 70 KHz mi escono dei valori assolutamente sballati.

 

Capisco che all'aumentare della freq la PulseIn/PulseInLong sarà sempre più messa sotto stress dato il periodo sempre più piccolo in cui si dovrà abilitare e disabilitare.

 

Ma essendo che io devo fare la misura che vi ho detto sopra come potrei fare ?

 

Questi valori sballati che mi escono da circa quella freq in poi è corretto dire che è un limite dell'arduino ?

 

Grazie 

 

float Periodo = 1;
unsigned long Periodo_Arrotondato;
unsigned long Mezzo_periodo_Pos;
unsigned long Mezzo_periodo_Neg;
unsigned long Periodo_Completo;
unsigned long Freq = 1000000;

bool Stamp           = true;
bool Load_Array      = true;
bool Check_Array_Min = false;
bool Check_Array_Max = false;
bool Check_Wave      = false;

int Array_Dimension = 40;
int Valori[40]; // Parte da zero quindi sono 20 elementi
int i = 1;

int Estremo_Inferiore;
int Estremo_Superiore = NULL;


void setup() {

  pinMode(5, INPUT);

  pinMode(4, OUTPUT);

  Serial.begin(9600);

  Periodo = (Periodo/Freq) * 1000000;
  Serial.println(Periodo,8); 

  /* Se faccio diventare il float 8.68 in int lui me lo approssima per difetto a 8. */
  //Periodo_1 = Periodo;
  //Serial.println(Periodo_1);

  /* Allora uso la funzione ceil che me lo approssima al primo valore mafggiore dispoonibile quindi 9, in questo caso essendo che i valori di pulse che ricevo sono 
   *  8 e 10 verifico che il mio periodo sia all'interno di questo intervallo
   */
   
  Periodo_Arrotondato = ceil(Periodo);
  //Serial.println(Periodo_1);
} 


void loop() {
    
  if(Load_Array) {

    tone(4, Freq);

    delay(100);
    
    Mezzo_periodo_Pos = pulseInLong(5, HIGH); 

    Mezzo_periodo_Neg = pulseInLong(5, LOW);
    
    Periodo_Completo = Mezzo_periodo_Pos + Mezzo_periodo_Neg;

    Serial.print("Periodo Completo = ");
    Serial.println(Periodo_Completo);

//    Serial.print("Mezzo Periodo Positivo = ");
//    Serial.println(Mezzo_periodo_Pos);
//
//    Serial.print("Mezzo Periodo Negativo = ");
//    Serial.println(Mezzo_periodo_Neg);
    
    if(i < (Array_Dimension + 1)) {

      Valori[i] = Periodo_Completo;
      delay(100);
    
      Serial.print("Valare nell'array = ");
      Serial.println(Valori[i]);

      Serial.print("Valare di i = ");
      Serial.println(i);

      if(i == Array_Dimension & Stamp) {

        Serial.println("Caricamento completato");

//        Serial.println(Valori[5]);
//        Serial.println(Valori[6]);
//        Serial.println(Valori[12]);
//        Serial.println(Valori[15]);
//        Serial.println(Valori[19]);
        
        Load_Array      = false;
        Check_Array_Min = true;
        Check_Array_Max = false;
        Check_Wave      = false;

        Stamp = false;
      }

      i ++ ;
     }
    }

  if(Check_Array_Min) {

    //noTone(4);
    int j;
    
    for(j = 1; j < Array_Dimension + 1; j++) {

      if(Estremo_Inferiore > Valori[j]) {

        Estremo_Inferiore = Valori[j];
      }
      else {

        // Solamente per la prima volta
        if(j == 1) {

          Estremo_Inferiore = Valori[j];
        }
      }

      Stamp = true;
    }
    
    if(j == (Array_Dimension + 1) & Stamp) {

      Serial.print("Estremo inferiore = ");
      Serial.println(Estremo_Inferiore);

      Load_Array      = false;
      Check_Array_Min = false;
      Check_Array_Max = true;
      Check_Wave      = false;

      Stamp = false;
    }
  }

  if(Check_Array_Max) {

    int j;
    
    for(j = 1; j < Array_Dimension + 1; j++) {

      if(Estremo_Superiore < Valori[j]) {

        Estremo_Superiore = Valori[j];
      }
      else { }

      Stamp = true;
    }
    
    if(j == (Array_Dimension + 1) & Stamp) {

      Serial.print("Estremo superiore = ");
      Serial.println(Estremo_Superiore);

      Load_Array      = false;
      Check_Array_Min = false;
      Check_Array_Max = false;
      Check_Wave      = true;

      Stamp = false;
    }
  }
  
  if(Check_Wave) {

    if(Estremo_Inferiore != Estremo_Superiore) {
      
      if(Periodo_Arrotondato > Estremo_Inferiore && Periodo_Arrotondato < Estremo_Superiore) {

        Stamp = true;
      
        if(Stamp) {

          Serial.println("ONDA QUADRA CORRETTA");

          Load_Array      = false;
          Check_Array_Min = false;
          Check_Array_Max = false;
          Check_Wave      = false;

          Stamp = false;
        }
       }
       else {

          if(Stamp) {

            //Serial.println("VERIFICARE L'ONDA QUADRA INVIATA");

            Stamp = false;
          }
       }
     }
     else {

        
     }
   }

}