Misurazione periodo o frequenza con Arduino

[lorenrus]

Ho attivato la funzione Input Capture.

Non mi è chiaro come interpretare i valori che leggo da ICR1.

Grazie

Codice: Seleziona tutto


volatile unsigned char current_edge = 0;
volatile uint16_t starting_cnt;
volatile uint16_t ending_cnt;

uint16_t time_diff;


//ISR(TIMER1_OVF_vect) {
//
//   tick ++;
//   
//   if(tick == 1) {
//
//     Led_On();
//   }
//   else if(tick > 2 & tick <= 20) {
//
//     Led_Off();
//   }
//   else {
//
//     Led_On();
//     delay(100);
//     Led_Off();
//     delay(100);
//   }
//}


ISR(TIMER1_CAPT_vect) {

   if(current_edge == 0) {

     // Save timestamp
     starting_cnt = ICR1;

     //Serial.println("starting_cnt");

     //Serial.println(starting_cnt);
     
     //Switch to rising edge
     TCCR1B |= (1 << ICES1);

     current_edge = 1;
   }
   else if(current_edge == 1) {

     //Save timestamp
     ending_cnt = ICR1;

     //Serial.println("ending_cnt");

     //Serial.println(ending_cnt);

     //Switch to falling edge
     TCCR1B &= ~(1 << ICES1);

     current_edge = 2;
   }

   TIFR1 |= (1 << ICF1);
}


void setup() {

  Serial.begin(9600);

  /*** Timer 1 overflow ***/
 
//  DDRB |= 1 << 5;
//
//  PORTB &= ~ (1 << 5);
//   
//  TCCR1A = 0x0;
//
//  TCCR1B = (1 << CS11) | (1 << CS10); // Prescaler a 64
//
//  TIMSK1 |= 1 << TOIE1; // Abilito l'interrupt Overflow
//
//  sei();


  /*** Timer 1 PWM ***/

//  TCCR1B = (1 << CS11); // Prescaler a 8
//
//  TCCR1A = (1 << WGM10) | (1 << WGM11); // Scelgo il tipo di onda PWM
//
//  TCCR1A |= (1 << COM1A1); // Scelgo il pin di uscita
//
//  OCR1A = 127 ; // Duty cycle al 50 %


  /*** Timer 1 Input Capture ***/
 
  DDRB = B00000000; // Pin 8 come ingresso

  TCCR1A = 0;

  TCCR1B |= (1 << CS10); // Prescaleer a 1

  TIMSK1 |= (1 << ICIE1); // Abilito l'input capture interrupt

  // Non settando il bit ICES1 di TCCR1B esso avrà valore 0 e quindi
  // la lettura dell'impulso avverrà sul FALLING
 
  sei(); // abilito i glob interrupt

}

void loop() {
 
  if(current_edge == 2) {

    if(starting_cnt < ending_cnt) {

      time_diff = ending_cnt - starting_cnt;

      Serial.println("time_diff");

      Serial.println(time_diff);
    }
    else {

      //wrap around
      //(0xffff + A) - B, done without requiring signed
      time_diff = starting_cnt - ending_cnt;
      time_diff = 0xffff - time_diff;

      //Serial.println("PLUTO");
    }

    current_edge = 0;
  }
  }



[EcoTan]

Fornisco un esempio di parte del Main Program e della IntServRoutine:

Codice: Seleziona tutto

volatile unsigned int per;
int main (void) {         //Main Program
PR2 = 65535;          //Timer2 period
T2CONbits.TCKPS = 1;  //Timer2 prescale 8
T2CONbits.TON = 1;    //Timer2 ON
RPINR7bits.IC1R = 6;  //Remap RP6 pin15 tied to InpCapt1
IC1CONbits.ICM = 0;   //Disable Capture module1
IC1CONbits.ICTMR = 1; //Timer2 Capture
IC1CONbits.ICI = 0;   //Interrupt every capt.event
IC1CONbits.ICM = 2;   //Capture on falling edge
IPC0bits.IC1IP = 1;   //InputCapture1 int.priority
IFS0bits.IC1IF = 0;   //Clear int.flag
IC1CONbits.ICBNE = 0; //not empty FIFO clear
IC1CONbits.ICOV = 0;  //overflow FIFO clear
IEC0bits.IC1IE = 1;   //InputCapture1 int.enable

void __attribute__((no_auto_psv)) _ISRFAST _IC1Interrupt(void)
{static unsigned int rif, buf;
buf = IC1BUF; //mette in memoria il valore catturato
IFS0bits.IC1IF = 0;//resetta l'interrupt
if (buf > rif) per = buf - rif;//calcola il periodo
else per = (PR2 - rif) + buf;//anche se il timer è ripartito dal fondo 
rif = buf;  }//salva l'ultimo valore catturato per il prossimo interrupt

[lorenrus]

Ciao buongiorno

io mi riferivo a come leggere il valore di ICR1 nel senso se us o altro.

Grazie

[EcoTan]

Questo dipende da come è clockato il timer

[lorenrus]

Questo dipende da come è clockato il timer

beh questo mi pare ovvio.

Se non erro, se il valore di Fclock = 16 MHz quando imposto il timer devo impostare anche il prescaler quindi devo calcolare ogni quanto il timer 1 che è a 16 bit va in overflow,
Se F timer1 = ( 1/(prescaler * Fclock) ) * 65536

Questo valore che ottengo deve essere minore del periodo dell’onda che invio al pin ICP1.

Ditemi se sbaglio.

Grazie

[Datman]

Devi usare gli interrupt: a ogni fronte di salita in ingresso incrementi il contatore; ogni volta che millis() è aumentato di 1000, leggi il numero di impulsi totalizzato, azzeri e fai un altro conteggio di 1 secondo.