ElectroYou

Buonasera...

premesso che probabilmente lo sfasato sono io ;) : devo realizzare due conteggi di tempo con un PIC 18F4620:

per fare ciò sto utilizzando con profitto il TIMER0 e il TIMER2: riesco ad effettuare il conteggio con buona precisione e ripetibilità; l'anomalia sta nella differenza del calcolo teorico rispetto al riscontro pratico

TIMER 0 Obiettivo:un conteggio ogni secondo

- f osc=20MHz -> 5 MIPS -> 1 conteggio ogni 0,2 us
- prescaler 1:16 -> conteggio ogni 3,2 us
- conteggio 8 bit (255) -> interrupt di fondo scala ogni 816 us
- ogni 1225,5 interrupt dovrei contare 1 secondo (tralasciamo lo 0,5 e lo accettiamo come errore: 1225)

Invece per ottenere il valore più viciono a 1 secondo (1,006 s) devo contare 1208 interrupt.. ?_?

TIMER 2 Obiettivo:un conteggio ogni 18 ms

- f osc=20MHz -> 5 MIPS -> 1 conteggio ogni 0,2 us
- prescaler=1
- postscale=1

per ottenere un conteggio ogni 18 ms devo ottenere un fattore 90000 che ottengo imponendo il valore di compare PR2 del timer a 200 e contando 450 interrupt di fondo scala.

Anche in questo caso per ottenere circa 18 ms devo mettere PR2=140, valore che differisce di molto dal valore calcolato.

Dove sbaglio? Ecco il code..

Codice: Seleziona tutto

sub procedure interrupt
if(INTCON.TMR0IF)then       'è un INTERRUPT di TIMER 0
  TMR0L=0
  INTCON.TMR0IF=0             'set T0IE, clear T0IF
  Inc(cnt)                    'increment value of cnt on every interrupt
  if(cnt>=1208)then           '1,006 sec
  cnt=0
  inc(sec)
  end if
  TMR0L=0
  INTCON.TMR0IF=0             'set T0IE, clear T0IF
end if

if(PIR1.TMR2IF)then
  TMR2=0
  PIR1.TMR2IF=0
  Inc(cnt2)
  if(cnt2>=450)then                 'è un INTERRUPT di TIMER 2
  cnt2=0                            '450+140PR2=28 Hz
  end if                            'circa 1 km/h (27 Hz)
  TMR2 =0
  PIR1.TMR2IF=0
end if

end sub

main:
'TIMER 2 -----------------------------------------------------------------------
T2CON=%00000100   'postscale=1 , acceso, prescaler 1
TMR2=0
PIE1.TMR2IE=1
PIR1.TMR2IF=0
PR2=140
'TIMER 0------------------------------------------------------------------------
T0CON=%11000011          'TIMER 0, 8 bit, gli assegno il PRESCALER, prescaler 16
TMR0L=0                  'Valore iniziale
TMR0H=0
'-------------------------------------------------------------------------------
INTCON=%11100000         'Abilito interrupt timer0 e timer2

while(1)
wend

end.

Ciao, secondo me il tuo non è un errore di codice. Credo che il problema derivi dal fatto che stai trascurando il tempo impiegato dalle routine di interrupt per essere eseguite.
Devi tener conto che la maggior parte delle istruzioni (in assembler) impiegano quattro cicli di clock per essere eseguite, altre (come i salti) ne impiegano otto e in più hai anche qualche ciclo di ritardo tra il momento in cui si scatena l' interrupt e il momento in cui il microcontrollore esegue le relative istruzioni.

Per quel che ne so quando sono richieste tempistiche precise sarebbe meglio passare all' assembler perché ti permette maggior controllo sulle istruzioni e di conseguenza sui tempi desiderati. Credo comunque che il tuo codice possa essere usato come lo hai scritto, devi soltanto considerare che la differenza tra i conti teorici e quelli pratici è legata a quanto scritto sopra.

Se vuoi fare un controllo dovresti ricavare dal codice che hai riportato la versione in assembler (MPLAB dovrebbe fartela vedere) vedrai che le istruzioni necessarie a fare quello che fai con poche righe in C in assembler sono molte di più e perciò i conti non ti tornano.

Condivido con davidde

Credo proprio che davidde abbia colto nel segno. Procederò quindi calcolando teoricamente i valori approssimativi e poi modificandoli empiricamente.

Grazie mille! Grazie anche a Taboga per la conferma..

Il Timer2 lo stai usando nel modo sbagliato.
Il Timer2 e' un timer con comparatore. Quando il conteggio e' uguale al contenuto del comparatore, viene generata l' interrupt ed il conteggio riparte da solo da 0.
E' quanto di piu' preciso puoi trovare in un PIC.
Perche' non lo usi con il comparatore in modo da ottenere una cadenza piu' che perfetta?

ciao, è quello che ho provato a fare..

"..imponendo il valore di compare PR2 del timer a 200..

Il fatto e' che azzeri Timer2 quando non e' necessario (e antiproducente) perche' si azzera da solo.
Usare Timer2 come timer di precisione e' la cosa piu' semplice. In questo programma e' usato per generare con precisione un' interrupt ciclica a 1ms. spaccato. Usa una variabile chiamata timer_delay che viene decrementata ogni millisecondo fino ad arrivare a zero, che funge da timer software.
Come puoi notare l' interrupt NON TOCCA NIENTE del timer, si limita resettare il flag di interrupt ed a decrementare la variabile (in questo caso ce n'e' una ma ne puoi mettere quante ne vuoi).

Codice: Seleziona tutto

// Variabile di conteggio millisecondi
unsigned int timer_delay;

/--------------------------------------------------------
void init_timer(void)
{
  // Inizializza il timer 2 per interrupt ogni millisecondo.
 
  // Postscaler a 5
  T2CONbits.T2OUTPS3 = 0;
  T2CONbits.T2OUTPS2 = 1;
  T2CONbits.T2OUTPS1 = 0;
  T2CONbits.T2OUTPS0 = 1;
 
  // prescaler 16
  T2CONbits.T2CKPS1 = 1;
  T2CONbits.T2CKPS0 = 1;
 
  // valore comparatore a 150
  PR2 = 150;
 
  // set interrupt a priorita' bassa
  IPR1bits.TMR2IP = 0;
 
  // abilita interrupt del timer
  PIE1bits.TMR2IE = 1;
 
  // abilita le interrupt a bassa priorita'
  INTCONbits.GIEL = 1;
 
  // start timer
  T2CONbits.TMR2ON = 1;
}

/--------------------------------------------------------
#pragma interruptlow YourLowPriorityISRCode
void YourLowPriorityISRCode()
{
  // Interrupt timer 2
  if(PIR1bits.TMR2IF)
  {
    PIR1bits.TMR2IF = 0;
    if (timer_delay) timer_delay--;
  } 
}

Il clock e' a 48 MHz. Una chiamata ogni millisencondo preciso e perfetto.

Ottimo! Grazie alle vostre dritte ho migliorato di molto la prestazione dei miei conteggi, grazie mille!

Se hai utilizzato il mio sistema la precisione non l' hai migliorata, l' hai resa perfetta.