//
//      TMDX ALPHA RELEASE
//      Intended for product evaluation purposes
//
//###########################################################################
//
// FILE:	DSP28_Example.c
//
// TITLE:	DSP28 CPU_Timer example program.
//
//###########################################################################
//
//  Ver | dd mmm yyyy | Who  | Description of changes
// =====|=============|======|===============================================
//  0.55| 06 May 2002 | S.S. | EzDSP Alpha Release
//  0.57| 27 May 2002 | L.H. | No change
//###########################################################################

// Step 0.  Include required header files
         // DSP28_Device.h: device specific definitions #include statements for
         // all of the peripheral .h definition files.
         // DSP28_Example.h is specific for the given example.  

#include "DSP28_Device.h"

float	a1[16];
unsigned int a2=0;
float	adclo=0.0;

// Prototype statements for functions found within this file.
interrupt void ad(void);

void main(void)
{

// Step 1. Initialize System Control registers, PLL, WatchDog, Clocks to default state:
        // This function is found in the DSP28_SysCtrl.c file.
	InitSysCtrl();

// Step 2. Select GPIO for the device or for the specific application:
        // This function is found in the DSP28_Gpio.c file.
	// InitGpio();  // Skip for this test

// Step 3. Initialize PIE vector table:
	// The PIE vector table is initialized with pointers to shell Interrupt 
        // Service Routines (ISR).  The shell routines are found in DSP28_DefaultIsr.c.
	// Insert user specific ISR code in the appropriate shell ISR routine in 
        // the DSP28_DefaultIsr.c file.

	// Disable and clear all CPU interrupts:
	DINT;
	IER = 0x0000;
	IFR = 0x0000;

	// Initialize Pie Control Registers To Default State:
        // This function is found in the DSP28_PieCtrl.c file.
	InitPieCtrl();

	// Initialize the PIE Vector Table To a Known State:
        // This function is found in DSP28_PieVect.c.
	// This function populates the PIE vector table with pointers
        // to the shell ISR functions found in DSP28_DefaultIsr.c.
	InitPieVectTable();	
	
// Step 4. Initialize all the Device Peripherals to a known state:
	// This function is found in DSP28_InitPeripherals.c
    // InitPeripherals();
    // Just init the timers for this test
//    InitCpuTimers();
    
// Step 5. User specific functions, Reassign vectors (optional), Enable Interrupts:
	
	// Initialize Timer 2:
	//		> Connect To INT14
	//		> Set Up For 1 Second Interrupt Period
	//		> Point To "ISRTimer2" function

	// Reassign CPU-Timer2 ISR. 
        // Reassign the PIE vector for TINT2 to point to a different ISR then
        // the shell routine found in DSP28_DefaultIsr.c.
        // This is done if the user does not want to use the shell ISR routine
        // but instead wants to use their own ISR.  This step is optional:
	
	EALLOW;	// This is needed to write to EALLOW protected registers
	PieVectTable.ADCINT=&ad;
	EDIS;   // This is needed to disable write to EALLOW protected registers
    
    // Include application specific functions. This is for this example:
	
	// Configure CPU-Timer 2 to interrupt every second:
//	ConfigCpuTimer(&CpuTimer2, 100, 1000000);	// 100MHz CPU Freq, 1 second Period (in uSeconds)
// 	StartCpuTimer2();

    InitAdc();

    // Enable INT14 which is connected to CPU-Timer 2:
	IER |= M_INT1;
	//KickDog();
    // Enable global Interrupts and higher priority real-time debug events:
	
	EINT;   // Enable Global interrupt INTM
	ERTM;	// Enable Global realtime interrupt DBGM
	while(AdcRegs.ADC_ST_FLAG.bit.SEQ1_BSY==0)
		{			

			AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;

		}
	//IFR =IFR|0x0001;
// Step 6. IDLE loop. Just sit and loop forever (optional):	
	for(;;)
	{
			//KickDog();
	}
} 	


// Step 7. Insert all local Interrupt Service Routines (ISRs) and functions here:	
	// If local ISRs are used, reassign vector addresses in vector table as
    // shown in Step 5

interrupt void ad(void)
{
	IFR=0x0000;
//	PieCtrl.PIEIFR1.all = 0;
	PieCtrl.PIEACK.all=0xffff;
	a2++;
	a1[0]=((float)AdcRegs.RESULT0)*3.0/65520.0+adclo;
	a1[1]=((float)AdcRegs.RESULT1)*3.0/65520.0+adclo;
	a1[2]=((float)AdcRegs.RESULT2)*3.0/65520.0+adclo;
	a1[3]=((float)AdcRegs.RESULT3)*3.0/65520.0+adclo;
	a1[4]=((float)AdcRegs.RESULT4)*3.0/65520.0+adclo;
	a1[5]=((float)AdcRegs.RESULT5)*3.0/65520.0+adclo;
	a1[6]=((float)AdcRegs.RESULT6)*3.0/65520.0+adclo;
	a1[7]=((float)AdcRegs.RESULT7)*3.0/65520.0+adclo;
	a1[8]=((float)AdcRegs.RESULT8)*3.0/65520.0+adclo;
	a1[9]=((float)AdcRegs.RESULT9)*3.0/65520.0+adclo;
	a1[10]=((float)AdcRegs.RESULT10)*3.0/65520.0+adclo;
	a1[11]=((float)AdcRegs.RESULT11)*3.0/65520.0+adclo;
	a1[12]=((float)AdcRegs.RESULT12)*3.0/65520.0+adclo;
	a1[13]=((float)AdcRegs.RESULT13)*3.0/65520.0+adclo;
	a1[14]=((float)AdcRegs.RESULT14)*3.0/65520.0+adclo;
	a1[15]=((float)AdcRegs.RESULT15)*3.0/65520.0+adclo;
	AdcRegs.ADC_ST_FLAG.bit.INT_SEQ1_CLR=1;
	AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;
	EINT;
	
}

//===========================================================================
// No more.
//===========================================================================