main.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
// Include files
#include "RC_calib_oscsampleif.h"
#include "ATmega8HVA_16HVA_signature.h"
#include "main.h"

// File global variables
uint16_t temp_sensor_coeff;



void main (void)
{
    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);
}


int8_t ReadButtons(void)
{
    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;
}



int8_t InitBandgap(void)
{
    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;
}



uint16_t MeasureTemperature(void)
{
    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));
}

---