Calibrazione oscillatore - AVR Butterfly

[zio_mangrovia]

Da poco sto studiando i microcontrollori ed in particolare sto utilizzando la board AVR Butterfly (con ATmega169) insieme al book "C programming for microcontrollers" of SmileyMicros.
Mi sono soffermato sulla routine 'OSCCAL_calibration' di calibrazione dell'oscillatore interno (pagina 122-123 del book) e non capisco perché sono prese come soglia superiore e inferiore 6120 e 6250.
Quale dovrebbe essere il valore ottimale (teorico) di impulsi che il timer/counter1 dovrebbe contare affinché la calibrazione sia perfetta? La routine considera accurato la calibrazione se il timer/counter1 conta tra i 6120 e 6250 impulsi.
Considerando che il timer/counter2 è collegato ad un cristallo esterno di quarzo con f=32768 Hz ed ogni ciclo impiega circa 30.5175 microseconds e quando si raggiunge quota 200 (valore assegnato al registro OCR2A) sono passati 6103.5 microseconds.

Il clock di sistema ha f=8 MHz (8192 KHz) e con il prescaler impostato a 8 otteniamo circa 1024 KHz, questo clock alimenta il timer/counter1 e ogni ciclo impiega circa 0.9765625 microseconds.

Quindi facendo 2 conti : 6103.5 / 0.9765625 = 6250

Perché questo valore? Se nel libro c'e' come soglia 6120-6250 mi aspettavo di trovare la media dei due valori (6120+6250)/2 come valore ideale. Sapete fornirmi una spiegazione?

Grazie

[deluca]

salve zio_mangrovia e benvenuto al forum,

c'è qualcosa che non torna.....
dici che 8Mhz equivalgono a 8192Khz... da dove hai presto questa informazione?
non si tratta di una quantità binaria come quando parliamo di 8KB = 8192Byte.
8MHz sono esattamente +/- qualche decimo di Hz(dipende dalla qualità del quarzo, dalla temperatura e da altri fattori)
8.000.000Hz .

Quindi rifai i calcoli e facci sapere

[zio_mangrovia]

Grazie per la risposta, ho ipotizzato tale equivalenza in analogia al quarzo da 32768 e, avendo fatto i calcoli anche con 8.000.000 Hz esatti, il valore ottenuto si distoglieva in modo significativo dai due valori soglia che avevo indicato:
Rifacendo i conti:

timer2: 32768 Hz, 30.517 usec/ciclo, 200 cicli in 6103.4 usec
timer1: 8000000 Hz, con prescaler (/8) 1000000 Hz, 1 usec/ciclo

Quindi dopo 200 colpi del timer2 il timer1 idealmente dovrebbe fare 6103 cicli visto che 6103.4/1=6103)

La routine considera accurata la calibrazione se il timer/counter1 conta tra i 6120 e 6250 impulsi ma perché il valore ideale è 6103?!??! Non sta neppure nel mezzo al range, non capisco....

Grazie

[Leonardo]

Ciao Riccardo,

Sicuro che non hai saltato un ciclo del timer2?

Timer Count = (Required Delay / Clock Time Period) - 1

Quindi

200 = (Required Delay / Clock Time Period) - 1

da cui segue

201 = (Required Delay / 30.517 uS)

e da cui si ricava

Required Delay = 6133.9 uS

Aggiungendo i cicli per l'elaborazione da parte della CPU, la routine considera calibrato il timer correttamente.

[zio_mangrovia]

Grazie per la tua risposta e interesse.
Che significa aver saltato un ciclo, mi sono limitato ad analizzare il codice riportato nel libro che descrivo qua sotto, forse la mia analisi è errata!?


OSCCAL_calibration() function – the code:
/*******************************************************************
*
* Function name : OSCCAL_calibration
*
None
* Returns :
*

*Parameters : None
*Purpose : Calibrate the internal OSCCAL byte, using the external
*
32,768 kHz crystal as reference
*


*******************************************************************/
void OSCCAL_calibration(void)
{
unsigned char calibrate = FALSE;
int temp;
unsigned char tempL;

CLKPR = (1<<CLKPCE);
// set Clock Prescaler Change Enable
// set prescaler = 8, Inter RC 8Mhz / 8 = 1Mhz
CLKPR = (1<<CLKPS1)| (1<<CLKPS0);
TIMSK2 = 0;
//disable OCIE2A and TOIE2
ASSR =(1<<AS2);
//select asynchronous operation of timer2 (32,768kHz)
OCR2A = 200;
// set timer2 compare value
TIMSK0 = 0;
// delete any interrupt sources
TCCR1B = (1<<CS10);
// start timer1 with no prescaling
TCCR2A = (1<<CS20);
// start timer2 with no prescaling
//wait for TCN2UB and TCR2UB to clear
while((ASSR & 0x01) | (ASSR& 0x04));
Delay(1000);
// wait for external crystal to stabilise
while(!calibrate)
{
cli(); // mt __disable_interrupt(); // disable global interrupt
TIFR1=0xFF;
//delete TIFR1 flags
TIFR2=0xFF;
//
delete TIFR2 flags

TCNT1H = 0; // clear timer1 counter
TCNT1L = 0;
TCNT2 = 0; // clear timer2 counter
// wait for timer2 compareflag while ( !(TIFR2 && (1<<OCF2A)) );
TCCR1B = 0; // stop timer1
sei(); // __enable_interrupt(); // enable global interrupt
if ( (TIFR1 && (1<<TOV1)) )
{
temp = 0xFFFF; // if timer1 overflows, set the temp to 0xFFFF
}
else
{
// read out the timer1 counter value tempL = TCNT1L;
temp = TCNT1H; temp = (temp << 8); temp += tempL;
}
if (temp > 6250)
{
OSCCAL--; //RCoscillator runs to fast, decrease OSCCAL
}
else if (temp < 6120)
{
OSCCAL++;//RC oscillator runs to slow, increase OSCCAL
}
else
calibrate = TRUE;
// the interRC is correct
TCCR1B = (1<<CS10); // start timer1
}
}

[Leonardo]

Il tuo calcolo era errato e non considerava il tempo speso dalla CPU

[Leonardo]

Ciao Riccardo,

Ti rispondo sul forum e non per PM così possono leggere anche altri la risposta.

perchè nella formula hai messso -1 ?
Timer Count = (Required Delay / Clock Time Period) - 1
perché c'e' il -1 ?

La formula del tempo trascorso dal timer è:

(Required Delay) = (Clock Time Period) * (Timer Count + 1)

Poiché viene contato anche lo zero, permettendo al timer così di contare per un periodo di clock in più che altrimenti sarebbe sprecato.

Con un semplice calcolo puoi trovare la formula precedente

[js-bascom]

Ciao Riccardo

Vedo che hai preso il mio consiglio di usare questo forum.