//###########################################################################
//
// FILE:	DC_DC_PWM.c
//
// TITLE:	DC/DC PWM control program.//
//
//###########################################################################
//
//  Ver | dd mmm yyyy | Who  | Description of changes
// =====|=============|======|===============================================
//  0.10| 27 Jan 2004 | ZYG  | test program, with attach pulses
//  0.30| 22 Feb 2004 | ZYG  | new pwm mode, without attach pulse 
//###########################################################################

// 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"
#include "ext_inf.h"

#define KeyPressedVoltage 2000
#define KeyPressCountLimit 20
#define	OffsetHighLimit	850
#define	OffsetLowLimit	-850

#define AttPulseInit  100

#define	OffsetIncrease	1
#define	OffsetDecrease	2
#define	OffsetZero		3
#define	AttPulseToggle	4

#define FlashSlow 50
#define FlashFast 15

void InitEv_1(void);
void LedFlash(void);
void KeyHandle(void);
void GetKeyValue(void);
void OffsetZeroHandle(void);

interrupt void T1Underflow_ISR(void);
interrupt void T1Period_ISR(void);
interrupt void T1Match_ISR(void);

interrupt void T3Underflow_ISR(void);
interrupt void T3Period_ISR(void);

interrupt void Timer2_ISR(void);
interrupt void ADC_ISR(void);

int i, Period, Offset, OffsetZeroFlag=0, LedFlag, LedCount=0;
int KeyValue, OldKeyValue, KeyPressCount=0, KeyHold=0;
int KeyHandleCount=0;
int ADCISRFlag=0, Syn_Flag=0;
int	AttPulse;
int LedCountLimit;

unsigned int ADCResult[4];

int tmp;
void main(void)
{
	/* Initialize system */
	InitSysCtrl();	

	/* Disable all interrupts */
	DINT;			
	IER = 0x0000;
	IFR = 0x0000;
	
	InitPieCtrl();
	
	/* Initialize PIE vector table */
	InitPieVectTable();	
	
	EALLOW;	
	PieVectTable.T1UFINT = &T1Underflow_ISR;
	PieVectTable.T1PINT = &T1Period_ISR;
	PieVectTable.T1CINT = &T1Match_ISR;
	
	PieVectTable.T3UFINT = &T3Underflow_ISR;
	PieVectTable.T3PINT = &T3Period_ISR;
	
	PieVectTable.TINT2 = &Timer2_ISR;
	PieVectTable.ADCINT = &ADC_ISR;
	EDIS; 
	
	/* Initialize EV*/
//	InitEv();
	
	InitCpuTimers();	
	InitEv_1();
	InitAdc();
	
	
	ConfigCpuTimer(&CpuTimer2, 150, 20000);	
 	StartCpuTimer2();
 	
 	AttPulse = AttPulseInit;
	
	EvaRegs.EVAIFRA.all = 0xffff;	//clear all suspend interrupts

  	EvaRegs.EVAIMRA.bit.T1UFINT = 1;
	EvaRegs.EVAIMRA.bit.T1CINT = 1;
	EvaRegs.EVAIMRA.bit.T1PINT = 1;
		
	PieCtrl.PIEIER1.bit.INTx6 = 1;
	
	PieCtrl.PIEIER2.bit.INTx4 = 1;	// T1PINT
	PieCtrl.PIEIER2.bit.INTx5 = 1;	// T1CINT
	PieCtrl.PIEIER2.bit.INTx6 = 1;	// T1UFINT
	
	Period = 3000;
	Offset = 000;
		
	EvaRegs.CMPR1 = Period / 2;
	EvaRegs.CMPR2 = Period / 2;
	EvaRegs.CMPR3 = Period / 2;	
		
	EvbRegs.CMPR4 = AttPulse;
	EvbRegs.CMPR5 = Period - AttPulse;
	EvbRegs.CMPR6 = Period / 4;
	
	EvaRegs.T1CON.bit.TENABLE = 1;
	EvbRegs.T3CON.bit.TENABLE = 1;
	
	IER |= M_INT1;
	IER |= M_INT2;
	IER |= M_INT14;	
	
	EINT;
	ERTM;
	
	OldKeyValue = 0;
	
	OffsetZeroFlag = 0;
	
	LedCount = 0;
	LedCountLimit = FlashFast;
	
	for(;;)
	{
//		KickDog();
	LedFlash();
	if(ADCISRFlag)
		{
		ADCISRFlag = 0;			
		KeyHandle();
		OffsetZeroHandle();
		}
	}


} 	

