modules/hardware/adc/adc.c

   1 /*
   2  *  Copyright Droids Corporation, Microb Technology, Eirbot (2005)
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  *  Revision : $Id: adc.c,v 1.8.4.8 2009-02-27 21:37:49 zer0 Exp $
  19  *
  20  */
  21
  22 #include <stdlib.h>
  23
  24 #include <aversive.h>
  25 #include <adc.h>
  26
  27  /* keep the previous config */
  28 static uint16_t g_adc_previous_config = ADC_NO_CONFIG;
  29
  30 /* function pointer definition for event */
  31 static void (*adc_event)(int16_t) = NULL;
  32
  33
  34 /**
  35  * Initialisation of ADC internal registers
  36  * Can be called for a wake up after a shutdown command
  37  */
  38 void adc_init(void)
  39 {
  40 #if defined(PRADC) && defined(PRR)
  41         cbi(PRR, PRADC);
  42 #elif defined(PRADC) && defined(PRR0)
  43         cbi(PRR0, PRADC);
  44 #endif
  45
  46         ADCSRA =  (1<<ADEN) | (ADC_PRESCALE << ADPS0);
  47         ADMUX = 0;
  48 #ifdef ADCSRB
  49         ADCSRB = 0;
  50 #endif
  51 }
  52
  53 /**
  54  * Shut down the ADC, for power consumption
  55  */
  56 void adc_shutdown(void)
  57 {
  58         ADCSRA = 0; // erases all the register
  59
  60 #if defined(PRADC) && defined(PRR)
  61         sbi(PRR, PRADC);
  62 #elif defined(PRADC) && defined(PRR0)
  63         sbi(PRR0, PRADC);
  64 #endif
  65 }
  66
  67
  68 /**
  69  * Register callback event. The parameter function is called when the
  70  * conversion is finished.
  71  */
  72 void adc_register_event(void (*f)(int16_t))
  73 {
  74         uint8_t flags;
  75
  76         IRQ_LOCK(flags);
  77         adc_event = f;
  78         IRQ_UNLOCK(flags);
  79 }
  80
  81 /**
  82  * Interrupt function, other interrupts are disabled during its
  83  * execution.
  84  */
  85 SIGNAL(SIG_ADC)
  86 {
  87         int16_t result;
  88
  89         if (!adc_event)
  90                 return;
  91
  92         result = ADC;
  93
  94         /* sign extension to fill the 16 bits when negative
  95          * (for the 16 bits output format, the output is
  96          * already right.) */
  97         if ( ( g_adc_previous_config & ADC_RESULT_SIGNED)
  98              && !(g_adc_previous_config & ADC_MODE_16_BITS)
  99              && (result & 0x0200) )
 100                 result |= 0xFE00;
 101
 102         adc_event(result);
 103 }
 104
 105
 106 /**
 107  * Launch a conversion : this function launches a conversion with the
 108  * specified configuration.  The conversion_config is casted to an
 109  * int.
 110 */
 111 void adc_launch(uint16_t conversion_config)
 112 {
 113         /* configure multiplexer : done first, so the maximum time is
 114          * left before the real conversion launch */
 115         ADMUX = conversion_config & 0xFF ;
 116         /**
 117          * This disables and reenables the ADC when a different
 118          * channel is selected AND the new channel is a differential
 119          * one. Using this trick, the ADC recalibrates, and the time
 120          * for this allows the amplifier to settle.
 121          *
 122          * Datasheet says :
 123          * When switching to a differential gain channel, the first
 124          * conversion result may have a poor accuracy due to the
 125          * required settling time for the automatic offset
 126          * cancellation circuitry.  The user should preferably
 127          * disregard the first conversion result.
 128          */
 129         if ( (conversion_config & ADC_RESULT_SIGNED) &&
 130              (g_adc_previous_config != conversion_config) ) {
 131                 cbi(ADCSRA,ADEN);
 132                 sbi(ADCSRA,ADEN);
 133         }
 134
 135         /* save config */
 136         g_adc_previous_config = conversion_config;
 137
 138         /* for some devices, one additionnal MUX bit is in ADCSRB */
 139 #ifdef MUX5_IN_ADCSRB
 140         if (conversion_config & MUX5_MASK_IN_CONFIG)
 141                 sbi(ADCSRB, MUX5);
 142         else
 143                 cbi(ADCSRB, MUX5);
 144 #endif // MUX5_IN_ADCSRB
 145
 146         /* Enable free run or not (triggered mode) */
 147         if (conversion_config  & ADC_MODE_TRIGGERED)
 148                 sbi(ADCSRA, ADFR);
 149         else
 150                 cbi(ADCSRA, ADFR);
 151
 152         /* Start conversion, with or without enabling interrupts */
 153         if (conversion_config & ADC_MODE_INT) {
 154                 /* Clear flag from previous intr (in case of previous
 155                  * conversion was not using intr), and enable
 156                  * interrupt */
 157                 ADCSRA |=  (1 << ADSC) | (1 << ADIF) | (1 << ADIE);
 158         }
 159         else {
 160                 /* clear flag from previous int, used as a 'conversion
 161                    finished' flag */
 162                 cbi(ADCSRA, ADIE);
 163                 ADCSRA |=  (1 << ADSC) | (1 << ADIF);
 164         }
 165 }
 166
 167 /**
 168  * This function gets an ADC value. If a conversion has been
 169  * previously started, with EXACTLY the same config (or specifying
 170  * ADC_NO_CONFIG) then it waits for it to finish. Else it launches a
 171  * new one with the given config, and polls the result.
 172  *
 173  * This function should not be used if you use interrupts, but only
 174  * can be used with triggered (or free run mode)
 175 */
 176 int16_t adc_get_value(uint16_t conversion_config)
 177 {
 178         int16_t result;
 179
 180         /* conversion has previously been launched, or no change */
 181         if ((conversion_config == ADC_NO_CONFIG) ||
 182             (conversion_config == g_adc_previous_config)) {
 183                 if (bit_is_clear(ADCSRA, ADSC) &&
 184                     bit_is_clear(ADCSRA, ADIF)) {
 185                         /* no result is available now and no
 186                            conversion is pending -> launch it... */
 187                         adc_launch(g_adc_previous_config);
 188                 }
 189         }
 190         /* The previous conversion had a different configuration : we
 191          * must launch a new one */
 192         else {
 193                 /* Cancel previous triggered mode, if it was set and
 194                  * reset interrupt mask */
 195                 cbi(ADCSRA, ADFR);
 196                 cbi(ADCSRA, ADIE);
 197
 198                 /* waiting for the previous conv to finish, result will
 199                  * be lost */
 200                 while (bit_is_set(ADCSRA, ADSC));
 201
 202                 /* launch new one */
 203                 adc_launch(conversion_config);
 204         }
 205
 206         /* waiting for the result, works even in triggered mode, then
 207          * clear the flag. */
 208         while (bit_is_clear(ADCSRA, ADIF));
 209         sbi(ADCSRA, ADIF);
 210
 211         result = ADC;
 212
 213         /* If we are in SIGNED_MODE + 10 bits format, and if the
 214          * result is negative, set the 7 first MSB bits to 1 */
 215         if(  ( g_adc_previous_config & ADC_RESULT_SIGNED ) &&
 216              !(g_adc_previous_config & ADC_MODE_16_BITS) &&
 217              (result & 0x0200) ) {
 218                 result |= 0xFE00;
 219         }
 220
 221         return result;
 222 }
 223
 224
 225 /**
 226  * Just a int32_t version for compatibility with control_system
 227  * function prototypes.
 228  */
 229 int32_t adc_get_value32(void *conversion_config)
 230 {
 231         return adc_get_value((uint16_t)conversion_config);
 232 }
 233