AVRFreaks.net

#include "OSCCal.h"

/* Code taken from Colin Oflynn from AVRFreaks and modified. His code originally used an externally
   divided 32768Hz clock on an external interrupt pin, but I changed that to use the timer 2 async
   mode with an overflow interrupt (clock source is the external 32768Hz crystal on the Butterfly.
   Code will calibrate to 7372800Hz for correct serial transmission at 115200 baud.                 */

volatile static uint16_t ActualCount;

void OSCCAL_Calibrate(void)
{
   uint8_t SREG_Backup;
   uint8_t LoopCount = (0x7F / 2); // Maximum range is 128, and starts from the middle, so 64 is the max number of iterations required
   
   // Make sure all clock division is turned off (8Mhz RC clock)
   CLKPR = (1 << CLKPCE);
   CLKPR = 0;

   // Inital OSCCAL of half its maximum for speed
   OSCCAL = (0x7F / 2);

   // Save the SREG
   SREG_Backup = SREG;
   
   // Disable all timer 1 interrupts
   TIMSK1 = 0;
       
   // Set timer 2 to asyncronous mode (32.768KHz crystal)
   ASSR   = (1 << AS2);
       
   // Timer 2 overflow interrupt enable
   TIMSK2 = (1 << TOIE2);

   // Enable interrupts
   sei();

   // Start both counters with no prescaling
   TCCR1B = (1 << CS10);
   TCCR2A = (1 << CS20);
       
   // Wait until timer 2's external 32.768KHz crystal is stable
   while (ASSR & ((1 << TCN2UB) | (1 << TCR2UB) | (1 << OCR2UB)));
   
   // Clear the timer values
   TCNT1  = 0;
   TCNT2  = 0;
   
   while (LoopCount--)
   {
      // Let it take a few readings (60ms, approx 7 readings)
      _delay_ms(60);
       
      if (ActualCount > (TARGETCOUNT + 5))          // Clock is running too fast
         OSCCAL--;
      else if (ActualCount < (TARGETCOUNT - 5))      // Clock is running too slow
         OSCCAL++;
      else                                          // Clock is just right
         break;
   }
           
   // Disable all timer interrupts
   TIMSK1 = 0;
   TIMSK2 = 0;
   
   // Stop the timers
   TCCR1B = 0x00;
   TCCR2A = 0x00;

   // Turn off timer 2 asynchronous mode
   ASSR  &= ~(1 << AS2);

   // Restore SREG
   SREG = SREG_Backup;
       
   return;
}

ISR(TIMER2_OVF_vect) // Occurs 32768/256 timers per second, or 128Hz
{
   // Stop timer 1 so it can be read
   TCCR1B = 0x00;
   
   // Record timer 1's value
   ActualCount = TCNT1;
        
   // Reset counters and restart timer 1
   TCNT1  = 0;
   TCNT2  = 0;
   TCCR1B = (1 << CS10);
}

#ifndef OSCCAL_H
#define OSCCAL_H

// DEFINES:
#define TARGETCOUNT (uint16_t)((7372800 / 128) - 5) // Compile time constant, ((Target Freq / Reference Freq) - 5)

// INCLUDES:
#include <avr/io.h>
#include <avr/interrupt.h>

// PROTOTYPES:
void OSCCAL_Calibrate(void);

#endif

#include "OSCCal.h"

/* Code taken from Colin Oflynn from AVRFreaks and modified. His code originally used an externally
   divided 32768Hz clock on an external interrupt pin, but I changed that to use the timer 2 async
   mode with an overflow interrupt (clock source is the external 32768Hz crystal on the Butterfly.
   Code will calibrate to 7372800Hz for correct serial transmission at 115200 baud.                 */

volatile uint16_t ActualCount;

