RC_calib_oscsampleif.c File Reference

---

Detailed Description

Functions for calibrating and estimating clock periods of the RC Oscillators.

Functions for: calibrating the Fast RC with Slow RC as reference, predicting Slow RC perod from temperature and measuring ULP RC period with Slow RC as reference. Supporting functions for measuring temperature and reading out signature data are also included.

Application note:

AVR351: Runtime calibration and compensation of RC oscillators using the Oscillator Sampling Interface

Documentation

For comprehensive code documentation, supported compilers, compiler settings and supported devices see readme.html

Author:

Atmel Corporation: http://www.atmel.com
Support email: avr@atmel.com

Revision

4809

Date

2008-11-04 12:17:59 +0100 (ti, 04 nov 2008)

Copyright (c) 2008, Atmel Corporation All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3. The name of ATMEL may not be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition in file RC_calib_oscsampleif.c.

#include "RC_calib_oscsampleif.h"
#include "ATmega8HVA_16HVA_signature.h"
#include <ioavr.h>
#include <inavr.h>

Include dependency graph for RC_calib_oscsampleif.c:

Go to the source code of this file.

Defines
#define	FAILED   -1
#define	SUCCESS   0
Functions
uint16_t	CalculateSlowRCperiod (int16_t temperature)
	Calculate Slow RC period time.
int8_t	CalibrateFastRCruntime (uint16_t cal_RC_period)
	Calibrate the Fast RC against the Slow RC oscillator runtime.
uint16_t	MeasureULPRCperiod (uint16_t cal_RC_period)
	Measure the ULP RC period time against the Slow RC.
uint16_t	OSIsampleClockPeriod (uint8_t clock_source)
	Measure OSI prescaled clock periods.

---

Define Documentation

#define FAILED   -1

Definition at line 63 of file RC_calib_oscsampleif.c.

#define SUCCESS   0

Definition at line 62 of file RC_calib_oscsampleif.c.

---

Function Documentation

uint16_t CalculateSlowRCperiod

(

int16_t

temperature

)

Calculate Slow RC period time.

Calculate Slow RC period time given a temperature. The formula for calculation of Slow RC period is used with the signature data (loaded from the signature row) to calculate the actual period as described in the data sheet and application note. The result is in ms * 1024. It can thus be seen as ms in 16 bit fixed point format, with 10 fractional bits, i.e. 0x XXXX XX.xx xxxx xxxx.

Parameters:

temperature

in Kelvin (uint16_t)

Returns:

calculated Slow RC period in ms*1024 (uint16_t)

Definition at line 81 of file RC_calib_oscsampleif.c.

References READ_SIGNATUREBYTE, SIG_SLOW_RC_H, SIG_SLOW_RC_L, SIG_SLOW_RC_PRED_H, SIG_SLOW_RC_PRED_L, SIG_TEMPERATURE_HOT, and ZERO_C_IN_KELVIN.

Referenced by main().

{
    uint16_t slow_RC_period;
    int16_t  slow_RC_temperature_coeff;
    uint16_t calib_temperature;

    /* Read necessary data from the signature row. The delay cycles are to avoid
     * accessing the SPMCSR register within 6 cycles of previous write, since it 
     * is locked for further writing during these cycles.
     */
    slow_RC_period = READ_SIGNATUREBYTE(SIG_SLOW_RC_L);
    
    // Avoid writing to SPMCSR register within 6 cycles of previous write.
    __delay_cycles(2);
    
    slow_RC_period |= READ_SIGNATUREBYTE(SIG_SLOW_RC_H) << 8;
    
    // Avoid writing to SPMCSR register within 6 cycles of previous write.
    __delay_cycles(2);
    
    slow_RC_temperature_coeff = READ_SIGNATUREBYTE(SIG_SLOW_RC_PRED_L);
    
    // Avoid writing to SPMCSR register within 6 cycles of previous write.
    __delay_cycles(2);
    
    slow_RC_temperature_coeff |= READ_SIGNATUREBYTE(SIG_SLOW_RC_PRED_H) << 8;
    
    // Avoid writing to SPMCSR register within 6 cycles of previous write.
    __delay_cycles(2);
    
    calib_temperature = READ_SIGNATUREBYTE(SIG_TEMPERATURE_HOT) + ZERO_C_IN_KELVIN;
    
    return (uint16_t)(slow_RC_period - ((temperature - calib_temperature)*slow_RC_temperature_coeff)/64);
}

