adc_internal.c

Go to the documentation of this file.

#include <includes.h>

//Variables
static volatile ADCI_FILTER adci_filters[4]; 
static ADCI_CHAN adci_sched[4]; 
static ADCI_STATUS adci_status = ADCI_DONE; 
static int adci_sched_index = -1; 
static int adci_sched_size = 0; 
void adci_init(int coeff0, int coeff1, int coeff2, int coeff3){
  adci_init_channel(ADCI_CH_0, coeff0);
  adci_init_channel(ADCI_CH_1, coeff1);
  adci_init_channel(ADCI_CH_2, coeff2);
  adci_init_channel(ADCI_CH_3, coeff3);
}

void adci_convert_all(void) //This will be called from the scheduler
{
  if (adci_status == ADCI_NOT_DONE) { //previous conversion did not finish
    error_occurred(ERROR_ADCI_DNF);
  }
  adci_convert_next();
}

void adci_convert_next(void)
{
  adci_sched_index++;
//  printf("%i %i\n",adci_sched_index, adci_sched_size);
  if (adci_sched_index < adci_sched_size){
    adci_status = ADCI_NOT_DONE;
    ADCR &= (~0xFF);// & (~ADCR_RB); //clear chan select bits
    ADCR |= (1<<(adci_sched[adci_sched_index])) & (~ADCR_RB);
//    ADCR |= (1<<adci_next) & ~ADCR_RB; 
//    ADCR &= ~(~(1<<adci_next) & 0x0F)& ~ADCR_RB;
    ADCR |= (1<<24) & (~ADCR_RB); //bit24 is the START conversion bit
  } else {
    adci_sched_index = -1;
    adci_status = ADCI_DONE;
  }
}

void adci_isr(void) __irq
{
  int reg = ADGDR;
  int chan = (reg>>24) & (0x7);
  int result = (reg>>6) & (0x3FF);

  adci_efilter_add(&(adci_filters[chan]), result); 
  

//  printf("chan: %i\n",chan);
  VICVectAddr = 0; //Interrupt Acknowledged
  adci_convert_next(); 

}

int adci_get_result(ADCI_CHAN channel)
{
  return adci_filters[channel].average>>14;
}

int adci_get_raw(ADCI_CHAN chan)
{
  return adci_filters[chan].average;
}

static void adci_init_channel(ADCI_CHAN ch, int coeff)
{
  if (coeff >= 0){
    adci_filters[ch].average = 0; //no initial value
    adci_filters[ch].count = 0;   //no values yet
    adci_filters[ch].coeff = coeff;   //filter coeff
    adci_sched[adci_sched_size] = ch;
    adci_sched_size++;
  }
}

volatile ADCI_FILTER* adci_get_filter(ADCI_CHAN channel)
{
  return &adci_filters[channel];
}

void adci_efilter_add(volatile ADCI_FILTER* f, short num){
  if (num > (1<<16)){
    error_occurred(ERROR_ADCI_FILT_OOB);
  }
  if (f->average == 0)
    f->average = num << 14;
  else
    f->average = f->average - (f->average >> f->coeff) + (((int)num) << (14 - f->coeff));
  f->count = f->count + 1;
}