drv_lamp.c

CC1000 Rf modem C codes for philips sLpc213X ARM MCU.

#include "config_GD61.h"
#include "include_GD61.h"
#include <stdio.h>

////////////////////////////////////////////////////////////////////
uint16 TestDrvState;

extern CALENDAR CurrentTime;

extern uint8 AutoLightCntMode;
extern uint8 MaxInputIICnt;

extern uint16 TransferKKK;

extern volatile uint16 mSecondTick;
extern volatile uint16 LD_AlarmCounter;
extern volatile uint16 PW_AlarmCounter;
extern volatile uint8  TestSecondTick;

////////////////////////////////////////////////////////////////////
void LampPinTOInput(void);
void LampPinInitialize(void);

void LampStateRelative(int16 DriveValue);
void LampStateAbs(uint16 DriveValue);

void RestoreLightState(void);

void U_ChannelTest(void);
void DL1_RelayTest(void);
void DK_RelayTest(void);
void LightLoopTest(void);

void  Rel_DQ_toOFF(void);							//control DQ off 
void  Rel_DQ_toON(void);							//control DQ on	

void  Cha_DQ_toOFF(void);							//change  DQ off 
void  Cha_DQ_toON(void);							//control DQ on	

void  Rel_DK_toOFF(void);
void  Rel_DK_toON(void);

void  ForceLampState(uint16 DriveValue);
void _ForceLampState(uint16 DriveValue);
void PreForceDKxState(uint16 DriveValue);
void PreToLightOn(void);

//void InputPinTest(void);
void OutputPinTest(void);
void SynZeroPoint(void);


///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
uint8 VoltageState[]={

//		0          1          2          3          4
		Minus_58V0,Minus_56V0,Minus_54V0,Minus_52V0,Minus_50V0,
//		5          6          7          8          9
		Minus_48V0,Minus_46V0,Minus_44V0,Minus_42V0,Minus_40V0,	// 2
//		10         11         12         13         14
		Minus_38V0,Minus_36V0,Minus_34V0,Minus_32V0,Minus_30V0,	// 3
//		15         16         17         18         19
		Minus_28V0,Minus_26V0,Minus_24V0,Minus_22V0,Minus_20V0,	// 1
//		20         21         22         23         24
		Minus_18V0,Minus_16V0,Minus_14V0,Minus_12V0,Minus_10V0,	// 2
//		25         26         27         28         29
		Minus_08V0,Minus_06V0,Minus_04V0,Minus_02V0,Minus_00V0,	// 3

		};

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
void LampPinTOInput(void)
{
//set pin to input	mode
	IO0DIR=IO0DIR&
				(~DK4_P0_04)&
				(~DK2_P0_05)&
				(~DK1_P0_06)&
				(~DQ__P0_07)&				
				(~EEP_P0_9)&		
				(~RSSI_IF_P0_27)&	// only for module test. 
				(~DL__P0_28);
////
	IO1DIR=IO1DIR&	
				(~DH__P1_16)&
				(~DL1_P1_17)&
				(~DK__P1_24)&
				(~DK3_P1_25)&
				(~DK5_P1_26)&
				(~LED_P1_21)&
				(~DT__P1_31);	// ok
}

