task_alarm.c

CC1000 Rf modem C codes for philips sLpc213X ARM MCU.

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

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

uint16 AlarmSenderAddr1;
uint16 AlarmSenderAddr2;
uint16 AlarmSenderAddr3;
uint16 AlarmSenderAddr4;
uint32 RF_intensity;
uint16 Get_RSSIIF_Counter;
volatile uint8  PW_FLAG=0;


////////////////////////////////////////////////////////////////
extern uint16 ModuleAddress;	//=0x5555;		//module address.
extern uint16 AlarmHostAddress;	//Host address, for alarm system

extern uint16 SourceAddr;		//source address.
extern uint16 DestinationAddr;	//destination address.

extern uint16 Pkg_SerialNum;	//serial number of package.
extern uint8  RoutingFlag;		//function code.

extern uint8  ActionCode;		//action code just like function code.
extern uint8  ActionValueLen;	//action value corresponding to action code.
extern uint16 ActionValue;		//action value (corresponding to action code)

extern uint8  AlarmInfoSendCnt;
extern volatile uint16 mSecondTick;		// for delay function
extern volatile uint16 RSSIF_mSecondTick;		// for delay function


////////////////////////////////////////////////////////////////
extern ROUTEDATA routeData[MAX_BRANCH_LINE_NUM];	//there is a routedata for each branchLine.
extern volatile uint16 PW_AlarmEnTimer;
extern volatile uint16 LD_AlarmEnTimer;
extern volatile uint16 PW_AlarmCounter;
extern volatile uint16 LD_AlarmCounter;
extern volatile uint16 MP_FailedmSecondCnt;			// for main power failed detector

////////////////////////////////////////////////////////////////
void TbufAlarmMsg(void);				//make alarm message frame
void AlarmFunction(void);
void RestoreDeviceState(void);
void GetRF_intensity(void);

////////////////////////////////////////////////////////////////
//
void GetRF_intensity(void)
{
//	RF_intensity=1024/3;
////get RSSI_IF sample
	PINSEL1=(PINSEL1&(~(0x03<<22)))|(1<<22);	// P0.27连接到AD0.0
	AD0CR  =(1 << 0)						|	// SEL=0,选择通道0
			((LPC_FPCLK / 3000000 - 1) << 8)	|	// CLKDIV=LPC_FPCLK/3000000-1,转换时钟为1MHz
			(0 << 16)						|	// BURST=0,软件控制转换操作
			(0 << 17)						|	// CLKS=0, 使用11clock转换
			(1 << 21)						|  	// PDN=1,正常工作模式
			(0 << 22)						|  	// TEST1:0=00,正常工作模式
//			(1 << 24)						|	// START=1,直接启动ADC转换
			(0 << 27);						 	// 直接启动ADC转换时，此位无效

	AD0CR |= 1 << 24 ;						// 进行第一次转换
	while((AD0DR & 0x80000000) == 0);		// 等待转换结束		
	AD0CR |= 1 << 24;						// 再次启动转换
	while((AD0DR & 0x80000000) == 0);		// 等待转换结束
	RF_intensity=(AD0DR>>6)&0x3ff;			// 读取ADC结果		
	RF_intensity=RF_intensity*3000/1024;

}

