drv_timer0.c

Enhanced LPC213x device drivers,tools ADS1.2

#include "config_60_61.h"
#include "config_GD61.h"
#include "config_GD60.h"
#include "include_GD60.h"
#include "include_GD61.h"

volatile uint16 mSecondTick;			// for delay Function
volatile uint16 U1_ModeSwitchDly = MODE_SWITCH_Dly;
volatile uint16 U2_ModeSwitchDly = MODE_SWITCH_Dly*3/2;
volatile uint16 MP_FailedmSecondCnt;	// for main power failed detector
volatile uint16 CommandSendTimer;
extern volatile uint8 GetCurrentDataTick;
extern volatile uint8 U1U2_ReadyTimer ;	// DSP get ready time

//extern uint16  DO_Buffer;	
extern uint16 DO_HoldingTime;
extern volatile uint16 DO_ResTime[MAX_DO_CHANNEL];

/////////////////////////////////////////////////////////////////////////
int32 CurInputA_II;				// after calibration
int32 CurInputA_UU;
int32 CurInputA_WP;
int32 CurInputA_QP;
int32 CurInputA_SP;
int32 CurInputA_PF;				// PF = P/S

int32 CurInputB_II;				// after calibration
int32 CurInputB_UU;
int32 CurInputB_WP;
int32 CurInputB_QP;
int32 CurInputB_SP;
int32 CurInputB_PF;				// PF = P/S

int32 CurInputC_II;				// after calibration
int32 CurInputC_UU;
int32 CurInputC_WP;
int32 CurInputC_QP;
int32 CurInputC_SP;
int32 CurInputC_PF;				// PF = P/S

/////////////////////////////////////////////////////////////////////////

int32 CurInput_II;				// after calibration
int32 CurInput_UU;
int32 CurInput_WP;
int32 CurInput_QP;
int32 CurInput_SP;
int32 CurInput_PF;				// PF = P/S

int32 CurInputULevel;
int32 CurInputILevel;

int32 CurOutput_I;
int32 CurOutput_U;
int32 CurOutput_WP;
int32 CurOutput_QP;
int32 CurOutput_SP;
int32 CurOutput_PF;

int32 CurOutputULevel;
int32 CurOutputILevel;

extern uint16 Alarm_I_Delta;
extern uint16 Alarm_I_Standard;
extern uint16 Alarm_U_Standard;

extern uint8 Unit1_Addr;
extern uint8 Unit2_Addr;

extern volatile uint16 LD_AlarmCounter;
extern volatile uint16 LD_AlarmEnTimer;
extern volatile uint16 OutReadyTimer;

//volatile uint16 mSecondTick;			// for delay Function
volatile uint32 PPPmSecondTick;
volatile uint8  r_waittingTime0;
volatile uint8  r_waittingTime1;

/////////////////////////////////////////////////////////////////////////////	
void DelayMS_(uint16 dly);
void __irq IRQ_Timer0Serving (void);
void TimerInitialize(void);

void GetCurrent_IUPQRLC(void);
void ADC_Init(void);
void SetDO_ResTime(uint8 do_channel);

/****************************************************************************
** 函数名称 ：DelayMS()		 ;delay 1 mil second 
** 函数功能 ：长软件延时
** 入口参数 ：dly	延时参数，值越大，延时越久
** 出口参数 ：无
****************************************************************************/
void DelayMS_(uint16 dly)
{
	mSecondTick=(dly+1);		//resolution is 1 mS
	while(mSecondTick>1);	
}