void OSCCAL_Calibrate(void)
{
   uint8_t SREG_Backup;
   uint8_t LoopCount           = (0x7F / 2); // Maximum is 128 and starts from the middle so 64 is the max number of iterations required
   uint8_t PrevOSCCALValues[2] = {};
   
   // Make sure all clock division is turned off (8Mhz RC clock)
   CLKPR = (1 << CLKPCE);
   CLKPR = 0;

   // Inital OSCCAL of half its maximum for speed
   OSCCAL = (0x7F / 2);

   // Save the SREG
   SREG_Backup = SREG;
   
   // Disable all timer 1 interrupts
   TIMSK1 = 0;
       
   // Set timer 2 to asyncronous mode (32.768KHz crystal)
   ASSR   = (1 << AS2);
       
   // Timer 2 overflow interrupt enable
   TIMSK2 = (1 << TOIE2);

   // Enable interrupts
   sei();

   // Start both counters with no prescaling
   TCCR1B = (1 << CS10);
   TCCR2A = (1 << CS20);
       
   // Wait until timer 2's external 32.768KHz crystal is stable
   while (ASSR & ((1 << TCN2UB) | (1 << TCR2UB) | (1 << OCR2UB)));
   
   // Clear the timer values
   TCNT1  = 0;
   TCNT2  = 0;
   
   while (LoopCount--)
   {
      // Let it take a few readings (60ms, approx 2 readings)
      _delay_ms(60);
      
      PrevOSCCALValues[1] = PrevOSCCALValues[0];
      PrevOSCCALValues[0] = OSCCAL;

      if (ActualCount > (TARGETCOUNT + 5))          // Clock is running too fast
         OSCCAL--;
      else if (ActualCount < (TARGETCOUNT - 5))      // Clock is running too slow
         OSCCAL++;
      else                                          // Clock is just right
         break;
         
      // If the OSCCAL cannot calibrate to within the tollerace, the routine will hover around the closest
      // two values for the full 64 iterations. To speed the routine up, the previous two OSCCAL values are
      // saved into an array. If the current value is the same as two iterations ago, the routine is hovering
      // and the loop exits as the OSCCAL is now as close to the target as possible.
      if (OSCCAL == PrevOSCCALValues[1])
         break;
   }
           
   // Disable all timer interrupts
   TIMSK1 = 0;
   TIMSK2 = 0;
   
   // Stop the timers
   TCCR1B = 0x00;
   TCCR2A = 0x00;

   // Turn off timer 2 asynchronous mode
   ASSR  &= ~(1 << AS2);

   // Restore SREG
   SREG = SREG_Backup;
       
   return;
}

ISR(TIMER2_OVF_vect) // Occurs 32768/256 timers per second, or 128Hz
{
   // Stop timer 1 so it can be read
   TCCR1B = 0x00;
   
   // Record timer 1's value
   ActualCount = TCNT1;
        
   // Reset counters and restart timer 1
   TCNT1  = 0;
   TCNT2  = 0;
   TCCR1B = (1 << CS10);
}

/*****************************************************************************
*
*   Function name : OSCCAL_sa
*
*   Returns :       None
*
*   Parameters :    None
*
*   Purpose :       Calibrate the internal OSCCAL byte, using successive
*               approximation and the external 32,768 kHz crystal as reference
*
*****************************************************************************/
void OSCCAL_sa()
{
   unsigned char mask = 0x40;
   unsigned char tempH;
    unsigned char tempL;
   unsigned char tempC;
   
   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 = 218;            // set timer2 compare value. This creates a target count of 0x1A00
   
   TIMSK0 = 0;             // delete any interrupt sources
   
   TCCR1B = (1<<CS10);     // start timer1 with no prescaling
    TCCR2A = (1<<CS20);     // start timer2 with no prescaling
   TIFR2 = 0xFF;   // delete TIFR2 flags
   
    Delay(1000);    // wait for external crystal to stabilise
   
   cli(); // disable global interrupt
   
   tempC = 0;
   
   while(mask)   //As long as we have a bit to mask in...
   {
      tempC |= mask;   // OR the mask in
      OSCCAL = tempC;
      TIFR2 = 0xFF;   // delete TIFR1 flags       
      TCNT2 = 0;      // clear timer2 counter
      
      while (ASSR & (1<<TCN2UB));   //Wait for timer 2 to update
      
      TCNT1H = 0;     // clear timer1 counter
      TCNT1L = 0;
   
       while ( !(TIFR2 & (1<<OCF2A)) );   // wait for timer2 compareflag
   
      // read out the timer1 counter value
      tempL = TCNT1L;
      tempH = TCNT1H;

      if (tempH >= 0x1A)
      {
         tempC -= mask;   // too high, so remove the mask bit
       }
      mask >>= 1;      // Shift the mask
   }

   //The second to last reading may have actually been closer
   if (tempH < 0x1A)
   {   
      if (tempL < 0xD8)
      {
         tempC++;   //The last reading was below 0x1AD8, so one step up is closer
      }
   }
   else
   {
      if (tempL < 0x28)
      {
         // The last reading was over 0x1A00, so the last bit was removed,
         // but since the count was below 0x1A28, the previous reading was closer,
         // so put the bit back
         tempC++;
      }
   }
   OSCCAL = tempC;

   sei(); // __enable_interrupt();  // enable global interrupt
}