////////////////////////////////////////////////////////////////
//
void GetAlarmSenderAddr(void)
{
char dbuf[100];

////
	if((ActionCode == 0x3)&&(ActionValueLen == 0x2)){
////
		Uart0SendString("GetAlarmSenderAddr()");
////
		if((AlarmSenderAddr1==SourceAddr)||
		   (AlarmSenderAddr2==SourceAddr)||
		   (AlarmSenderAddr3==SourceAddr)||
		   (AlarmSenderAddr4==SourceAddr)||
		   (ModuleAddress   ==SourceAddr)){
		   Uart0SendString("have caught AlarmSenderAddr before");
		   return;
		}
////
		if(AlarmSenderAddr1==0){
			AlarmSenderAddr1=SourceAddr;
			AlarmInfoSendCnt=ALARM_INFO_SENDING_TIMES;
			Uart0SendString("catch AlarmSenderAddr in buffer1");
		}
		else if(AlarmSenderAddr2==0){
			AlarmSenderAddr2=SourceAddr;
			AlarmInfoSendCnt=ALARM_INFO_SENDING_TIMES;			
			Uart0SendString("catch AlarmSenderAddr in buffer2");
		}
		else if(AlarmSenderAddr3==0){
			AlarmSenderAddr3=SourceAddr;
			AlarmInfoSendCnt=ALARM_INFO_SENDING_TIMES;
			Uart0SendString("catch AlarmSenderAddr in buffer3");
		}
		else if(AlarmSenderAddr4==0){
			AlarmSenderAddr4=SourceAddr;
			AlarmInfoSendCnt=ALARM_INFO_SENDING_TIMES;
			Uart0SendString("catch AlarmSenderAddr in buffer4");
		}
		else {
		Uart0SendString("warning: AlarmSenderAddr buffer full");
		}
////
		sprintf(dbuf,"SendCnt=%d,_Addr1=0x%x,_Addr2=0x%x,_Addr3=0x%x,_Addr4=0x%x",
	 		    AlarmInfoSendCnt,AlarmSenderAddr1,AlarmSenderAddr2,AlarmSenderAddr3,AlarmSenderAddr4);
		Uart0SendString(dbuf);
	}
}

////////////////////////////////////////////////////////////////
//
void RestoreDeviceState(void)
{
	InitializeDevice();
	KillRelayPackage();
	SysInitGD61();

	RF_StartCC1000();
	RFtoRXmode();			// release RF channel

	GetSysConfig();			// read data from EEprom

#ifdef ENABLE_LPC_WATCHDOG
	WatchDog_Start(5000);	// 5000 ms Watchdog reset time
#endif  // ENABLE_LPC_WATCHDOG

}

////////////////////////////////////////////////////////////////
//
void TbufAlarmMsg(void)	//make alarm message frame
{
uint8 index;
uint8 branch_id;

	DestinationAddr	=AlarmHostAddress;	//source address(GD60)
	SourceAddr		=ModuleAddress;		//destination address
	RoutingFlag		=0x80;				//change the direction
	Pkg_SerialNum ++;					//change the Pkg_SerialNum

//Byte1:  =  Relay position，please refer to [1] (1).
//Byte2:
//bit0___ I alarm flag;						bit1___ U alarm flag;
//bit2___ PF alarm flag;					bit3___ unused;
//bit4___ load alarm flag;					bit5___ relay package failed flag;
//bit6___ Main_Power supply failed flag;	bit7___ light ON/OFF flag;

////data to be relay
	for(branch_id=0;branch_id<MAX_BRANCH_LINE_NUM;branch_id++){
		index=0;
		routeData[branch_id].datax[index++]= INQUIRE_STATE;
		routeData[branch_id].datax[index++]= 2;

//attached Main_Power supply failed flag
		routeData[branch_id].datax[index++]= (uint8)(StateValue>>8);
		routeData[branch_id].datax[index++]= (uint8) StateValue;
		routeData[branch_id].byteCounter=4;
	}
}

