vadc_usage.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/

#define module_vadc_usage   1

// Include files
#include <ioavr.h>
#include <inavr.h>

#include "vadc_usage.h"
#include "calibration.h"
#include "ATmega8HVA_16HVA_signature.h"


//File global variables for storing signature bytes/words.
uint16_t vptat_coeff;              
uint16_t cell_gain[NO_CELLS];      
int8_t   cell_offset[NO_CELLS];    
uint16_t vadc_gain[NO_VADC];       
int8_t   vadc_offset[NO_VADC];     

#ifndef USE_CAL_GAIN
uint16_t raw_cal;                   
#endif

uint16_t vadc_measurement[NO_VADC_CHANNELS]; 
uint16_t cell_v[NO_CELLS];                   
uint16_t vadc_v[NO_VADC];                    
uint16_t bg_temp;                            
uint8_t  vadc_scan_complete;                 



// Functions

void InitCoeff(void)
{
    uint8_t signature_array[SIG_END_ADDRESS+1];

    for(uint8_t i=0 ; i <= SIG_END_ADDRESS ; i++){
        signature_array[i] = READ_SIGNATUREBYTE(i);
    }

    /* Please note that breaking within 2 cycles of completing a signature byte
     * reading will corrupt further AVR Studio flash readout until a reset is issued.
     */

    // Coefficient for temperature calculation from internal sensor.
    vptat_coeff = signature_array[SIG_VPTAT_L];
    vptat_coeff |= signature_array[SIG_VPTAT_H] << 8;

    // Coefficients for cell gain and offset.
    cell_gain[0] = signature_array[SIG_VADC_CELL1_GAIN_L];
    cell_gain[0] |= signature_array[SIG_VADC_CELL1_GAIN_H] << 8;
    cell_offset[0] = signature_array[SIG_VADC_CELL1_OFFSET];

    cell_gain[1] = signature_array[SIG_VADC_CELL2_GAIN_L];
    cell_gain[1] |= signature_array[SIG_VADC_CELL2_GAIN_H] << 8;
    cell_offset[1] = signature_array[SIG_VADC_CELL2_OFFSET];

    // Coefficients for VADC gain and offset.
    vadc_gain[0] = signature_array[SIG_VADC_ADC0_GAIN_L];
    vadc_gain[0] |= signature_array[SIG_VADC_ADC0_GAIN_H] << 8;
    vadc_offset[0] = signature_array[SIG_VADC_ADC0_OFFSET];

    vadc_gain[1] = signature_array[SIG_VADC_ADC1_GAIN_L];
    vadc_gain[1] |= signature_array[SIG_VADC_ADC1_GAIN_H] << 8;
    vadc_offset[1] = signature_array[SIG_VADC_ADC1_OFFSET];

// Only load raw calibration values if needed.
#ifndef USE_CAL_GAIN

// Using Cell1 for calibration.
#ifdef USE_CELL1_CAL
    // RAW Cell1 measurements for 4096mV in.
    raw_cal = signature_array[SIG_VADC_RAW_CELL1_L];
    raw_cal |= signature_array[SIG_VADC_RAW_CELL1_H] << 8;

// Using VADC0 for calibration.
#else
    // RAW VADC0 measurements with (4096/5)mV in.
    raw_cal = signature_array[SIG_VADC_RAW_ADC0_L];
    raw_cal |= signature_array[SIG_VADC_RAW_ADC0_H] << 8;
#endif

#endif

}


int8_t InitBandgap(void)
{
    uint8_t bgccr_cal, bgcrr_cal;
    int8_t  mode;

    bgcrr_cal = READ_SIGNATUREBYTE(SIG_BGCRR_CALIB_25C);

#ifdef IGNORE_2ND_CAL
    // To do second point calibration on parts that already have.
    bgcrr_cal = 0xFF;
#endif

    /* Please note that breaking within 2 cycles of completing a signature byte
     * reading will corrupt further AVR Studio flash readout until a reset is issued.
     */
    if ( bgcrr_cal != 0xFF ){
        // Check to see if part was calibrated at room temperature.
        bgccr_cal = 0x3F & READ_SIGNATUREBYTE(SIG_BGCCR_CALIB_25C);
        mode = CALIB_ROOM;
    } else {
        bgcrr_cal = 0x0F;
        bgccr_cal = 0x3F & READ_SIGNATUREBYTE(SIG_BGCCR_CALIB_HOT);

        if (bgccr_cal == 0x3F) {
            return FAILED;
        }

        mode = CALIB_HOT;
    }

    BGCRR = bgcrr_cal;

    // If done this way device may enter BOD so use method below.
    // BGCCR = bgccr_cal;

    while (BGCCR < bgccr_cal){
        // Adjust BGCCR up if needed. Slowly to avoid BOD.
        BGCCR++;
        __delay_cycles(BANDGAP_ADJ_DELAY);
    }

    // Adjust down if necessary. (Safe - but results in wrong ADC measurements until VREF is stabilized)
    BGCCR = bgccr_cal;

    return mode;
}



void StartVADCScan(void)
{
    //disable ADC0-1 digital input buffer.
    DIDR0 = 0x03;
    vadc_scan_complete = 0;

    // Start set up for first channel.
    VADMUX = FIRST_VADC_MEAS;

    // Clear any pending interrupt
    VADCSR = (1<<VADEN) | (1<<VADCCIF);

    //Start the first conversion & enable interrupts
    VADCSR = (1<<VADEN) | (1<<VADSC) | (1<<VADCCIE);

    // Make sure interrupt are enabled.
    __enable_interrupt();
}



