main.c File Reference

---

Detailed Description

main.c, demonstration of using runtime oscillator calibration.

Demonstration of Slow RC period calculation, Fast RC calibration and Ultra Low Power RC period measurement. Slow RC is used for calibrating the Fast RC and measuring ULP RC period.

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 main.c.

#include "RC_calib_oscsampleif.h"
#include "ATmega8HVA_16HVA_signature.h"
#include "main.h"

Include dependency graph for main.c:

Go to the source code of this file.

Functions
int8_t	InitBandgap (void)
	Bandgap initialisation.
void	main (void)
uint16_t	MeasureTemperature (void)
	Temperature measurement.
int8_t	ReadButtons (void)
	Read what/if buttons was pressed.
Variables
uint16_t	temp_sensor_coeff
	< For calculating temperature from VPTAT measurement (internal temperature sensor)

---

Function Documentation

int8_t InitBandgap

(

void

)

Bandgap initialisation.

Initialises the bandgap voltage reference to factory calibration. If second calibration has been done at room temperature those values are loaded. BGCCR need to be changed slowly to avoid BOD. See appnote for details.

Return values:

	FAILED	Loading of signature data failed.
	ROOM_TEMPERATURE	Signature data for second insertion test found.
	HOT_TEMPERATURE	Signature data only for first insertion test found.

< Factory calibration of BGCCR and BGCRR.

Definition at line 185 of file main.c.

References BANDGAP_ADJ_DELAY, FAILED, HOT_TEMPERATURE, READ_SIGNATUREBYTE, ROOM_TEMPERATURE, SIG_BGCCR_CALIB_25C, SIG_BGCCR_CALIB_HOT, and SIG_BGCRR_CALIB_25C.

Referenced by main().

{
    uint8_t bgccr_cal, bgcrr_cal;
    int8_t  mode;

    bgcrr_cal = READ_SIGNATUREBYTE(SIG_BGCRR_CALIB_25C);
    
    /* Uncomment the following line to do second point calibration. Please notice
     * that breaking within 2 cycles of completing a signature byte reading will 
     * corrupt AVR Studio flash readout.
     */
//  bgcrr_cal = 0xFF;
    
    // Check that valid BGCRR data exists in the signature row.
    if ( bgcrr_cal != 0xFF ){
        bgccr_cal = 0x3F & READ_SIGNATUREBYTE(SIG_BGCCR_CALIB_25C); 
        mode = ROOM_TEMPERATURE;
    }else{
        // No valid data was found. Load HOT temperature data and abort if that is not valid.
        bgcrr_cal = 0x0F;
        bgccr_cal = 0x3F & READ_SIGNATUREBYTE(SIG_BGCCR_CALIB_HOT);
        
        if (bgccr_cal == 0x3F) {
            return FAILED;
        }
        
        mode = HOT_TEMPERATURE;
    }       

    BGCRR = bgcrr_cal;

    // If done this way device may enter BOD so use method below.
    // BGCCR = bgccr_cal;               
    
    // Adjust BGCCR up if needed. Slowly to avoid BOD.
    while (BGCCR < bgccr_cal) {
        BGCCR++;
        __delay_cycles(BANDGAP_ADJ_DELAY);
    }
    
    /* Adjust down if necessary. (Safe with regard to BOD, but uses
     * longer time to stabilize and thus give correct ADC measurements)
     */
    BGCCR = bgccr_cal;
                                      
    return mode;
}

void main

(

void

)

< Volatile to avoid compiler warning, since we are only storing it.

Definition at line 63 of file main.c.

References BUTTON_ONE, BUTTON_THREE, BUTTON_TWO, CalculateSlowRCperiod(), CalibrateFastRCruntime(), HOT_TEMPERATURE, InitBandgap(), MeasureTemperature(), MeasureULPRCperiod(), READ_SIGNATUREBYTE, ReadButtons(), ROOM_TEMPERATURE, SIG_VPTAT_H, SIG_VPTAT_L, SUCCESS, TEMP_DIFF_LIMIT, temp_sensor_coeff, and ZERO_C_IN_KELVIN.