void InitEv_1(void)
{
	EALLOW;
	GpioMuxRegs.GPAMUX.all = 0x00ff;
	GpioMuxRegs.GPBMUX.all = 0x00ff;
	EDIS;

//EVA
	
	EvaRegs.GPTCONA.all = 0x0876;		/* gp timer control register */

	EvaRegs.T1CNT = 0;					/* timer1 count is zero */
	EvaRegs.T1CON.all = 0x0802;			//
	EvaRegs.T1PR = Period;
	EvaRegs.T1CMPR = Period / 2;
		
	EvaRegs.T2CNT = Period / 2;
	EvaRegs.T2CON.all = 0x0887;
	EvaRegs.T2CMPR = Period / 2 + 200;
		
	EvaRegs.COMCONA.all = 0xa2e0;
	EvaRegs.ACTRA.all = 0x0666;
	
	EvaRegs.DBTCONA.all = 0x03ff;

//EVB

	EvbRegs.GPTCONB.all = 0x0879;		/* gp timer control register */

//	EvbRegs.T3CNT = 0;					/* timer1 count is zero */
	EvbRegs.T3CNT = Period;
	EvbRegs.T3CON.all = 0x0802;			//
	EvbRegs.T3PR = Period;
	EvbRegs.T3CMPR = Period / 2;
	
	EvbRegs.T4CNT = Period / 2;
	EvbRegs.T4CON.all = 0x0887;
	EvbRegs.T4CMPR = Period / 2 - 200;
	
	EvbRegs.COMCONB.all = 0xa2e0;
	EvbRegs.ACTRB.all = 0x0666;
			
	EvbRegs.DBTCONB.all = 0x03ff;		
}	

void LedFlash(void)
{
	if(LedCount >= LedCountLimit)
	{
		LedCount = 0;
		if(LedFlag == 0)
		{
			LedFlag = 1;
			*LED2 = 1;
		}
		else
		{
			LedFlag = 0;
			*LED2 = 0;
		}	
	}	
}


void KeyHandle(void)
{
	GetKeyValue();
	if(KeyValue == OldKeyValue)
	{
		if(KeyHold)
			switch(KeyValue)
				{
				case OffsetIncrease:
					if(Offset < OffsetHighLimit)
						Offset += 10;
					break;
						
				case OffsetDecrease:
					if(Offset > OffsetLowLimit)
						Offset -= 10;
					break;
						
				default:
					break;
			
				}
		}
	else
		{
			OldKeyValue = KeyValue;
			switch(KeyValue)
				{
				case OffsetIncrease:
					if(Offset < OffsetHighLimit)
						Offset+=10;
					break;
						
				case OffsetDecrease:
					if(Offset > OffsetLowLimit)
						Offset-=10;
					break;
					
				case OffsetZero:
					OffsetZeroFlag = 1;
					break;	
					
				case AttPulseToggle:
					if(AttPulse)
						{
						AttPulse = 0;
						LedCountLimit = FlashSlow;
						}
					else
						{
						AttPulse = AttPulseInit;
						LedCountLimit = FlashFast;
						}
								
					EvbRegs.CMPR4 = AttPulse;
					EvbRegs.CMPR5 = Period - AttPulse;
					break;
						
				default:
					break;		
				}	
		}		
}