while (ASSR & (1<<TCN2UB));   //Wait for timer 2 to update

#include "OSCCal.h"

void OSCCAL_Calibrate(void)
{
   uint8_t LoopCount = (0x7F / 2); // Maximum range is 128, and starts from the middle, so 64 is the max number of iterations required

   ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
   {
      // Make sure all clock division is turned off (8MHz RC clock)
      CLKPR  = (1 << CLKPCE);
      CLKPR  = 0x00;
   
      // Inital OSCCAL of half its maximum
      OSCCAL = (0x7F / 2);
      
      // Disable timer interrupts
      TIMSK1 = 0;
      TIMSK2 = 0;
         
      // Set timer 2 to asyncronous mode (32.768KHz crystal)
      ASSR   = (1 << AS2);
   
      // Ensure timer 1 control register A is cleared
      TCCR1A = 0;
   
      // Start both counters with no prescaling
      TCCR1B = (1 << CS10);
      TCCR2A = (1 << CS20);
         
      // Wait until timer 2's external 32.768KHz crystal is stable
      while (ASSR & ((1 << TCN2UB) | (1 << TCR2UB) | (1 << OCR2UB)));
      
      // Clear the timer values
      TCNT1  = 0;
      TCNT2  = 0;
   
      while (LoopCount--)
      {
         // Wait until timer 2 overflows
         while (!(TIFR2 & (1 << TOV2)));
      
         // Stop timer 1 so it can be read
         TCCR1B = 0x00;
         
         // Check timer value against ideal constant
         if (TCNT1 > OSCCAL_TARGETCOUNT)      // Clock is running too fast
           OSCCAL--;
         else if (TCNT1 < OSCCAL_TARGETCOUNT) // Clock is running too slow
           OSCCAL++;
         
         // Clear timer 2 overflow flag
         TIFR2 |= (1 << TOV2);
   
         // Restart timer 1
         TCCR1B = (1 << CS10);
   
         // Reset counters
         TCNT1  = 0;
         TCNT2  = 0;
      }
   
      // Stop the timers
      TCCR1B = 0x00;
      TCCR2A = 0x00;
   
      // Turn off timer 2 asynchronous mode
      ASSR  &= ~(1 << AS2);
   }   
   END_ATOMIC_BLOCK
   
   return;
}

#ifndef OSCCAL_H
#define OSCCAL_H

   // INCLUDES:
   #include <avr/io.h>
   #include <avr/interrupt.h>

   // CODE DEFINES:
   #define ATOMIC_BLOCK(exitmode)   { exitmode cli();
   #define END_ATOMIC_BLOCK         }
   
   #define ATOMIC_RESTORESTATE      inline void __irestore(uint8_t *s) { SREG = *s; }         \
                                    uint8_t __isave __attribute__((__cleanup__(__irestore))) = SREG;
   #define ATOMIC_ASSUMEON          inline void __irestore(uint8_t *s) { sei(); *s = 0; }     \
                                    uint8_t __isave __attribute__((__cleanup__(__irestore))) = 0;

   // CONFIG DEFINES:
   #define OSCCAL_TARGETCOUNT         (uint16_t)(F_CPU / (32768 / 256)) // (Target Freq / Reference Freq)   
   
   // PROTOTYPES:
   void OSCCAL_Calibrate(void);
   
#endif

// Clear the timer values
      TCNT1  = 0;
      TCNT2  = 0;
      while (LoopCount--)
      {  // Wait until timer 2 overflows
         while (!(TIFR2 & (1 << TOV2)));

// Clear the timer values
      while (LoopCount--)
      {  // Wait until timer 2 overflows
[b]      TCNT1  = 0;
      TCNT2  = 0;
[/b]         while (!(TIFR2 & (1 << TOV2)));

         if (TCNT1 > (OSCCAL_TARGETCOUNT + OSCCAL_TOLLERANCE))      // Clock is running too fast
           OSCCAL--;
         else if (TCNT1 < (OSCCAL_TARGETCOUNT - OSCCAL_TOLLERANCE)) // Clock is running too slow
           OSCCAL++;
         else                                                       // Clock within tollerance
           LoopCount = 0;