{
    uint16_t current_temperature, calibration_temperature;
    int16_t  temp_diff;
    uint16_t slow_RC_period;
    
    volatile uint16_t ULP_RC_period;
    
    int8_t   button_pressed;

    /* Calibrate bandgap reference. This checks if signature row contains
     * data from second insertion. No check for failure is implemented.
     */
    if (InitBandgap() == ROOM_TEMPERATURE){ 
        // Fast RC calibrated at room temperature.
        calibration_temperature = ZERO_C_IN_KELVIN + ROOM_TEMPERATURE;
    }else{
        // Fast RC calibrated at hot temperature.
        calibration_temperature = ZERO_C_IN_KELVIN + HOT_TEMPERATURE;
    }
    
    // Read temperature sensor coefficient from signature row and store in global variable.
    temp_sensor_coeff =  READ_SIGNATUREBYTE(SIG_VPTAT_L);
    
    // Avoid writing to SPMCSR register within 6 cycles of previous write.
    __delay_cycles(2);

    temp_sensor_coeff |= (READ_SIGNATUREBYTE(SIG_VPTAT_H) << 8);

    // Output System clock/2 on PINB0 to enable easy debugging.
    DDRB |= (1 << DDB0);
    MCUCR |= (1 << CKOE);

    // Enter eternal loop.
    do {
        /* In an actual application the temperature measurements would
         * be part of the, possibly interrupt driven, VADC measurement
         * but here we just manually sample them.
         */
        current_temperature = MeasureTemperature();
        temp_diff = current_temperature - calibration_temperature;
        button_pressed = ReadButtons();

        // Start calibration if called for, either by temperature difference or button 3 (PB3).
        if ( (temp_diff > TEMP_DIFF_LIMIT) || (temp_diff < -TEMP_DIFF_LIMIT) || (button_pressed == BUTTON_THREE) ) {

            slow_RC_period = CalculateSlowRCperiod(current_temperature);
            ULP_RC_period = MeasureULPRCperiod(slow_RC_period);

            /* Here we use the The Slow RC result for ULP RC period measurement and Fast RC calibration.
             * In a battery application the Slow RC or ULP RC period would also be used for compensating
             * the Coulomb counter ADC results. Please see application note AVR352 for details.
             */

            if (CalibrateFastRCruntime(slow_RC_period) == SUCCESS){
                // Save the temperature we calibrated at.
                calibration_temperature = current_temperature;
            }else{
                // Should flag error here. No action is taken in this application. 
            }
        }
        
        // Adjust FOSCCAL down if button 1 is pressed (PB1), thus decreasing clock frequency.
        if (button_pressed == BUTTON_ONE){
            FOSCCAL--;      
        }
        
        // Adjust FOSCCAL up if button 2 is pressed (PB2), thus increasing clock frequency.
        if (button_pressed == BUTTON_TWO){
            FOSCCAL++;      
        }
        
    } while(1);
}

Here is the call graph for this function:

uint16_t MeasureTemperature

(

void

)

Temperature measurement.

Returns temperature in Kelvin (uint16_t). Absolute accuracy of the temperature sensor is stated at +/-5 Kelvin in the data sheet.

An alternative could be to use °C with 1 byte signed format, thus giving a range of +127 - -128°C. In an application temperature measurements should be part of the VADC interrupt controlled measurements.

Returns:

temperature [Kelvin] (uint16_t)

Definition at line 247 of file main.c.

References temp_sensor_coeff, and VTEMP.

Referenced by main().

{
    uint32_t temperature;
    
    // VTEMP as input
    VADMUX = VTEMP;
    
    temperature = VADC;

    // Enable VADC and start conversion
    VADCSR = (1 << VADEN) | (1 << VADSC) | (1 << VADCCIF);

    do {} while(!(VADCSR & (1 << VADCCIF)));
    
    temperature = VADC;
    temperature *= temp_sensor_coeff;

    // Disable VADC and reset interrupt flag, interrupting any ongoing conversion
    VADCSR = (1 << VADCCIF);
    return ((uint16_t)(temperature >> 14));
}

int8_t ReadButtons

(

void

)

Read what/if buttons was pressed.

Uses PB1/2/3 as inputs, so they must be configured as inputs (default when device is reset). Waits for button(s) to be released before returning the result.

Returns:

Which button was pressed, or FAILED if none or multiple was pressed.

Definition at line 147 of file main.c.

References BUTTON_MASK, BUTTON_ONE, BUTTON_THREE, BUTTON_TWO, and FAILED.

Referenced by main().

{
    uint8_t buttons_pressed;
    int8_t return_value;
    buttons_pressed = (~PINB & BUTTON_MASK);
    
    do {} while (~PINB & BUTTON_MASK);
    
    switch( buttons_pressed ) {
        case (1 << BUTTON_ONE):
            return_value = BUTTON_ONE;
            break;
        case (1 << BUTTON_TWO):
            return_value = BUTTON_TWO;
            break;
        case (1 << BUTTON_THREE):
            return_value = BUTTON_THREE;
            break;
        default : 
            return_value = FAILED;
            break;
    }
    
    return return_value;
}

---

Variable Documentation

uint16_t temp_sensor_coeff

< For calculating temperature from VPTAT measurement (internal temperature sensor)

Definition at line 59 of file main.c.

Referenced by main(), and MeasureTemperature().