int8_t CalibrateFastRCruntime

(

uint16_t

cal_RC_period

)

Calibrate the Fast RC against the Slow RC oscillator runtime.

Since the value we're searching for is probably close to the current, we do a linear search. It searches the segment where FOSCCAL default is and the one below. When searching downwards we use the FOSC SEGMENT signature byte to avoid a jump in frequency when reaching the lower segment and thus giving a longer continous search range. FOSC segment is the first value in the previous segment that gives a lower frequency than the lowest value in the FOSCCAL default segment. If we reach the bottom of the lower segment or the top of the default segment we select the default FOSCCAL value and return failed as this range should provide a more than sufficient range for adjusting FOSCCAL over all temperatures, so something is wrong.

Note that no other boundary check is done, but even if the FOSCCAL value is outside the search range the frequency should be correctly calibrated, although jumps in frequency results will be encountered. If the FOSCCAL value is between the lowest value in FOSCCAL default segment and the FOSC SEGMENT, a value in that range might be selected.

The Oscillator Sampling interface with timer input capture is used in a polled way to minimize interrupt routines.

Parameters:

cal_RC_period

Slow RC period in ms * 1024

Returns:

Status, SUCCESS or FAILED

Definition at line 143 of file RC_calib_oscsampleif.c.

References FAILED, FAST_RC_TARGET_MHZ, OSIsampleClockPeriod(), READ_SIGNATUREBYTE, SIG_FOSC_SEGMENT, SIG_FOSCCAL_DEFAULT, SLOW_RC, and SUCCESS.

Referenced by main().

{
    uint16_t target_period;
    int16_t  error;
    int16_t  last_error;
    uint8_t  fosccal_saved;
    
    /* Read necessary data from the signature row. The delay cycles are to avoid
     * accessing the SPMCSR register within 6 cycles of previous write, since it 
     * is locked for further writing during these cycles.
     */
    uint8_t fosccal_default = READ_SIGNATUREBYTE(SIG_FOSCCAL_DEFAULT);
    
    // Avoid writing to SPMCSR register within 6 cycles of previous write.
    __delay_cycles(2);
    
    uint8_t fosccal_segment = READ_SIGNATUREBYTE(SIG_FOSC_SEGMENT);

    uint8_t bottom_limit = fosccal_segment & 0xE0;
    uint8_t top_limit =  (fosccal_default & 0xE0) + 0x1F;

    // Only whole MHz accounted for.
    target_period = cal_RC_period * FAST_RC_TARGET_MHZ;
    
    // Initial measurement to determine search direction.
    uint8_t  check_value;
    error = OSIsampleClockPeriod(SLOW_RC) - target_period;
    
    if(error > 0){
        // Search downwards.
        check_value = bottom_limit + 0x1F;
        do {
            last_error = error;
            fosccal_saved = FOSCCAL;
            if ( FOSCCAL-- == check_value ){
                // Use fosccal segment value to avoid a step in frequency when going to lower segment. 
                FOSCCAL = fosccal_segment;
            } else if (FOSCCAL < bottom_limit){ 
                // The range have been searched without success, so we select default fosccal value.
                FOSCCAL = fosccal_default;
                return FAILED;
            }
            error = OSIsampleClockPeriod(SLOW_RC) - target_period;
        } while (error > 0);
    }else{
        // Search upwards.
        check_value = fosccal_segment + 0x01;
        do {
            last_error = error;
            fosccal_saved = FOSCCAL;
            if ( FOSCCAL++ == check_value ){    
                // Use fosccal segment value to avoid a step in frequency when going to upper segment. 
                FOSCCAL = fosccal_default & 0xE0;
            } else if ( FOSCCAL > top_limit ){ 
                // The range have been searched without success, so we select default fosccal value.
                FOSCCAL = fosccal_default;
                return FAILED;
            }
            error = OSIsampleClockPeriod(SLOW_RC) - target_period;
        }while ( error < 0 );
    }

    /* Neighbor check. Since we're just searching until frequency is too low or 
     * too high a neighbor check is needed to get the best value. Not needed if 
     * ~2% accuracy is sufficient. Saves ~60 bytes code in release version if omitted.
     */
    if(error < 0){
        // Oscillator frequency to low? If so check if last error was smaller (in absolute value).
        if (last_error < -error){
            FOSCCAL = fosccal_saved;
        }
    }else{
        // Oscillator frequency is to high, so test next lower FOSCCAL setting.
        if (-last_error < error){
            FOSCCAL = fosccal_saved;
        }
    }

    return SUCCESS;
}

