ADC.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include <ioavr.h>
#include <inavr.h>

#include "structs.h"

#include "main.h"
#include "ADC.h"


//******************************************************************************
// Variables
//******************************************************************************
// ADC status struct.
ADC_Status_t ADCS;


// Maximum battery voltage (affects scaling of samples).
__eeprom unsigned char VBAT_RANGE = 1;


//******************************************************************************
// Functions
//******************************************************************************
#pragma vector=ADC_vect
__interrupt void ADC_ISR(void)
{
        static unsigned char avgIndex = 0;
        unsigned char i, Next, Signed;
        signed int  temp = 0;
        
        Signed = FALSE;  // Presume next conversion is unipolar.
        ADCSRA &= ~(1<<ADEN);  // Stop conversion before handling. This makes all
          // conversions take at least 25 ADCCLK. (It is restarted later)
        
        // Handle the conversion, depending on what channel it is from, then
        // switch to the next channel in the sequence.
        switch (ADCS.MUX){
                // MUX = 0b000001 => ADC1 (PA1) = NTC
                case 0x01:
                        ADCS.rawNTC = ADC;
                        Next=0x02;
                break;

                
                // MUX = 0b000010 => ADC2 (PA2) = RID
                case 0x02:
                        ADCS.rawRID = ADC;
                        Next=0x03;
                break;

                
                // MUX = 0b000011 => ADC3 (PA4) = VIN-
                case 0x03:
                        // Supply voltage is always divided by 16.
                        ADCS.VIN = ScaleU(4, (unsigned int)ADC);  // Cast because ADC is short.
                        
                        // Is mains failing?
                        if (ADCS.VIN < VIN_MIN) {
                                ADCS.Mains = FALSE;
                        } else {
                                ADCS.Mains = TRUE;
                        }
                        
                        Next=0x05;
                break;

                
                // MUX = 0b000101 => ADC5 (PA6) = VBAT-
                case 0x05:
                        ADCS.rawVBAT = ADC;
                        
                        // Scale voltage according to jumper setting.
                        ADCS.VBAT = ScaleU(VBAT_RANGE, (unsigned int)ADC); // ADC is a short.
                        Next=0x17;
//                      Signed = TRUE;  // Next conversion is bipolar. Halves sensitivity!
                break;


                case 0x17:  // MUX = 0b010111 => 20 x [ADC6(PA7) - ADC5(PA6)] = IBAT
                        // If bipolar, from -512 to 0, to 511:
                        // 0x200 ... 0x3ff, 0x000, 0x001 ... 0x1FF
                
                        // Scale sample according to jumper setting, handle negative numbers.
                        if (ADC > 511) {
                                ADCS.IBAT = -(signed int)ScaleI(VBAT_RANGE,
                                             (1024 - (ADC-ADCS.ADC5_G20_OS)));
                        } else if (ADC > 0) {
                                ADCS.IBAT = ScaleI(VBAT_RANGE, (ADC-ADCS.ADC5_G20_OS));
                        } else {
                                ADCS.IBAT = 0;
                        }

                        // Insert sample of battery current into the averaging-array
                        // (overwriting the oldest sample), then recalculate and store the
                        // average. This is the last conversion in the sequence, so
                        // flag a complete ADC-cycle and restart sequence.
                        ADCS.discIBAT[(avgIndex++ & 0x03)] = ADCS.IBAT;
                        for (i = 0; i < 4 ; i++) {
                                temp += ADCS.discIBAT[i];
                        }
                        
                        ADCS.avgIBAT = (temp / 4);
                        
                        ADCS.Flag = TRUE;
                        Next=0x01;
                        Signed = FALSE;  // This is the only bipolar conversion.
                break;

                
                default:  // Should not happen. (Invalid MUX-channel)
                        Next=0x01;  // Start at the beginning of sequence.
                break;
        }
        
        // Update MUX to next channel in sequence, set a bipolar conversion if
        // this has been flagged.
        ADCS.MUX = Next;                    
        ADMUX = (1<<REFS0) + ADCS.MUX;      

        if (Signed)     {
          ADCSRB |= (1<<BIN);               
        } else {
          ADCSRB &= ~(1<<BIN);              
        }

        // Re-enable the ADC unless a halt has been flagged and a conversion
        // cycle has completed.
        if (!((ADCS.Halt) && (ADCS.Flag))) {
          ADCSRA |= (1<<ADEN)|(1<<ADSC);    
        }
}


