vadc_usage.c File Reference

---

Detailed Description

Routines for voltage reference calibration and VADC measurements.

This contain functions for reading out signature row data, bandgap initialisation and bandgap calibration. Functions for start of VADC measurements, interrupt routine for measurements and calculation of cell voltages, vadc inputs and bandgap temperature are also included.

Application note:

AVR353: Voltage Reference Calibration and Voltage ADC Usage.

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

4814

Date

2008-11-04 12:29:56 +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 vadc_usage.c.

#include <ioavr.h>
#include <inavr.h>
#include "vadc_usage.h"
#include "calibration.h"
#include "ATmega8HVA_16HVA_signature.h"

Include dependency graph for vadc_usage.c:

Go to the source code of this file.

Defines
#define	module_vadc_usage   1
	< Define for vadc_usage.h to avoid including the external variables.
Functions
void	CalculateADCResults (void)
	Calculate results from the VADC raw values.
int8_t	CalibrateVREF (void)
	Voltage reference calibration.
int8_t	InitBandgap (void)
	Bandgap initialisation.
void	InitCoeff (void)
	Function to load coefficients needed from the signature row.
int16_t	MeasureVADCerror (void)
	Measure VADC error.
void	StartVADCScan (void)
	Start a scan of all VADC channels.
__interrupt void	VADC_ISR (void)
	Interrupt Service Function to measure VADC values.
Variables
uint16_t	bg_temp
	Global variable for the result of band-gap temperature measurement/calculation.
uint16_t	cell_gain [NO_CELLS]
	Gain coefficients for Cells.
int8_t	cell_offset [NO_CELLS]
	Offset for cells.
uint16_t	cell_v [NO_CELLS]
	Global variable for results of Cell Voltage measurements/calculations.
uint16_t	vadc_gain [NO_VADC]
	VADC channel gain.
uint16_t	vadc_measurement [NO_VADC_CHANNELS]
	Global variable for VADC samples. Sized to number of VADC channels.
int8_t	vadc_offset [NO_VADC]
	VADC channel offset.
uint8_t	vadc_scan_complete
	Flag for signalling VADC sampling complete.
uint16_t	vadc_v [NO_VADC]
	Global variable for results of Voltage ADC measurements/calculations.
uint16_t	vptat_coeff
	Internal temperature sensor coefficient.

---

Define Documentation

#define module_vadc_usage   1

< Define for vadc_usage.h to avoid including the external variables.

Definition at line 54 of file vadc_usage.c.

---

Function Documentation

void CalculateADCResults

(

void

)

Calculate results from the VADC raw values.

Function uses values from vadc_measurement variable and stores results in global variables cell_v and bg_temp. The formulas are found in the data sheet and details in the application note.

Definition at line 300 of file vadc_usage.c.

References bg_temp, CELL1, cell_gain, cell_offset, cell_v, NO_CELLS, NO_VADC, VADC0, vadc_gain, vadc_measurement, vadc_offset, VADC_SCALE_BITS, vadc_v, VPTAT, and vptat_coeff.

Referenced by main().

{
    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

)

Voltage reference calibration.

Calibrates the bandgap reference. Assumes 4096mV in on PV1 (Cell1). Values in calibration.h have to be adjusted if any other value is used. The reference needs to be calibrated to factory default before performing this calibration, and if it fails the reference is not correct and factory defaults should be used.

Calibration of bandgap at room temperature only needs to be done if device isn't calibrated so in Atmel factory. Otherwise calibration can be done by reading out signature data.

Returns:

Status, SUCCESS or FAILED as defined in vadc_usage.h

Definition at line 353 of file vadc_usage.c.

References CAL_CHANNEL, FAILED, MeasureVADCerror(), SUCCESS, temp_cal, and vcalibration_level.

Referenced by main().

{
    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;
}

Here is the call graph for this function:

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.
	CALIB_ROOM	Signature data for second insertion test found.
	CALIB_HOT	Signature data only for fist insertion test found.

< Factory calibration of BGCCR and BGCRR.

Definition at line 156 of file vadc_usage.c.

References BANDGAP_ADJ_DELAY, CALIB_HOT, CALIB_ROOM, FAILED, READ_SIGNATUREBYTE, 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);

#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 InitCoeff

(

void

)

Function to load coefficients needed from the signature row.

Loads all signature data into an array and then stores the relevant ones in (file) global variables.

Definition at line 91 of file vadc_usage.c.