void GetKeyValue(void)
	{

		{
//		ADCISRFlag = 0;
		KeyValue = 0;
		
		for(i=0;i<4;i++)
			{
			if(ADCResult[i]<KeyPressedVoltage)
				{
				if(KeyPressCount < KeyPressCountLimit) 
					KeyPressCount++;
				else
					KeyHold = 1;
					
				KeyValue = i + 1;
				}
			}
		
		
		if(!KeyValue)
			{					
			KeyPressCount = 0;
			KeyHold = 0;
			KeyValue = 0;
			}
		}	
	}


void OffsetZeroHandle(void)
{
if(OffsetZeroFlag)
	{
	if(abs(Offset) < 10)
		{
		Offset = 0;
		OffsetZeroFlag = 0;
		}
	else
		{
		if(Offset > 0)
			Offset -= 10;
		else
			Offset += 10;
		}
	}
}
					
/********************************
*								*
* Interrupt Service Routines	*
*								*
********************************/


interrupt void T1Underflow_ISR(void)
{
	
	EvaRegs.EVAIFRA.bit.T1UFINT = 1;
	PieCtrl.PIEACK.bit.ACK2 = 1;
	
	if(Offset < 0)
		{
		EvaRegs.CMPR1 = Period - 1 + Offset;
//		EvaRegs.CMPR2 = Period/2 + Offset;
		}
	else
		{
		EvaRegs.CMPR1 = Period - 1;
//		EvaRegs.CMPR2 = Period/2 + Offset;
		}		

	Syn_Flag = 1;	
		
//	EvbRegs.T3CNT = 0;
}

interrupt void T1Period_ISR(void) 
{
	EvaRegs.EVAIFRA.bit.T1PINT = 1;
	PieCtrl.PIEACK.bit.ACK2 = 1;

	EvbRegs.T3CNT = 0;		// Syn		
	
	if(Offset < 0)
		{
		EvaRegs.CMPR1 =  1 - Offset;
//		EvaRegs.CMPR2 = Period/2 + Offset;
		}
	else
		{
		EvaRegs.CMPR1 = 1;
//		EvaRegs.CMPR2 = Period/2 + Offset;
		}

}


interrupt void T1Match_ISR(void)
{
	EvaRegs.EVAIFRA.bit.T1CINT = 1;
	PieCtrl.PIEACK.bit.ACK2 = 1;
	tmp = EvaRegs.T2CNT;	

	if(Syn_Flag == 1)
	{
		Syn_Flag = 0;
		EvaRegs.T2CNT = 0;
		EvbRegs.T4CNT = 0;
	}
}



interrupt void T3Underflow_ISR(void)
	{
	EvbRegs.EVBIFRA.bit.T3UFINT = 1;
	PieCtrl.PIEACK.bit.ACK4 = 1;
	
	if(Offset < 0)
		EvbRegs.CMPR4 = 1;
	else
		EvbRegs.CMPR4 = 1 + Offset;

	}



interrupt void T3Period_ISR(void) 
	{
	EvbRegs.EVBIFRA.bit.T3PINT = 1;
	PieCtrl.PIEACK.bit.ACK4 = 1;

	if(Offset < 0)
		EvbRegs.CMPR4 = Period - 1;
	else
		EvbRegs.CMPR4 = Period - 1 - Offset;

	}

	
interrupt void Timer2_ISR(void)
{

	if(AdcRegs.ADC_ST_FLAG.bit.SEQ1_BSY==0)
		{			

			AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;
			
			LedCount++;
			
		}
}


interrupt void ADC_ISR(void)
{

	PieCtrl.PIEACK.bit.ACK1 = 1;

	ADCResult[0] = AdcRegs.RESULT0;
	ADCResult[1] = AdcRegs.RESULT2;
	ADCResult[2] = AdcRegs.RESULT4;
	ADCResult[3] = AdcRegs.RESULT6;
	
	AdcRegs.ADC_ST_FLAG.bit.INT_SEQ1_CLR=1;
	//	AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;
	
	ADCISRFlag = 1;	
}
//===========================================================================
// No more.
//===========================================================================