////////////////////////////////////////////////////////////////
void AlarmFunction(void)
{

#ifdef EN_MAIN_POWER_ALARM
uint32 delay;

	
//	if(((IO0PIN&PW_INT_P0_15)==PW_INT_P0_15)&&
//		(PW_AlarmEnTimer==0)&&
//		(PW_AlarmCounter<=ALARM_INFO_SENDING_TIMES)){	//level detecting mode

	if( (MP_FailedmSecondCnt>=MAIN_POWER_FAILED_MSECOND)&&
		(PW_AlarmEnTimer==0)&&
		(PW_AlarmCounter<=ALARM_INFO_SENDING_TIMES)){	//pulse detecting mode
		
		PW_FLAG=1;				//屏蔽电压电流采样

		PW_AlarmEnTimer = 60;	//60 seconds, send alarm message again
		PW_AlarmCounter++;

		StateValue = StateValue|POWER_ALARM_TYPE;

		if(PW_AlarmCounter<=(ALARM_INFO_SENDING_TIMES-3)){
			LampPinTOInput();		//set control pins to input mode
			Uart0SendString("LampPinTOInput");
		}else{
			LampPinInitialize();
			RestoreLightState();	//restore the light state and clr all alarm bits.
			Uart0SendString("[1]LampPinInitialize,[2]RestoreLightState");
		}
		
		delay=(ModuleAddress%5)*1250 + 20;	//sending alarm message according to ModuleAddress		
#ifdef ENABLE_LPC_WATCHDOG
		WatchDog_Start(delay+2000);			// 9000 ms Watchdog reset time
#endif  // ENABLE_LPC_WATCHDOG

		DelayMS_(delay);

#ifdef ENABLE_LPC_WATCHDOG
		WatchDog_Start(5000);				// 5000 ms Watchdog reset time
#endif  // ENABLE_LPC_WATCHDOG
	
		RF_SendingOver();
		
		for(Get_RSSIIF_Counter=1;Get_RSSIIF_Counter<RSSIIF_Counter;Get_RSSIIF_Counter++)
		{	
			WatchDogClear();
			GetRF_intensity();
			RSSIF_mSecondTick=50;
			while((RF_intensity>RF_INTENSITY_LEVEL)&&(RSSIF_mSecondTick>0))
			{
				GetRF_intensity();
			}
			if((RSSIF_mSecondTick==0)&&(RF_intensity>RF_INTENSITY_LEVEL))
			{
		//		sprintf(dbuffer,"%d:the line is idle,the voltage is %d",Get_RSSIIF_Counter,RF_intensity);	
		//		Uart0SendString(dbuffer);
		//		RSSIF_mSecondTick=500;
		//		while(RSSIF_mSecondTick>1);
				break;
			}
			RSSIF_mSecondTick=500;
			while((RF_intensity<RF_INTENSITY_LEVEL)&&(RSSIF_mSecondTick>1))
			{
				GetRF_intensity();
			}
		//	sprintf(dbuffer,"%d:the line is busy,the voltage is %d",Get_RSSIIF_Counter,RF_intensity);	
		//	Uart0SendString(dbuffer);
		}
	
		TbufAlarmMsg();	//fill routeData[]//source & destination address//set routing direction
		MakeRelayPackage(KEEP_ROUTE_DIR);
		Uart0SendString("Sending power_failure alarm message");
		Uart0SendEnter();
	}

////////
//	else if(((IO0PIN&PW_INT_P0_15)!=PW_INT_P0_15)  &&(PW_AlarmEnTimer!=0)){	//level detecting mode
/*
	else if((MP_FailedmSecondCnt<MAIN_POWER_FAILED_MSECOND)&&(PW_AlarmEnTimer!=0)){	//pulse detecting mode

		Uart0SendString("Reset from AlarmFunction");
		Uart0SendingOver();
		WatchDog_Start(10);	//10 ms Watchdog reset time
		while(1);			//wait for watchdog reset
*/		


	else if((MP_FailedmSecondCnt<MAIN_POWER_FAILED_MSECOND)&&(PW_FLAG==1)){	//pulse detecting mode
	
	//	StateValue = StateValue&(~POWER_ALARM_TYPE);
		Uart0SendString("Reset from AlarmFunction");
		Uart0SendingOver();
		WatchDog_Start(10);	//10 ms Watchdog reset time
		while(1);
		
/*
		
		LampPinInitialize();
		RestoreLightState();	//restore the light state and clr all alarm bits.
		InitializeDevice();
//		KillRelayPackage();
		Uart0SendEnter();
		Uart0SendString("Recover control pins into output mode");
		Uart0SendString("[1]RestoreLightState,[2]InitializeDevice");
		PW_AlarmCounter=0;
		PW_AlarmEnTimer=0;		//main power supply is ok		
*/		
	}
//	if(MP_FailedmSecondCnt<MAIN_POWER_FAILED_MSECOND) StateValue = StateValue&(~POWER_ALARM_TYPE);
#endif	

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#ifdef EN_LOAD_ALARM
	if(((StateValue&LOAD__ALARM_TYPE)==LOAD__ALARM_TYPE)&&
		(LD_AlarmEnTimer==0)&&
		(LD_AlarmCounter<=ALARM_INFO_SENDING_TIMES)){	//pulse detecting mode

			LD_AlarmCounter++;
			LD_AlarmEnTimer = 60;	//60 seconds, send alarm message again

			RF_SendingOver();
			TbufAlarmMsg();			//fill routeData[]//source & destination address//set routing direction

			MakeRelayPackage(KEEP_ROUTE_DIR);
			PrintAlarmInfo();
			Uart0SendString("Sending load_failure alarm message");
			Uart0SendEnter();
	}
#endif
}



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