File content as of revision 54:660af33fa930:

//-------------------------------------------------------------------------------
// 
//  Treehouse Designs Inc.
//  Colorado Springs, Colorado
// 
//  Copyright (c) 2016 by Treehouse Designs Inc. 
//  Copyright (c) 2018 by Agility Power Systems Inc. 
// 
//  This code is the property of Treehouse Designs, Inc. (Treehouse) and
//  Agility Power Systems Inc. (Agility) and may not be redistributed
//  in any form without prior written permission from 
//  both copyright holders, Treehouse and Agility.
//
//  The above copyright notice and this permission notice shall be included in
//  all copies or substantial portions of the Software.
// 
//   
//-------------------------------------------------------------------------------
// 
//  REVISION HISTORY:
//  
//   $Author: $
//   $Rev: $
//   $Date: $
//   $URL: $
// 
//-------------------------------------------------------------------------------

#include "mbed.h"
#include "adc_defs.h"
#include "adc.h"
#include "all_io.h"

void initADC(void){
    
    //Auto-zero current values
    struct adcValues adcVals = getADCresults();
    
    CURRENT_48_OFFSET = adcVals.i48;
    CURRENT_24_OFFSET = adcVals.i24;
    CURRENT_12_OFFSET = adcVals.i12;
    
}

/*******************************************************************************
 getADCresults
*******************************************************************************/
struct adcValues getADCresults(void){
    
    unsigned int v48x = 0; 
    unsigned int v24x = 0;
    unsigned int v12x = 0;
    unsigned int i48x = 0; 
    unsigned int i24x = 0;
    unsigned int i12x = 0;
    
    struct adcValues avals;
    unsigned int loopCounter = LOOP_COUNTER;
    
    for(unsigned int i=0;i<loopCounter;i++){
        v48x = v48x + VIN48.read_u16();
        i48x = i48x + IIN48.read_u16();
        v24x = v24x + VIN24.read_u16();
        i24x = i24x + IIN24.read_u16();
        v12x = v12x + VIN12.read_u16();
        i12x = i12x + IIN12.read_u16();
    }
    avals.v48 = v48x/loopCounter; 
    avals.v24 = v24x/loopCounter;
    avals.v12 = v12x/loopCounter;
    avals.i48 = i48x/loopCounter; 
    avals.i24 = i24x/loopCounter;
    avals.i12 = i12x/loopCounter;
    
    return avals;
}

/*******************************************************************************
 getADCvolts
*******************************************************************************/
struct adcValues getADCvolts(void){
    
    unsigned int v48x = 0; 
    unsigned int v24x = 0;
    unsigned int v12x = 0;
    
    struct adcValues avals;
    
    for(unsigned int i=0;i<100;i++){
        v48x = v48x + VIN48.read_u16();
        v24x = v24x + VIN24.read_u16();
        v12x = v12x + VIN12.read_u16();
    }
    avals.v48 = v48x/100; 
    avals.v24 = v24x/100;
    avals.v12 = v12x/100;
    
    return avals;
}

/*******************************************************************************
 getADCamps
*******************************************************************************/
struct adcValues getADCamps(void){
    
    unsigned int i48x = 0; 
    unsigned int i24x = 0;
    unsigned int i12x = 0;
    
    struct adcValues avals;
    
    for(unsigned int i=0;i<100;i++){
        i48x = i48x + IIN48.read_u16();
        i24x = i24x + IIN24.read_u16();
        i12x = i12x + IIN12.read_u16();
    }
    avals.i48 = i48x/100; 
    avals.i24 = i24x/100;
    avals.i12 = i12x/100;
    
    return avals;
}

/*******************************************************************************
 calcDisplayValues
*******************************************************************************/
struct displayValues calcDisplayValues(struct adcValues avals){
    
    struct displayValues dvals;
    
