//******************************************************************************
//  TMS470 Demo - MibADC Buffered Sample with Interrupts
//
//  Description; the MibADC is used in buffered mode.  20 samples are taken
//  in continuous mode from channel 9 and are placed in the group 1 FIFO.
//  Interrupts are used to trigger the read of the FIFO
//  20 samples are read and averaged.  The average is displayed on the LEDs
//
//  Total sample and convert time = 19.6608 MHz/(8*((62+2)+11)) = 32.7KSPS
//  SYSCLK = MCLK = ACLK = 8 x 7.3728MHz = 58.9824MHz
//  ICLK = SYSCLK / 3 = 19.6608MHz
//
//  //*An external 7.3728MHz XTAL with proper load caps is required*//
//
//              TMS-FET470B1M
//             -----------------
//            |            OSCIN|-
//         +--|PLLDIS           | 7.3728MHz
//         |  |           OSCOUT|-
//        -+- |                 |
//            |                 |
//        >---|ADIN0         HET|---> Toggle
//            |                 |
//
//  L.Westlund / J.Mangino
//  Texas Instruments, Inc
//  July 29th 2005
//  Built with IAR Embedded Workbench Version: 4.30A
//******************************************************************************

#include <intrinsic.h>
#include "iotms470r1b1m.h"
#include "tms470r1b1m_bit_definitions.h"

void LedSet(unsigned int);
unsigned int result[20];
unsigned int average;

void main(void)
{

  PCR = CLKDIV_3;                         // ICLK = SYSCLK / 3
  GCR = ZPLL_CLK_DIV_PRE_1;               // SYSCLK = 8 x fOSC
  PCR |= PENABLE;                         // Enable peripherals

  HETDIR  = 0xFFFFFFFF;                   // HETx Output direction
  HETDOUT = 0x00000000;

  GIODIRE = 0xFF;                         // GIO[E] set as outputs
  GIODOUTE = 0x00;

  REQMASK = 0;                            // clear interrupt mask
  REQMASK |= (1<<27);                     // enable channel 27 (AD1)

  ADCR1 |= PS_8;                          // ADCLK prescaler = 8
  ADSAMPEV |= SEN;                        // ADCSAMP1 controls SW
  ADSAMP1 = 62;                           // SW = 62+2

  ADCR1 |= ADC_EN;                        // Enable ADC
  ADISR1 = 0x0001;                        // group 1 = channel 0
  ADCR2 |= G1_MODE;                       // Continuous Conversion


  ADBCR1 |= BUF_EN;                       // enable buffered mode
  ADBCR1 |= BNDA_8;                       // set RAM boundary between event and group 1
                                          // units of two words from the beginning of buffer
                                          // event group has 8*2 = 16 words for the FIFO
  ADBCR1 |= BNDB_16 + BNDB_2;             // set RAM boundary between group 1 and 2
                                          // units of two words from the beginning of buffer
                                          // group 1 has (18-8)*2 = 20 words for the FIFO
  ADBCR2 |= BNDEND_64;                    // set RAM buffer end boundary
                                          // 64-word FIFO buffer
                                          // group 2 has 64-(2*18) = 28 words for the FIFO

  ADTHRG1 = G1THR_16 + G1THR_4;           // group 1 threshold counter = 20, 20 results will be
                                          // placed on the buffer before setting G1 BUF INT FLAG

  ADBUFST &= ~G1_INT_FLAG;                // clear flag
  ADBCR3 |= G1_OVR_INT_EN;                // enable group 1 FIFO buffer over-run interrupt
  ADBCR3 |= G1_BUF_INT_EN;                // enable group 1 FIFO buffer interrupt

  __enable_interrupt();                   // enable interrupts

  // Loop forever.
  while(1){}
}

// display binary value on 8 LEDs
void LedSet(unsigned int mask)
{
  unsigned int out = 0;
  GIODOUTE = mask & 0xFF;
  HETDOUT = (mask & 0xFF00)>>8;

}



//------------------------------------------------------------------------------
// TMS470R1B1M Standard Interrupt Handler
//------------------------------------------------------------------------------

__irq __arm void irq_handler(void)
{
   switch((0xff & IRQIVEC)-1)
  {
   case CIM_MIBADCE1  :                   // channel 27 (AD1) interrupt?
     if (ADBUFST & 0x0020)                // buffer over-run?
     {
       ADISR1 = 0x0001;                   // clear buffer
       ADTHRG1 = G1THR_16 + G1THR_4;      // reset group 1 threshold
     }
     else
     {
       unsigned int i;
       ADBUFST &= ~G1_INT_FLAG;           // clear flag
       average = 0;
       for (i=0; i<20; i++)
       {
         result[i] = ADBUF1;              // read FIFO value
         average = average + result[i];   // sum values
       }
       average = (unsigned int) average / 20;  // get average
       LedSet(average);
      }
      break;
  }
}