///////////////////////////////////////////////////////////////////
void LampPinInitialize(void)
{
//set pin to out mode
#ifdef INCLUDE_LAMP_CON

//	PINSEL0 = 0;
//	PINSEL1 = 0;

	PINSEL2 = PINSEL2&(~0x08);	// P1 [25:16] serve as GPIO
	PINSEL2 = PINSEL2&(~0x04);	// P1 [31:26] serve as GPIO

////
	IO0DIR=IO0DIR
				|DK4_P0_04
				|DK2_P0_05
				|DK1_P0_06
				|DQ__P0_07
				|EEP_P0_9
				|DL__P0_28;
////
	IO1DIR=IO1DIR
				|DH__P1_16
				|DL1_P1_17
				|DK__P1_24
				|DK3_P1_25
				|DK5_P1_26
				|LED_P1_21
				|DT__P1_31;
////
	IO0DIR=IO0DIR&
				(~PW_INT_P0_15)&				
				(~RSSI_IF_P0_27);

////

	IO0SET=EEP_P0_9;	// eeprom write_protection pin
//	IO0SET=_PWM_P0_21;	// only for module test. 
	IO1SET=DL1_P1_17;	// turn on  DL1 relay
	IO1SET=DK__P1_24;	// turn off DK  relay
	

#endif	// INCLUDE_LAMP_CON
}

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
void LampStateRelative(int16 DriveValue)
{
uint16 buff;
int16  CurState;

//// get the current position
	buff = StateValue & 0x00ff;
	
	if(buff<=Minus_vMAX){
		CurState = Minus_vMAX - buff;
	}else{
		Uart0SendString("LampStateRelative,unknown case");
		LampStateAbs(Minus_00V0);	//unknown case
		return;
	}

//// get the executing position
	CurState = CurState + DriveValue;
	
//// relay switching	
	Uart0SendString("LampStateRelative");
	
	if(CurState<Minus_00V0){		//over adjust
		LampStateAbs(Minus_vMAX);
	}else if(CurState>Minus_vMAX){
		LampStateAbs(Minus_00V0);
	}else{
		LampStateAbs(VoltageState[CurState]);
	}
}