    if(!raw){
        double VOLTAGE_48_CORRECTION = VOLTAGE_TARG_VALUE/VOLTAGE_48_ACTUAL_VALUE/ADC_SCALE_FACTOR;
        double VOLTAGE_24_CORRECTION = VOLTAGE_TARG_VALUE/VOLTAGE_24_ACTUAL_VALUE/ADC_SCALE_FACTOR;
        double VOLTAGE_12_CORRECTION = VOLTAGE_TARG_VALUE/VOLTAGE_12_ACTUAL_VALUE/ADC_SCALE_FACTOR;
        double VOLTAGE_48_FACTOR = 48.0*VOLTAGE_48_CORRECTION;
        double VOLTAGE_24_FACTOR = 24.0*VOLTAGE_24_CORRECTION;
        double VOLTAGE_12_FACTOR = 12.0*VOLTAGE_12_CORRECTION;
        dvals.v48f = (VOLTAGE_48_FACTOR*avals.v48) - VOLTAGE_48_OFFSET;
        dvals.v24f = (VOLTAGE_24_FACTOR*avals.v24) - VOLTAGE_24_OFFSET;
        dvals.v12f = (VOLTAGE_12_FACTOR*avals.v12) - VOLTAGE_12_OFFSET;
        
        // The adc results are linear above CURRENT_48_DIV_THRESH5. Only apply a linear correction to it above that threshold.
        // The multiple correction factors below CURRENT_48_DIV_THRESH5 linearize the curve below CURRENT_48_DIV_THRESH5.
        if(abs((avals.i48-CURRENT_48_OFFSET)) > CURRENT_48_DIV_THRESH5){
            dvals.i48f = ((avals.i48-CURRENT_48_OFFSET)/CURRENT_48_DIV_FACTOR5)-CURRENT_48_CORRECTION5;
        }else if(abs((avals.i48-CURRENT_48_OFFSET)) > CURRENT_48_DIV_THRESH4){
            dvals.i48f = ((avals.i48-CURRENT_48_OFFSET)/CURRENT_48_DIV_FACTOR4)-CURRENT_48_CORRECTION4;
        }else if(abs((avals.i48-CURRENT_48_OFFSET)) > CURRENT_48_DIV_THRESH3){
            dvals.i48f = ((avals.i48-CURRENT_48_OFFSET)/CURRENT_48_DIV_FACTOR3)-CURRENT_48_CORRECTION3;
        }else if(abs((avals.i48-CURRENT_48_OFFSET)) > CURRENT_48_DIV_THRESH2){
            dvals.i48f = ((avals.i48-CURRENT_48_OFFSET)/CURRENT_48_DIV_FACTOR2)-CURRENT_48_CORRECTION2;
        }else if(abs((avals.i48-CURRENT_48_OFFSET)) > CURRENT_48_DIV_THRESH1){
            dvals.i48f = ((avals.i48-CURRENT_48_OFFSET)/CURRENT_48_DIV_FACTOR1)-CURRENT_48_CORRECTION1;
        }else{
            dvals.i48f = ((avals.i48-CURRENT_48_OFFSET)/CURRENT_48_DIV_FACTOR0)-CURRENT_48_CORRECTION0;
        }
        
        dvals.i24f = (avals.i24-CURRENT_24_OFFSET)/CURRENT_24_DIV_FACTOR;
        
        // The adc results are linear above CURRENT_12_DIV_THRESH5. Only apply a linear correction to it above that threshold.
        // The multiple correction factors below CURRENT_12_DIV_THRESH5 linearize the curve below CURRENT_12_DIV_THRESH5.
        if(abs((avals.i12-CURRENT_12_OFFSET)) > CURRENT_12_DIV_THRESH5){
            dvals.i12f = ((avals.i12-CURRENT_12_OFFSET)/CURRENT_12_DIV_FACTOR5)-CURRENT_12_CORRECTION5;
        }else if(abs((avals.i12-CURRENT_12_OFFSET)) > CURRENT_12_DIV_THRESH4){
            dvals.i12f = ((avals.i12-CURRENT_12_OFFSET)/CURRENT_12_DIV_FACTOR4)-CURRENT_12_CORRECTION4;
        }else if(abs((avals.i12-CURRENT_12_OFFSET)) > CURRENT_12_DIV_THRESH3){
            dvals.i12f = ((avals.i12-CURRENT_12_OFFSET)/CURRENT_12_DIV_FACTOR3)-CURRENT_12_CORRECTION3;
        }else if(abs((avals.i12-CURRENT_12_OFFSET)) > CURRENT_12_DIV_THRESH2){
            dvals.i12f = ((avals.i12-CURRENT_12_OFFSET)/CURRENT_12_DIV_FACTOR2)-CURRENT_12_CORRECTION2;
        }else if(abs((avals.i12-CURRENT_12_OFFSET)) > CURRENT_12_DIV_THRESH1){
            dvals.i12f = ((avals.i12-CURRENT_12_OFFSET)/CURRENT_12_DIV_FACTOR1)-CURRENT_12_CORRECTION1;
        }else{
            dvals.i12f = ((avals.i12-CURRENT_12_OFFSET)/CURRENT_12_DIV_FACTOR0)-CURRENT_12_CORRECTION0;
        }
    }else{
        dvals.v48f = 1.0*avals.v48;
        dvals.v24f = 1.0*avals.v24;
        dvals.v12f = 1.0*avals.v12;
        dvals.i48f = 1.0*avals.i48;
        dvals.i24f = 1.0*avals.i24;
        dvals.i12f = 1.0*avals.i12;
    }
    return dvals;
}