/****************************************************************************
** 函数名称 ：IRQ_Timer0Serving()
** 函数功能 ：定时器0中断服务程序，取反LED9控制口。
** 入口参数 ：无
** 出口参数 ：无
*****************************************************************************/
void __irq IRQ_Timer0Serving (void)
{
uint8 i;

	if(mSecondTick!=0)		mSecondTick--;	// ms running,for delay Function
	if(r_waittingTime0!=0) 	r_waittingTime0--;
	if(r_waittingTime1!=0) 	r_waittingTime1--;
	
	PPPmSecondTick++;
	
	if(CommandSendTimer!=0)	CommandSendTimer--;

////
	if(U1_ModeSwitchDly>0)	U1_ModeSwitchDly--;
	if(U2_ModeSwitchDly>0)	U2_ModeSwitchDly--;

////
	for(i=0;i<MAX_DO_CHANNEL;i++){
		if(DO_ResTime[i]>0)  DO_ResTime[i]--;
	}

////
#ifdef POWER_LOST_ALARM						//enable the counter for power detecting in pulse mode.
	if(MP_FailedmSecondCnt <= MAIN_P0WER_FAILED_MSECOND){	//power failed detecting in pulse mode.
		MP_FailedmSecondCnt++;		//power failed detector stop at (MAIN_P0WER_FAILED_MSECOND+1).
	}
#endif

////
	T0IR = 0x01;			/* 清除中断标志*/
	VICVectAddr = 0x00;		/* 通知VIC中断处理结束*/
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void TimerInitialize(void)
{
	IRQDisable();

/* 定时器0初始化 */
	T0TC   = 0;					/* 定时器设置为0						*/
	T0PR   = 0;					/* 时钟不分频							*/
	T0MCR  = 0x03;				/* 设置T0MR0匹配后复位T0TC,并产生中断	*/
	T0MR0  = LPC_FPCLK /1000;	/* 1/1000秒钟定时						*/
	T0TCR  = 0x01;				/* 启动定时器							*/
	
/* 设置定时器0中断IRQ */
	VICVectCntl5 = 0x20|INT_TIMER0;				/* 设置定时器0中断通道分配最高优先级*/
	VICVectAddr5 = (uint32)IRQ_Timer0Serving;	/* 设置中断服务程序地址*/
	VICIntEnable = 1<<INT_TIMER0;				/* 使能定时器0中断*/

	IRQEnable();	
}

//////////////////////////////////////////////////////////////////////////
void ADC_Init(void)
{
	IRQDisable();
	
	PINSEL1=(PINSEL1&(~(0x03<<18)))|(1<<18);	// P0.25连接到AD0.4
	PINSEL1=(PINSEL1&(~(0x03<<20)))|(1<<20);	// P0.26连接到AD0.5

	PINSEL1=(PINSEL1&(~(0x03<<22)))|(1<<22);	// P0.27连接到AD0.0
	PINSEL1=(PINSEL1&(~(0x03<<24)))|(1<<24);	// P0.28连接到AD0.1
	
	PINSEL1=(PINSEL1&(~(0x03<<26)))|(1<<26);	// P0.29连接到AD0.2
	PINSEL1=(PINSEL1&(~(0x03<<28)))|(1<<28);	// P0.30连接到AD0.3

	PINSEL0=(PINSEL0&(~(0x03<< 8)))|(0x3<< 8);	// P0.04连接到AD0.6
	PINSEL0=(PINSEL0&(~(0x03<<10)))|(0x3<<10);	// P0.05连接到AD0.7

	IRQEnable();
}

////////////////////////////////////////////////////////////////////////	
//  int32 MB_Read_E_Data(uint8 channel,uint16 addr)
//	rIa rIb rIc rIt rUa rUb rUc rPa
//	rPb rPc rPt rQa rQb rQc rQt
// 	rSa rSb rSc rSt rPfa rPfb rPfc rPft
////////////////////////////////////////////////////////////////////////	
void GetCurrent_IUPQRLC(void)
{
#ifdef EN_LOAD_ALARM
static uint16 OverDeltaTimes=0;
#endif

		if((U1U2_ReadyTimer!=0)||(GetCurrentDataTick!=0)) return;
		GetCurrentDataTick=5;

		CurInputA_II = MB_Read_E_Data(Unit2_Addr,rIa);
		CurInputA_UU = MB_Read_E_Data(Unit2_Addr,rUa);
		CurInputA_WP = MB_Read_E_Data(Unit2_Addr,rPa);
		CurInputA_QP = MB_Read_E_Data(Unit2_Addr,rQa);
		CurInputA_SP = MB_Read_E_Data(Unit2_Addr,rSa);
		CurInputA_PF = MB_Read_E_Data(Unit2_Addr,rPfa);

////////////////////////////////////////////////////////////////////////	
////////////////////////////////////////////////////////////////////////	
		CurInputB_II = MB_Read_E_Data(Unit2_Addr,rIb);
		CurInputB_UU = MB_Read_E_Data(Unit2_Addr,rUb);
		CurInputB_WP = MB_Read_E_Data(Unit2_Addr,rPb);
		CurInputB_QP = MB_Read_E_Data(Unit2_Addr,rQb);
		CurInputB_SP = MB_Read_E_Data(Unit2_Addr,rSb);
		CurInputB_PF = MB_Read_E_Data(Unit2_Addr,rPfa);

////////////////////////////////////////////////////////////////////////		
////////////////////////////////////////////////////////////////////////	
		CurInputC_II = MB_Read_E_Data(Unit2_Addr,rIc);
		CurInputC_UU = MB_Read_E_Data(Unit2_Addr,rUc);
		CurInputC_WP = MB_Read_E_Data(Unit2_Addr,rPc);
		CurInputC_QP = MB_Read_E_Data(Unit2_Addr,rQc);
		CurInputC_SP = MB_Read_E_Data(Unit2_Addr,rSc);
		CurInputC_PF = MB_Read_E_Data(Unit2_Addr,rPfc);

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
		if(CurInputA_WP<0) CurInputA_WP=-CurInputA_WP;
		if(CurInputA_QP<0) CurInputA_QP=-CurInputA_QP;
		if(CurInputA_PF<0) CurInputA_PF=-CurInputA_PF;

		if(CurInputB_WP<0) CurInputB_WP=-CurInputB_WP;
		if(CurInputB_QP<0) CurInputB_QP=-CurInputB_QP;
		if(CurInputB_PF<0) CurInputB_PF=-CurInputB_PF;

		if(CurInputC_WP<0) CurInputC_WP=-CurInputC_WP;
		if(CurInputC_QP<0) CurInputC_QP=-CurInputC_QP;
		if(CurInputC_PF<0) CurInputC_PF=-CurInputC_PF;

	
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
	
		CurInput_II = CurInputA_II;		CurInput_UU = CurInputA_UU;
		CurInput_WP = CurInputA_WP;		CurInput_QP = CurInputA_QP;
		CurInput_SP = CurInputA_SP;		CurInput_PF = CurInputA_PF;
		CurInputULevel++;				CurInputILevel++;

		CurOutput_I  = CurInputA_II;	CurOutput_U  = CurInputA_UU;
		CurOutput_WP = CurInputA_WP;	CurOutput_QP = CurInputA_QP;
		CurOutput_SP = CurInputA_SP;	CurOutput_PF = CurInputA_PF;
		CurOutputULevel++;				CurOutputILevel++;
		
//////////////////////////////////////////////////////////////////////////////
//// alarm bits setting area,	//uint16 StateValue;
//	if(((StateValue&LIGHT_ON_FLG_BIT)==LIGHT_ON_FLG_BIT)&&(OutReadyTimer==0)){
	if(OutReadyTimer==0){

//   attach light state; SP>200/10=20VA, set LIGHT_ON_FLG_BIT.
		if(CurInput_SP >200){	StateValue = StateValue|  LIGHT_ON_FLG_BIT ;}
		else{					StateValue = StateValue&(~LIGHT_ON_FLG_BIT);}
//   I alarm
		if(CurInput_II < I_ALARM_LOW_LIMIT){	StateValue = StateValue|  IIII__ALARM_TYPE; }
		else{									StateValue = StateValue&(~IIII__ALARM_TYPE);}
//   U alarm
		if(CurInput_UU < U_ALARM_LOW_LIMIT){	StateValue = StateValue|  UUUU__ALARM_TYPE; }
		else{									StateValue = StateValue&(~UUUU__ALARM_TYPE);}
//   PF alarm
		if(CurInput_PF < PF_ALARM_LOW_LIMIT){	StateValue = StateValue|  PFPF__ALARM_TYPE; }
		else{									StateValue = StateValue&(~PFPF__ALARM_TYPE);}

//   load alarm	
//
#ifdef EN_LOAD_ALARM
		if((CurOutput_U < (Alarm_U_Standard+100))&&		//Alarm_U_Standard -/+ 10.0V
		   (CurOutput_U > (Alarm_U_Standard-100))){

			if (((uint16)CurOutput_I < (Alarm_I_Standard-Alarm_I_Delta))||
				((uint16)CurOutput_I > (Alarm_I_Standard+Alarm_I_Delta))){

				if(OverDeltaTimes==0) DB_SendString("System go into AlarmState");
				if(OverDeltaTimes<=OVER_DELTA_TRIGGER_LEVEL) OverDeltaTimes++;
			   	if(OverDeltaTimes>=OVER_DELTA_TRIGGER_LEVEL) StateValue=StateValue|LOAD__ALARM_TYPE;
			}else{
		
				if(OverDeltaTimes!=0) DB_SendString("System recover from AlarmState");
				OverDeltaTimes=0;
				StateValue = StateValue&(~LOAD__ALARM_TYPE);
			}
		}
#else
		StateValue = StateValue&(~LOAD__ALARM_TYPE);
#endif
	}

}

///////////////////////////////////////////////////////////////////////////
void SetDO_ResTime(uint8 do_channel)
{

//char dbuff[100];
/*
	sprintf(dbuff,"SetDO_ResTime(), channel=%d",channel); 
	DB_SendString(dbuff);
*/
	if(do_channel<MAX_DO_CHANNEL){

		if(DO_ResTime[do_channel]==0){
			DO_ResTime[do_channel]=DO_HoldingTime;
		}

	}else{

		DB_SendString("SetDO_ResTime: DO channel out of range.");

	}

/*
	sprintf(dbuff, "DO_ResTime[0]=%d,DO_ResTime[1]=%d,DO_ResTime[2]=%d,DO_ResTime[3]=%d",
					DO_ResTime[0],   DO_ResTime[1],   DO_ResTime[2],   DO_ResTime[3]); 
	DB_SendString(dbuff);
*/
}

//////////////////////////////////////////////////////////////////////////
// end of file //