unsigned int ScaleU(unsigned char setting, unsigned int data)
{
        // Temporary variable needed.
        unsigned int scaled = 0;

        // Jumper setting 3: mV/LSB = 29.30 ~= 29 + 1/4 + 1/16
        if (setting == 3)       {
                scaled = 29 * data;
                scaled += (data >> 2);
                scaled += (data >> 4);
        } else {
                // Jumper setting 4: mV/LSB = 39.06 ~= 39 + 1/16
                scaled = 39 * data;
                scaled += (data >> 4);
                
                if (setting <3) {
                        // Jumper setting 0: mV/LSB = 4.883 = 39.06 / 8
                        //                1: mV/LSB = 9.766 = 39.06 / 4
                        //                2: mV/LSB = 19.53 = 39.06 / 2
                        scaled = (scaled >> (3-setting));
                }
        }

        return(scaled);
}


unsigned int ScaleI(unsigned char setting, unsigned int data)
{
        // Temporary variable needed.
        unsigned int  scaled = 0;
        
        // Jumper setting 3: mA/LSB = 20.931mA ~= 21 - 1/16 + 1/128
        if (setting == 3) {
                scaled = 21 * data;
                scaled -= (data >> 4);
                scaled += (data >> 7);
        }       else    { // Jumper setting 4: mA/LSB = 27.909mA ~= 28 - 1/8 + 1/32
                scaled = 28 * data;
                scaled -= (data >> 3);
                scaled += (data >> 5);
                
                if (setting <3) {
                        // Jumper setting 0: mA/LSB = 3.489mA = 27.909 / 8
                        //                1: mA/LSB = 6.978mA = 27.909 / 4
                        //                2: mA/LSB = 13.955mA = 27.909 / 2
                        scaled = (scaled >> (3-setting));
                }
        }
        
        return(scaled);
}


void ADC_Wait(void)
{
        // Clear ADC flag and wait for cycle to complete.
        ADCS.Flag = FALSE;              
        do {
        } while (ADCS.Flag == FALSE);      
        
        // Repeat, so we are sure the data beong to the same cycle.
        ADCS.Flag = FALSE;              
        do {
        } while (ADCS.Flag == FALSE);      
}


void ADC_Init(void)
{
        unsigned char i;

        __disable_interrupt();

        ADCS.Halt = FALSE; // Enable consecutive runs of ADC.

        // Configure ADC pins (inputs and disabled pull-ups).
        DDRA &= ~((1<<PA1)|(1<<PA2)|(1<<PA4)|(1<<PA5)|(1<<PA6)|(1<<PA7));
        PORTA &= ~((1<<PA1)|(1<<PA2)|(1<<PA4)|(1<<PA5)|(1<<PA6)|(1<<PA7));

        // Set ADC3 as reference, and MUX to measure the same pin.
        ADMUX = (1<<REFS0) | (1<<MUX0) | (1<<MUX1);
        
        ADCSRB = 0;

        // Start conversion, no interrupt (disable ADC-ISR).
        ADCSRA = (1<<ADEN) | (1<<ADSC) | ADC_PRESCALER; 

        do { // Wait for conversion to finish.
        } while (!(ADCSRA & (1<<ADIF)));

        ADCSRA |= (1<<ADIF);  // Clear ADC interrupt flag manually.

        ADCS.ADC3_G20_OS = ADC;  // Save the sampled offset.

        ADMUX = (1<<REFS0) | 0x16;  // ADC5/ADC5 (external ref.), 20x
        
        // Start conversion, no interrupt. ADC_PRESCALER is defined in ADC.h.
        ADCSRA = (1<<ADEN) | (1<<ADSC) | ADC_PRESCALER; 

        do { // Wait for conversion to finish.
        } while (!(ADCSRA & (1<<ADIF)));

        ADCSRA |= (1<<ADIF);  // Clear ADC interrupt flag.

        ADCS.ADC5_G20_OS = ADC;  // Save the sampled offset.

        // Reset the ADC-cycle.
        ADCS.Flag = FALSE;      
        ADCS.MUX = 0x01;                    
        ADMUX = (1<<REFS0) | ADCS.MUX;      

        // Clear averaged battery current and the discrete readings.
        ADCS.avgIBAT = 0;
        
        for (i = 0; i < 4; i++) {
                ADCS.discIBAT[i] = 0;             
        }
        
        // Re-enable the ADC and ISR.
        ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADIE)|ADC_PRESCALER;
        
        __enable_interrupt();

        // Get a complete cycle of data before returning.
        ADC_Wait();
}

---