adc_external.c

Go to the documentation of this file.

#include <includes.h> 

#define ADCX_BUSY (SSPSR & (1<<4)) 
#define ADCX_TNF  (SSPSR & (1<<1)) 
#define ADCX_RNE  (SSPSR & (1<<2)) 
// Variables
static volatile int adcx_index = 0; 
static int adcx_num_configs = 0; 
static ADCX_CHAN_CFG adcx_configs[16]; 
static signed short adcx_results[16];  //re-precated! for direct access to results

static volatile int adcx_status = ADCX_DONE; 
static volatile int adcx_wait_count = 0; 
static int adcx_count = 0;

void adcx_isr(void) __irq
{
  unsigned char msb, lsb;
  int chan;
  signed short result;
  ADCX_CHAN_CFG * cfg;
  
  EXTINT = (1<<1); // Clear External Interrupt flag;
  
  if (adcx_num_configs != 0) {
    // ****** READ N-1th RESULT ****** //
    while (ADCX_RNE){ // If the Rx buffer is Not Empty, read data
      adcx_read_buffer(); //Clear out junk from command
    }
    msb = adcx_register_read(1);
    lsb = adcx_register_read(0);
    result = ((signed short)((((unsigned short)msb)<<8)+(unsigned short)lsb))>>2; //Convert (SIGNED data) to (14 bits, right justified)

    // ****** SAVE RESULT ****** //
    cfg = &(adcx_configs[adcx_index]);
    chan = cfg->chan;
    adcx_results[chan] = result;
  
    // ****** SEND Nth CONVERSION ****** //
    adcx_index = adcx_index + 1;
    adcx_convert_next();
  }
  VICVectAddr = 0;          //indicates end of interrupt service
}

void adcx_convert_all(void){
  if (adcx_status != ADCX_DONE){ 
    error_occurred(ERROR_ADCX_DNF);
  } else {
    adcx_index = 0;
    //Start first conversion
    adcx_convert_next();
  }

}

void adcx_convert_next(void){
  ADCX_CHAN_CFG * cfg;
  if(adcx_index >= adcx_num_configs){
    adcx_status = ADCX_DONE; //no more configs to convert
    cfg = NULL;
    adcx_count = 0;
  } else {
    adcx_status = ADCX_NOT_DONE;
    cfg = &(adcx_configs[adcx_index]);
  }
  if(cfg != NULL) adcx_convert_cfg(cfg);
}

void adcx_convert_cfg(ADCX_CHAN_CFG * config)
{
  adcx_count++;
  adcx_register_write(4, (1<<7)|(config->gain<<4)|(config->chan));
} 

void adcx_write(unsigned short data){
  if (!(ADCX_TNF)){ //Transmit buffer full; TNF (Transmit not full) bit 1
    error_occurred(ERROR_ADCX_TX_FULL);
  } 
  SSPDR = data;
}

void adcx_register_write(unsigned char reg, unsigned char data){  
  short command = (reg<<8)|data;
  while(!(ADCX_TNF)){}  // wait if transmit buffer is full
  SSPDR = command;  // register mode, write, 16 bit, big endian
}

unsigned char adcx_register_read(unsigned char reg){
  unsigned short read_in;
  while (!(ADCX_TNF)){}
  SSPDR = ((1<<6)|reg)<<8; //16 bits reg read instuction
  while (ADCX_BUSY){}
  read_in = SSPDR;                
  return (unsigned char)(read_in & 0x00FF);
}

unsigned short adcx_read_buffer(void){
  unsigned short temp = 0;
  if (ADCX_RNE){ // If the Rx buffer is Not Empty (RNE), read data
    temp = SSPDR;
  } else {
    error_occurred(ERROR_ADCX_RX_EMPTY);
  }
  return temp; 
}

signed short adcx_get_result(char channel)
{
  return adcx_results[channel];
}

void adcx_init(void)
{ 
  // Setup ADC registers
  adcx_register_write(24,0x00); // SPI: MSB first, 3-wire mode, DIN stuff   
  adcx_register_write(3,0x00);  // 2s-comp output, manual readback, CCLK div = 1
  adcx_register_write(7,0x00);  // Vref=2.5V, buffer and ref powered down (using external 5V reference)
  while(ADCX_BUSY){} //Wait for data to be sent
  while(ADCX_RNE){   //Read returning dummy byte to clear out buffer.
      adcx_read_buffer();
  } 
}

void adcx_add_config(unsigned char channel, unsigned char gain) {
  if(adcx_num_configs<16) {
    adcx_configs[adcx_num_configs].chan = channel;
    adcx_configs[adcx_num_configs].gain = gain;
    adcx_num_configs++;
  } else {
    error_occurred(ERROR_ADCX_NUM_CFGS);
  }
}

void adcx_conversion_wait(void){
  adcx_wait_count = 0;
  while(adcx_status == ADCX_NOT_DONE) {
    adcx_wait_count++;
  }
}