RC_calib_oscsampleif.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 <ioavr.h>
#include <inavr.h>

// Defines
#define SUCCESS                 0
#define FAILED                  -1

// Prototypes
uint16_t OSIsampleClockPeriod(uint8_t clock_source);


uint16_t CalculateSlowRCperiod(int16_t temperature)
{
    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)
{
    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;
}



uint16_t MeasureULPRCperiod(uint16_t cal_RC_period)
{
    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;
}


uint16_t OSIsampleClockPeriod(uint8_t clock_source)
{
    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;
}

---