aversive_10-03-12/modules/hardware/adc/adc.c

Go to the documentation of this file.

/*
 *  Copyright Droids Corporation, Microb Technology, Eirbot (2005)
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Revision : $Id: adc.c,v 1.12 2009-03-15 21:51:19 zer0 Exp $
 *
 */

#include <stdlib.h>

#include <aversive.h>
#include <adc.h>

 /* keep the previous config */
static uint16_t g_adc_previous_config = ADC_NO_CONFIG;

/* function pointer definition for event */
static void (*adc_event)(int16_t) = NULL;


void adc_init(void)
{
#if defined(PRADC) && defined(PRR)
        cbi(PRR, PRADC);
#elif defined(PRADC) && defined(PRR0)
        cbi(PRR0, PRADC);
#endif

        ADCSRA =  (1<<ADEN) | (ADC_PRESCALE << ADPS0);
        ADMUX = 0;
#ifdef ADCSRB
        ADCSRB = 0;
#endif
}

void adc_shutdown(void)
{
        ADCSRA = 0; // erases all the register

#if defined(PRADC) && defined(PRR)
        sbi(PRR, PRADC);
#elif defined(PRADC) && defined(PRR0)
        sbi(PRR0, PRADC);
#endif
}


void adc_register_event(void (*f)(int16_t))
{
        uint8_t flags;

        IRQ_LOCK(flags);
        adc_event = f;
        IRQ_UNLOCK(flags);
}

SIGNAL(SIG_ADC)
{
        int16_t result;

        if (!adc_event)
                return;

        result = ADC;
        
        /* sign extension to fill the 16 bits when negative
         * (for the 16 bits output format, the output is
         * already right.) */
        if ( ( g_adc_previous_config & ADC_RESULT_SIGNED)
             && !(g_adc_previous_config & ADC_MODE_16_BITS)
             && (result & 0x0200) )
                result |= 0xFE00;
        
        adc_event(result);
}


void adc_launch(uint16_t conversion_config)
{
        /* configure multiplexer : done first, so the maximum time is
         * left before the real conversion launch */
        ADMUX = conversion_config & 0xFF ;
        if ( (conversion_config & ADC_RESULT_SIGNED) &&
             (g_adc_previous_config != conversion_config) ) {
                cbi(ADCSRA,ADEN);
                sbi(ADCSRA,ADEN);
        }

        /* save config */
        g_adc_previous_config = conversion_config;

        /* for some devices, one additionnal MUX bit is in ADCSRB */
#ifdef MUX5_IN_ADCSRB
        if (conversion_config & MUX5_MASK_IN_CONFIG)
                sbi(ADCSRB, MUX5);
        else
                cbi(ADCSRB, MUX5);
#endif // MUX5_IN_ADCSRB

        /* Enable free run or not (triggered mode) */
        if (conversion_config  & ADC_MODE_TRIGGERED)
                sbi(ADCSRA, ADFR);
        else
                cbi(ADCSRA, ADFR);

        /* Start conversion, with or without enabling interrupts */
        if (conversion_config & ADC_MODE_INT) {
                /* Clear flag from previous intr (in case of previous
                 * conversion was not using intr), and enable
                 * interrupt */
                ADCSRA |=  (1 << ADSC) | (1 << ADIF) | (1 << ADIE);
        }
        else {
                /* clear flag from previous int, used as a 'conversion
                   finished' flag */
                cbi(ADCSRA, ADIE);
                ADCSRA |=  (1 << ADSC) | (1 << ADIF);
        }
}

int16_t adc_get_value(uint16_t conversion_config)
{
        int16_t result;

        /* conversion has previously been launched, or no change */
        if ((conversion_config == ADC_NO_CONFIG) ||
            (conversion_config == g_adc_previous_config)) {
                if (bit_is_clear(ADCSRA, ADSC) &&
                    bit_is_clear(ADCSRA, ADIF)) {
                        /* no result is available now and no
                           conversion is pending -> launch it... */
                        adc_launch(g_adc_previous_config);
                }
        }
        /* The previous conversion had a different configuration : we
         * must launch a new one */
        else {
                /* Cancel previous triggered mode, if it was set and
                 * reset interrupt mask */
                cbi(ADCSRA, ADFR);
                cbi(ADCSRA, ADIE);

                /* waiting for the previous conv to finish, result will
                 * be lost */
                while (bit_is_set(ADCSRA, ADSC));

                /* launch new one */
                adc_launch(conversion_config);
        }

        /* waiting for the result, works even in triggered mode, then
         * clear the flag. */
        while (bit_is_clear(ADCSRA, ADIF));
        sbi(ADCSRA, ADIF);

        result = ADC;

        /* If we are in SIGNED_MODE + 10 bits format, and if the
         * result is negative, set the 7 first MSB bits to 1 */
        if(  ( g_adc_previous_config & ADC_RESULT_SIGNED ) &&
             !(g_adc_previous_config & ADC_MODE_16_BITS) &&
             (result & 0x0200) ) {
                result |= 0xFE00;
        }

        return result;
}


int32_t adc_get_value32(void *conversion_config)
{
        return adc_get_value((uint16_t)conversion_config);
}

---