Here is the call graph for this function:

uint16_t MeasureULPRCperiod

(

uint16_t

cal_RC_period

)

Measure the ULP RC period time against the Slow RC.

The period of the ULP RC is measured with the Slow RC as reference using the Oscillator Sampling interface. Result is in ms * 1024. It can thus be seen as 16 bit fixed point format, with 10 fractional bits, i.e. 0x XXXX XX.xx xxxx xxxx

Parameters:

cal_RC_period

(uint16_t)

Returns:

ULP RC period (uint16_t)

Definition at line 236 of file RC_calib_oscsampleif.c.

References OSIsampleClockPeriod(), SLOW_RC, and ULP_RC.

Referenced by main().

{
    uint16_t slow_RC_measurement, ULP_RC_measurement;
    uint32_t result;

    slow_RC_measurement = OSIsampleClockPeriod(SLOW_RC);
    ULP_RC_measurement = OSIsampleClockPeriod(ULP_RC);

    result = (uint32_t)cal_RC_period * ULP_RC_measurement / slow_RC_measurement;
    return (uint16_t)result;
}

Here is the call graph for this function:

uint16_t OSIsampleClockPeriod

(

uint8_t

clock_source

)

Measure OSI prescaled clock periods.

Measure number of Fast RC clock cycles in RC_CALIB_CYCLES number of Oscillator Sampling Interface prescaled Clock periods. The prescaler is 128 for ATmega16HVA. osi_cycles is typically 8, giving a total of 1024 cycles for the selected input clock. Available inputs are Slow RC and ULP RC.

Warning: The routine only takes into account one overflow of OCR0, so make sure the number of Fast RC cycles used for calibration are less than 2^16.

Parameters:

clock_source

(uint8_t)

Returns:

Fast RC cycles in 1024 clock periods from selected clock (uint16_t)

Definition at line 262 of file RC_calib_oscsampleif.c.

References RC_CALIB_CYCLES, and T0_PRESCALER.

Referenced by CalibrateFastRCruntime(), and MeasureULPRCperiod().

{
    uint16_t initial_capture, final_capture, result;
    
    // OSI enable and select
    OSICSR = clock_source | (1 << OSIEN);
    
    // 16-bit mode, falling edge trigger
    TCCR0A = (1 << TCW0) | (1 << ICEN0) | (0 << ICS0);
    
    // Timer0 running with 1x prescaling.
    TCCR0B = T0_PRESCALER;
    
    // Clear interrupt flag.
    TIFR0 |= (1 << ICF0);

    // Wait for negative edge.
    do {} while(!(TIFR0 & (1 << ICF0)));
    initial_capture = OCR0A;
    initial_capture |= OCR0B << 8;
    
    // Clear interrupt flag.
    TIFR0 |= (1 << ICF0);
    
    for(uint8_t i = 0 ; i < RC_CALIB_CYCLES ; i++) {
        // Wait for negative edge.
        do {} while(!(TIFR0 & (1 << ICF0)));
        TIFR0 |= (1 << ICF0);
    }
    final_capture = OCR0A;
    final_capture |= OCR0B << 8;

    // This line doesn't take sign into account, but gives correct results. 
    result = final_capture - initial_capture;
    
    return result;
}