ccadc.c

Go to the documentation of this file.

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

/******************************************************************************
 Global (file scope) status variables.
******************************************************************************/
//volatile uint8_t ccAdcInputPolarity;

volatile int32_t CCADC_accResult;
volatile int16_t CCADC_iccResult;

union CCADC_conversionFlag_union{
    uint8_t allFlags;
    struct{
        uint8_t accResultReady : 1 ;
        uint8_t iccResultReady : 1 ;
        uint8_t regularCurrentDetected : 1 ;
    };
} volatile CCADC_statusFlags = {0x00};


/******************************************************************************
 Proto type for private functions.
******************************************************************************/

static void CCADC_PolarityManager( void );


void CCADC_Init( CCADC_AccConvPeriod_t accConversionTime, CCADC_RccConvPeriod_t rccSamplingInterval, uint16_t regularCurrentLevel )
{ 
    // Set Regular current detection level.
    CADRC = ((regularCurrentLevel<<RCC_SCALE) / RCC_STEP_SIZE_mA_SCALED);

    /* Wait until CC-ADC is ready for configuration change. (wait for
     * synchronization between clock domains to be completed since previous change).
     */
    while( CADCSRA & (1<<CADUB) ){
    }
    
    /* Write CC-ADC settings:
     * - Clear CC-ADC Conversion Time and Regular Current Sampling Interval.\n
     * - select new CC-ADC Conversion Time and Current Sampling Interval.\n
     * - and set the polarity bit accoring the initial state.
     */
    CADCSRA = (CADCSRA & ~( (1<<CADAS1)|(1<<CADAS0)|(1<<CADSI1)|(1<<CADSI0)|(1<<CADPOL) )) |
              ((uint8_t)accConversionTime | (uint8_t)rccSamplingInterval) |
              CCADC_POLARITY_POS;
}


void CCADC_SetMode( CCADC_modes_t mode )
{
    while( CADCSRA & (1<<CADUB) ){
    };
    
    switch( mode ){
        case CCADC_DISABLE:
        // Disable CC-ADC and disable interrupts (and clear pending interrupts).
        CADCSRA = CADCSRA & ~( (1<<CADEN) | (1<<CADSE) );
        CADCSRB = (0<<CADACIE) | (0<<CADRCIE) | (0<<CADICIE) | (1<<CADACIF) | (1<<CADRCIF) | (1<<CADICIF);
        break;
        
        case CCADC_IAC:
        // Enable CC-ADC with both ICC and ACC interrupts running (and clear pending interrupts).
        CADCSRA = ( CADCSRA & ~(1<<CADSE) ) | (1<<CADEN);
        CADCSRB = (1<<CADACIE) | (0<<CADRCIE) | (1<<CADICIE) | (1<<CADACIF) | (1<<CADRCIF) | (1<<CADICIF);
        break;
        
        case CCADC_ICC:
        // Enable CC-ADC with ICC interrupt running  (and clear pending interrupts).
        CADCSRA = ( CADCSRA & ~(1<<CADSE) ) | (1<<CADEN);
        CADCSRB = (0<<CADACIE) | (0<<CADRCIE) | (1<<CADICIE) | (1<<CADACIF) | (1<<CADRCIF) | (1<<CADICIF);
        break;
        
        case CCADC_ACC:
        // Enable CC-ADC with ACC interrupt running  (and clear pending interrupts).
        CADCSRA = ( CADCSRA & ~(1<<CADSE) ) | (1<<CADEN);
        CADCSRB = (1<<CADACIE) | (0<<CADRCIE) | (0<<CADICIE) | (1<<CADACIF) | (1<<CADRCIF) | (1<<CADICIF);
        break;
        
        case CCADC_RCC:
        // Enable CC-ADC with RCC and ICC interrupts running (ICC due to RCC unable to wake up device from power save).
        CADCSRA = CADCSRA | (1<<CADSE) | (1<<CADEN);
        CADCSRB = (0<<CADACIE) | (1<<CADRCIE) | (1<<CADICIE) | (1<<CADACIF) | (1<<CADRCIF) | (1<<CADICIF);  
        break;
        
        default:
        break;
    }
}

uint8_t CCADC_GetMode( void )
{
    while( CADCSRA & (1<<CADUB) ){
    }
    
    if( CADCSRA & (1<<CADSE) ){
        return CCADC_RCC;
    }else{
        return CCADC_IAC;
    }
}


int32_t CCADC_GetAccResult( void )
{
    int32_t result;
    uint8_t interruptState = __save_interrupt();

    __disable_interrupt();
    result = CCADC_accResult;
    __restore_interrupt(interruptState);

    return result;
}


int32_t CCADC_GetIccResult( void )
{
    int16_t result;
    uint8_t interruptState = __save_interrupt();
    
    __disable_interrupt();
    result = CCADC_iccResult;
    __restore_interrupt(interruptState);
    
    // Scale the 13-bit Icc result to 18-bit like the Acc result.
    return (int32_t)(result * (1<<5));
}


#pragma inline = forced
static void CCADC_PolarityManager( void )
{
    static uint8_t polarityCounter = CONVERSION_COUNT;
    
    polarityCounter--;
    if(polarityCounter == 0){
        CADCSRA ^= (1<<CADPOL);
        polarityCounter = CONVERSION_COUNT;
    }
}


bool CCADC_isAccResultReady( void )
{
    uint8_t interruptState = __save_interrupt();
    __disable_interrupt();

    bool flagState = CCADC_statusFlags.accResultReady;
    CCADC_statusFlags.accResultReady = false;

    __restore_interrupt( interruptState );
    
    return flagState;
}


bool CCADC_isIccResultReady( void )
{
    uint8_t interruptState = __save_interrupt();
    __disable_interrupt();

    bool flagState = CCADC_statusFlags.iccResultReady;
    CCADC_statusFlags.iccResultReady = false;

    __restore_interrupt( interruptState );
    
    return flagState;
}


#pragma vector= CCADC_CONV_vect
__interrupt void Ccadc_Icc_ISR( void )
{
    if( CADCSRA & (1<<CADPOL) ){
        CCADC_iccResult = -CADIC;
    }else{
        CCADC_iccResult = CADIC;
    }
    CCADC_statusFlags.iccResultReady = true;
}


#pragma vector= CCADC_REG_CUR_vect
__interrupt void Ccadc_Rcc_ISR( void )
{
    CCADC_statusFlags.regularCurrentDetected = true;
}


#pragma vector= CCADC_ACC_vect
__interrupt void Ccadc_Acc_ISR( void )
{
    if( CADCSRA & (1<<CADPOL) ){
        CCADC_accResult = - CADAC;
    }else{
        CCADC_accResult = CADAC;
    }
    CCADC_PolarityManager();
    CCADC_statusFlags.accResultReady = true;
}

---