///////////////////////////////////////////////////////////////////
void LampStateAbs(uint16 DriveValue)
{
char dbuffer[100];

	sprintf(dbuffer,"LampStateAbs() Changes state to 0x%x",DriveValue); 
	Uart0SendString(dbuffer);

////
	if((((StateValue & LIGHT_ON_FLG_BIT)==LIGHT_ON_FLG_BIT)&&(DriveValue==(StateValue & 0x00ff)))||
	   (((StateValue & LIGHT_ON_FLG_BIT)==0x0000)		   &&(DriveValue==Light_toOFF))){

 		Uart0SendString("Keep state");

	}else{
		ForceLampState(DriveValue);		//switch action
	}
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
void RestoreLightState(void)
{
#ifdef INCLUDE_LAMP_CON						//>>>(1) light control function

uint16 databuf;
///////////////	warm boot ///////////////////////////////////////////////////
	if((POWERUP_FLAG1==WARM_START_FLAG1)&&(POWERUP_FLAG2==WARM_START_FLAG2)){

		if((StateValue & LIGHT_ON_FLG_BIT)==LIGHT_ON_FLG_BIT){
//// turn light ON
			databuf = StateValue & 0x00ff;
			if(databuf <= Light_toON){

				_ForceLampState(databuf);		//force to the state before reset
				if(((RSIR & WDTR_RESET) == WDTR_RESET)||((RSIR & EXTR_RESET) == EXTR_RESET)){
					Uart0SendString("WatchDog/ResetPIN reset,Restore light state.");

				}else{							//POWR_RESET	//BODR_RESET
					Uart0SendString("BODR_RESET/POWR_RESET,Restore light state.");
				}

			}else{	//databuf > Light_toON
				_ForceLampState(Light_toOFF);
				Uart0SendString("Warm Boot,Force light OFF in unknown case.");
			}
		}
		else{
//// turn light OFF
			_ForceLampState(Light_toOFF);
			Uart0SendString("Warm Boot,Restore light OFF");
		}
	}
	
///////////////////////// cold boot //////////////////////
	else{
//all light control pins switch off
		_ForceLampState(Light_toOFF);
		Uart0SendString("Cold Boot,Force light OFF.");
				
//enable alarm sending
		LD_AlarmCounter=0;	//enable alarm message sending
		PW_AlarmCounter=0;
	
//set the initialization state
		AutoVoltageFlag	= 0;
		AutoVoltageTimer= 0;
		TargetVoltage	= 0;
		
//initialize the measuring data
		CurInput_II		= 0;		CurInput_UU		= 0;
		CurInput_WP		= 0;		CurInput_QP		= 0;
		CurInput_SP		= 0;		CurInput_PF		= 0;

		CurInputULevel	= 0;		CurInputILevel	= 0;

		CurOutput_I		= 0;		CurOutput_U		= 0;
		CurOutput_WP	= 0;		CurOutput_QP	= 0;
		CurOutput_SP	= 0;		CurOutput_PF	= 0;

		CurOutputULevel	= 0;		CurOutputILevel	= 0;		
	}

#endif	//#ifedf INCLUDE_LAMP_CON	//>>>(1) light control function
}

///////////////////////////////////////////////////////////////////
//////////////////////////////////////////////// SYNCHRO_CYCLE_NUM

void SynZeroPoint(void)
{	
uint32 tp1,tp2;
	StateValue = StateValue&(~SYNC__ALARM_TYPE);	//clr alarm bit
	if((IO1PIN&DK__P1_24)==DK__P1_24) 	//set DK on
	{	
		WatchDogClear();		
		IO1CLR=DK__P1_24;
		DelayMS_(SWITCH_DELAY_TIME);
		WatchDogClear();		
	}
	
#ifdef EN_SYNCHRO_MAIN_POWER


	PINSEL0   	= PINSEL0 & 0x3fffffff;	// set p0.15 as gpio
	mSecondTick = 20*SYNCHRO_CYCLE_NUM;	// waitting for SYNCHRO_CYCLE_NUM cycles at most

	tp2 = IO0PIN & PW_INT_P0_15;
	do{
		tp1 = tp2;
		tp2 = IO0PIN & PW_INT_P0_15;
	#ifdef SYNCHRO_MAIN_POWER_FALLING
		if((tp1==PW_INT_P0_15)&&(tp2==0)) break ;
	#else
		if((tp1==0)&&(tp2==PW_INT_P0_15)) break ;
	#endif
	}while(mSecondTick>1);	

	if(mSecondTick<=1){
		StateValue = StateValue|SYNC__ALARM_TYPE;	//set alarm bit if syn failed
		Uart0SendString("synchronization(3) failed");
	}

	IRQDisable();
	EINT2_Initialize();		//restore PW_INT_P0_15 to interrupt mode	
	IRQEnable();

#endif

}

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

void U_ChannelTest(void)
{
static uint8 U_State_buff=0;

	if(U_State_buff==0){
		Uart0SendString("DT_P1_31(toInPut)");	
		RF_SendString("DT_P1_31(toInPut)");
		IO1CLR=DT__P1_31;	//measure input voltage
		U_State_buff=1;
	}else{
		Uart0SendString("DT_P1_31(toOutPut)");	
		RF_SendString("DT_P1_31(toOutPut)");
		IO1SET=DT__P1_31;	//measure output voltage
		U_State_buff=0;
	}
}

////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
void DL1_RelayTest(void)
{
static uint8 DL1_buff=0;
	
	if(DL1_buff==0){
		Uart0SendString("DL1_P1_17(toON)");	
		RF_SendString("DL1_P1_17(toON)");
		IO1SET=DL1_P1_17;
		DL1_buff=1;
	}else{
		Uart0SendString("DL1_P1_17(toOFF)");	
		RF_SendString("DL1_P1_17(toOFF)");
		IO1CLR=DL1_P1_17;
		DL1_buff=0;
	}
}

////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
void DK_RelayTest(void)
{
static uint8 DK_buff=0;

	if(DK_buff==0x0){
		Uart0SendString("DK_P1_24(toOFF)");	
		RF_SendString("DK_P1_24(toOFF)");
		IO1SET=DK__P1_24;	//toOFF
		DK_buff=1;
	}else{
		Uart0SendString("DK_P1_24(toON)");	
		RF_SendString("DK_P1_24(toON)");
		IO1CLR=DK__P1_24;	//toON
		DK_buff=0;
	}
}

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
void TurnOff_DQ_DH_DL(void)
{
	Uart0SendString("turn off DQ/DH/DL");
	RF_SendString("turn off DQ/DH/DL");
	WatchDogClear();		//clr watchdog
	SynZeroPoint();
	
	IO0SET=DQ__P0_07;		//set DQ off
	IO1SET=DH__P1_16 ;		//set DH off
	IO0SET=DL__P0_28;		//set DL off
	WatchDogClear();		//clr watchdog
	DelayMS_(2000);
}

//////////////////////////////////////////////////////////////////
void TestPowerSwitch(void)
{
	Uart0SendEnter(); 	Uart0SendString("PowerSwitch testing...");	
	RF_SendEnter();		RF_SendString("PowerSwitch testing...");

//turn off all switch
	TurnOff_DQ_DH_DL();
//turn on DH,test DH
	Uart0SendString("turn on DH");	RF_SendString("turn on DH");
	WatchDogClear();		//clr watchdog
	SynZeroPoint();

	IO0SET=DQ__P0_07;		//set DQ off
	IO1CLR=DH__P1_16 ;		//set DH on
	IO0SET=DL__P0_28;		//set DL off

	WatchDogClear();				//clr watchdog	
	DelayMS_(1000);

//turn off all switch
	TurnOff_DQ_DH_DL();
//turn on DL,test DL
	Uart0SendString("turn on DL");	RF_SendString("turn on DL");	
	WatchDogClear();		//clr watchdog
	SynZeroPoint();

	IO0SET=DQ__P0_07;		//set DQ off
	IO1SET=DH__P1_16 ;		//set DH off
	IO0CLR=DL__P0_28;		//set DL on 

	WatchDogClear();				//clr watchdog
	DelayMS_(1000);

//turn off all switch
	TurnOff_DQ_DH_DL();
//turn on DQ,test DQ
	Uart0SendString("turn on DQ");	RF_SendString("turn on DQ");
	WatchDogClear();		//clr watchdog
	SynZeroPoint();

	IO0CLR=DQ__P0_07;		//set DQ  on
	IO1SET=DH__P1_16 ;		//set Q3 off
	IO0SET=DL__P0_28;		//set Q4 off

	WatchDogClear();		//clr watchdog
	DelayMS_(2000);
	
//turn off all switch
	TurnOff_DQ_DH_DL();
//test K1
	WatchDogClear();		//clr watchdog
	SynZeroPoint();
	LampStateAbs(Minus_02V0);		RF_SendString("Minus_02V0");

	WatchDogClear();		//clr watchdog
	DelayMS_(2000);
	
//turn off all switch
	TurnOff_DQ_DH_DL();
//test K2
	WatchDogClear();		//clr watchdog
	SynZeroPoint();
	LampStateAbs(Minus_04V0);		RF_SendString("Minus_04V0");

	WatchDogClear();		//clr watchdog
	DelayMS_(2000);
		
//turn off all switch
	TurnOff_DQ_DH_DL();
//test K3
	WatchDogClear();		//clr watchdog
	SynZeroPoint();
	LampStateAbs(Minus_08V0);		RF_SendString("Minus_08V0");
	
	WatchDogClear();		//clr watchdog	
	DelayMS_(2000);
	
//turn off all switch
	TurnOff_DQ_DH_DL();
//test K4
	WatchDogClear();		//clr watchdog
	SynZeroPoint();
	LampStateAbs(Minus_16V0);		RF_SendString("Minus_16V0");

	WatchDogClear();		//clr watchdog
	DelayMS_(2000);

//turn off all switch
	TurnOff_DQ_DH_DL();
//test K5
	WatchDogClear();		//clr watchdog
	SynZeroPoint();
	LampStateAbs(Minus_32V0);		RF_SendString("Minus_32V0");

	WatchDogClear();		//clr watchdog
	DelayMS_(2000);
	
//turn off all switch
	TurnOff_DQ_DH_DL();
	IO1SET = DK__P1_24;		//turn off DK relay
	DelayMS_(SWITCH_DELAY_TIME);

	Uart0SendString("Test over");	RF_SendString("Test over");
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
void LightLoopTest(void)
{

char dbuffer[100];

	if((TestDrvState>(Minus_vMAX*2))||(TestSecondTick!=0)) return;

////
	     if(TestDrvState<=Minus_vMAX)