#pragma vector = VADC_vect
__interrupt void VADC_ISR(void)
{
    uint8_t temp;

    // Used for indexing the vadc_measurement variable
    static uint8_t vadc_index = 0;

    temp = VADMUX;

    // Save the result
    vadc_measurement[vadc_index] = VADC;

    /* Code could be added here to store current with the associated cell
     * voltage if doing cell impedance measurements.
     */

    temp++;
    vadc_index++;

    /* Check for disabling of cell balancing could be inserted here or in "if"
     * below. Timing must be adjusted according to discharge time constant.
     */

    if(temp > LAST_VADC_MEAS){
        // Finished with no cell inputs. Do cell measurements.
        temp = BOTTOM_CELL;
    } else {
        // Finished with all cells also?
        if(temp == (TOP_CELL+1)){
            // Flag that we have new samples!
            vadc_scan_complete = 1;

            /*  Possibly re-enable cell balancing here. */

            // Disable this ADC and its Interrupt.
            VADCSR = 0;
            vadc_index = 0;
            return;
        }
    }

    VADMUX = temp;

    //Start next conversion now.
    VADCSR |= (1<<VADSC);
}



void CalculateADCResults(void)
{
    uint32_t calc;
    uint8_t index;

    // Calculate new cell voltages.
    for(index = 0 ; index < NO_CELLS ; index++) {
        calc = vadc_measurement[index + CELL1];
        calc -= cell_offset[index];
        calc *= cell_gain[index];
        cell_v[index] = (uint16_t)(calc >> VADC_SCALE_BITS);
    }

    /* Code checking for under or over-voltage, and/or calculating cell
     * impedances could be inserted here.
     */

    // Calculate new VADC voltages.
    for(index = 0 ; index < NO_VADC ; index++) {
        calc = vadc_measurement[index + VADC0];
        calc -= vadc_offset[index];
        calc *= vadc_gain[index];
        vadc_v[index] = (uint16_t)((calc >> VADC_SCALE_BITS)/10);
    }

    // Calculate temperature from measurement of internal temp sensor (VPTAT).
    calc = vadc_measurement[VPTAT];
    calc *= vptat_coeff;
    calc >>= VADC_SCALE_BITS;
    bg_temp = (uint16_t)(calc);

    /* Code for calculating temperature from external thermistors connected to
     * VADC0 and/or VADC1 could be inserted here. Gain and offset coefficients for
     * vadc inputs are stored in signature row.
     */
}



int8_t CalibrateVREF(void)
{
    volatile uint32_t temp;
    int16_t v_error;        // Variable to keep error after conversion.
    int16_t last_v_error;   // Value used to keep old error value during linear scan.
    int8_t counter;         // Value used to count BGCCR value and index.

    // Select terminal input defined in calibration.h
    VADMUX = CAL_CHANNEL;

    // Enable the VADC.
    VADCSR = (1 << VADEN);

    // Start a VADC conversion and clear any pending interrupts
    VADCSR |= (1 << VADSC) | (1 << VADCCIF);

    // Wait while conversion in progress
    do {} while(!(VADCSR & (1 << VADCCIF)));

    // Dummy read to ensure correct data for next conversion.
    temp = VADC;


    /* If using cell balancing (e.g ATmega406, and not on ATmega8/16HVA),
     * code should be inserted here to wait for error to cancel out.
     */

    // First we do the BGCRR / temperature stability calibration.
    v_error = MeasureVADCerror();
    counter = 8;

    // Check for all different test limits.
    while ( (v_error < vcalibration_level[counter]) && (counter >= 0) ) {
        counter--;
    }

    // Set BGCRR to correct setting.
    BGCRR = temp_cal[counter];

    // Then we do the BGCCR / absolute value calibration.
    v_error = MeasureVADCerror();

    if (v_error < 0){
        do {
            // Ratio_counter bit 6 set means calibration failed.
            if(--BGCCR == 0x40){
                // Return with fail flag.
                return FAILED;
            }
            last_v_error = v_error;
            v_error = MeasureVADCerror();

        } while (v_error < 0);

        // Neighbor check, as previous step can select the next best value.
        if (v_error > -last_v_error){
            BGCCR++;
        }

    }else{
        do{
            // Ratio_counter bit 6 set means calibration failed.
            if(++BGCCR == 0x40){
                // Return with fail flag.
                return FAILED;
            }
            last_v_error = v_error;
            v_error = MeasureVADCerror();

        } while (v_error < 0);

        // Neighbor check, as previous step can select the next best value.
        if(-v_error > last_v_error){
            BGCCR--;
        }
    }

    /* The found values should be stored in eeprom or possibly flash for
     * correct initialisation if device is reset.
     */
    return SUCCESS;
}


int16_t MeasureVADCerror(void)
{
    // Variable to keep error after conversion.
    int32_t vadc_error;

    // Start a VADC conversion and clear any pending interrupts
    VADCSR |= (1 << VADSC) | (1 << VADCCIF);

    // Wait while conversion in progress
    do {} while(!(VADCSR & (1 << VADCCIF)));

    // Calculate error of VADC measurement.
    vadc_error = VADC;

#ifdef USE_CAL_GAIN
    vadc_error -= CAL_OFFSET;
    vadc_error *= CAL_GAIN;

    // Divide by 16384.
    vadc_error >>= VADC_SCALE_BITS;
#endif

    vadc_error -= VCALIB_VALUE;
    return (int16_t) vadc_error;
}

---