References cell_gain, cell_offset, READ_SIGNATUREBYTE, SIG_END_ADDRESS, SIG_VADC_ADC0_GAIN_H, SIG_VADC_ADC0_GAIN_L, SIG_VADC_ADC0_OFFSET, SIG_VADC_ADC1_GAIN_H, SIG_VADC_ADC1_GAIN_L, SIG_VADC_ADC1_OFFSET, SIG_VADC_CELL1_GAIN_H, SIG_VADC_CELL1_GAIN_L, SIG_VADC_CELL1_OFFSET, SIG_VADC_CELL2_GAIN_H, SIG_VADC_CELL2_GAIN_L, SIG_VADC_CELL2_OFFSET, SIG_VADC_RAW_ADC0_H, SIG_VADC_RAW_ADC0_L, SIG_VADC_RAW_CELL1_H, SIG_VADC_RAW_CELL1_L, SIG_VPTAT_H, SIG_VPTAT_L, vadc_gain, vadc_offset, and vptat_coeff.

Referenced by main().

{
    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

}

int16_t MeasureVADCerror

(

void

)

Measure VADC error.

Subroutine for measurement of VADC input and calculation of error. Uses defines from calibration.h.

Returns:

VADC_error

Definition at line 444 of file vadc_usage.c.

References CAL_GAIN, CAL_OFFSET, VADC_SCALE_BITS, and VCALIB_VALUE.

Referenced by CalibrateVREF().

{
    // 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;
}

void StartVADCScan

(

void

)

Start a scan of all VADC channels.

VADC is set up and interrupts enabled. Global interrupts are also enabled, so make sure all other interrupts are correctly configured before running this. The interrupt routine VADC_ISR does the actual vadc measurements.

Note:

If not using ADC0-1 exclusively as analog inputs, you must modify the disabling of the ADC0-1 digital input buffer.

Definition at line 215 of file vadc_usage.c.

References FIRST_VADC_MEAS, and vadc_scan_complete.

Referenced by main().

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

__interrupt void VADC_ISR

(

void

)

Interrupt Service Function to measure VADC values.

Measurements are stored in global array vadc_measurement[]. The ISR scans all inputs and then disables itself. It starts with temperature sensor and normal VADc channels. Cells are measured last to give possiblity to disable cell balancing in relevant devices (HVB/m406). This routine can be simplified for HVA.

Definition at line 245 of file vadc_usage.c.

References BOTTOM_CELL, LAST_VADC_MEAS, TOP_CELL, vadc_measurement, and vadc_scan_complete.

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

---

Variable Documentation

uint16_t bg_temp

Global variable for the result of band-gap temperature measurement/calculation.

Definition at line 79 of file vadc_usage.c.

Referenced by CalculateADCResults().

uint16_t cell_gain[NO_CELLS]

Gain coefficients for Cells.

Definition at line 67 of file vadc_usage.c.

Referenced by CalculateADCResults(), and InitCoeff().

int8_t cell_offset[NO_CELLS]

Offset for cells.

Definition at line 68 of file vadc_usage.c.

Referenced by CalculateADCResults(), and InitCoeff().

uint16_t cell_v[NO_CELLS]

Global variable for results of Cell Voltage measurements/calculations.

Definition at line 77 of file vadc_usage.c.

Referenced by CalculateADCResults().

uint16_t vadc_gain[NO_VADC]

VADC channel gain.

Definition at line 69 of file vadc_usage.c.

Referenced by CalculateADCResults(), and InitCoeff().

uint16_t vadc_measurement[NO_VADC_CHANNELS]

Global variable for VADC samples. Sized to number of VADC channels.

Definition at line 76 of file vadc_usage.c.

Referenced by CalculateADCResults(), and VADC_ISR().

int8_t vadc_offset[NO_VADC]

VADC channel offset.

Definition at line 70 of file vadc_usage.c.

Referenced by CalculateADCResults(), and InitCoeff().

uint8_t vadc_scan_complete

Flag for signalling VADC sampling complete.

Definition at line 80 of file vadc_usage.c.

Referenced by main(), StartVADCScan(), and VADC_ISR().

uint16_t vadc_v[NO_VADC]

Global variable for results of Voltage ADC measurements/calculations.

Definition at line 78 of file vadc_usage.c.

Referenced by CalculateADCResults().

uint16_t vptat_coeff

Internal temperature sensor coefficient.

Definition at line 66 of file vadc_usage.c.

Referenced by CalculateADCResults(), and InitCoeff().