drv_exint.c

CC1000 Rf modem C codes for philips sLpc213X ARM MCU.

////////////////////////////////////////////////////////////////////////////
#include "config_GD61.h"
#include "include_GD61.h"

///////////////////////////////////////////////////////////////////////////
extern char TxCurrent;
extern char RxCurrent;
extern char RF_RxPll;
extern char RF_TxPll;

extern volatile uint16 r_inp0,r_outp0,r_count0;
volatile uint8  CC1000Mode;
volatile uint8  RF_RxSynSemaphore;	
volatile uint32 RF_Rx_PreHead;		  			// equal to 0xAAAAAAAA 

volatile uint8  RF_ActiveFlag;
volatile uint8  RF_Rx_Buffer[RX_BUFFER_LEN];			// UART1 receiving buffer
volatile uint8  RF_Tx_Buffer[TX_BUFFER_LEN];			// UART1 sending buffer
volatile uint16 RFr_inp=0,RFr_outp=0,RF_RxCounter=0;
volatile uint16 RFt_inp=0,RFt_outp=0,RF_TxCounter=0;

volatile uint8  RF_TxBitCounter=0;	// bit pointer of data_byte in sending
volatile uint8  RF_RxBitCounter=0;	// bit pointer of data_byte in sending

volatile uint8  RF_SendingBuf;
volatile uint8  RF_ReceivingBuf;

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

void __irq IRQ_Eint0Serving (void);
void EINT0_Initialize(void);

/*************************************************************************
** 函数名称 ：IRQ_Eint0Serving()
** 函数功能 ：外部中断0 EINT0服务程序口。
*************************************************************************/
void __irq IRQ_Eint0Serving (void)
{

uint32 tp1,tp2;
uint8  buff;
static uint8 frameByteCnt=0;
////
///
	PINSEL1 = PINSEL1& 0xfffffffc; 		// set p0.16 as GPIO
	IO0DIR  = IO0DIR & ~PIN_EINT0;		// set p0.16 into input mode

	tp1 = IO0PIN   & PIN_EINT0;			// sampling the pin level
	tp2 = EXTPOLAR & 0x00000001;		// 设置EINT0为 raiseing edge 触发

/////////////////////////////////////////////////////////////////////////
// raising edge, receiving mode
	if((tp1==PIN_EINT0)&&(tp2==1)){
		if(CC1000Mode==RFinRX_MODE){		//in receiving mode
			IO0DIR  = IO0DIR&(~CC_DIO__P0_20);	// CC_DIO__P0_20 serve as inpin
			
			tp1		= IO0PIN & CC_DIO__P0_20;		// get the input bit
			switch(RF_RxSynSemaphore){
//////////////////////////////////////////////////			
// WAIT_SYN_F state
				case WAIT_SYN_F:
					RF_Rx_PreHead = RF_Rx_PreHead<<1;					//get a bit
					if(tp1==CC_DIO__P0_20){
						RF_Rx_PreHead = RF_Rx_PreHead&(~0x00000001);	//reverse the bit polarity
					}
					else{
						RF_Rx_PreHead = RF_Rx_PreHead|0x00000001;		//reverse the bit polarity
					}
//
					if(RF_Rx_PreHead==SYN_FLAG){
						RF_RxSynSemaphore=SYN_STATE0;			//check if system synchronization flag
						RF_RxBitCounter=0;
					}
					break;
					
//////////////////////////////////////////////////
// state0 receiving byteCnt
				case SYN_STATE0:								//after synchronized
// get a bit
					RF_RxBitCounter++;
					RF_ReceivingBuf = RF_ReceivingBuf<<1;				//get a high bit
					if(tp1==CC_DIO__P0_20){							//system in asynchronize state
						RF_ReceivingBuf = RF_ReceivingBuf&(~0x01);	//reverse the bit polarity				
					}
					else{
						RF_ReceivingBuf = RF_ReceivingBuf|0x01;		//reverse the bit polarity
					}
// get a byte, here is receivingCnt
					if(RF_RxBitCounter>=8){						//get a byte
						RF_RxBitCounter=0;

						if((RF_ReceivingBuf>0)&&(RF_ReceivingBuf<=RX_BUFFER_LEN)){
							RF_RxSynSemaphore=SYN_STATE1;
							frameByteCnt=RF_ReceivingBuf;
						}
						else{
							RF_RxSynSemaphore=WAIT_SYN_F;		//lost the too large frame
							frameByteCnt=0;
						}
					}
					break;

////////////////////////////////////////////////
// state1 receiving ~receivingCnt
				case SYN_STATE1:								//after synchronized
// get a bit
					RF_RxBitCounter++;
					RF_ReceivingBuf = RF_ReceivingBuf<<1;				//get a high bit
					if(tp1==CC_DIO__P0_20){							//system in asynchronize state
						RF_ReceivingBuf = RF_ReceivingBuf&(~0x01);	//reverse the bit polarity				
					}
					else{
						RF_ReceivingBuf = RF_ReceivingBuf|0x01;		//reverse the bit polarity
					}
// get a byte, here is ~receivingCnt
					if(RF_RxBitCounter>=8){						//get a byte
						RF_RxBitCounter=0;						//reset byte counter

						RF_ReceivingBuf=~RF_ReceivingBuf;
						if(frameByteCnt==RF_ReceivingBuf){
							RF_RxSynSemaphore=SYN_STATE2;		//receivingCnt check ok
						}
						else{
							RF_RxSynSemaphore=WAIT_SYN_F;		//lost the too long package
							frameByteCnt=0;
						}
					}
					break;
					
///////////////////////////////////////////////
// state2 receiving a byte
				case SYN_STATE2:								//after synchronized
// get a bit
					RF_RxBitCounter++;
					RF_ReceivingBuf = RF_ReceivingBuf<<1;				//get a high bit
					if(tp1==CC_DIO__P0_20){							//system in asynchronize state
						RF_ReceivingBuf = RF_ReceivingBuf&(~0x01);	//reverse the bit polarity				
					}
					else{
						RF_ReceivingBuf = RF_ReceivingBuf|0x01;		//reverse the bit polarity
					}
// get a byte
					if(RF_RxBitCounter>=8){				//get a byte
						RF_RxBitCounter=0;				//reset bit counter
	
						RF_Rx_Buffer[RFr_inp]=RF_ReceivingBuf;	//sending data to receiving buffer
						RFr_inp++;	if(RFr_inp>=RX_BUFFER_LEN)  RFr_inp=0;
						RF_RxCounter++;

// check if receiving all data
						frameByteCnt--;
						if(frameByteCnt==0){
							RF_RxSynSemaphore=WAIT_SYN_F;	//received a whole frame
							RF_ActiveFlag = _DATA_AVAILABLE;
							frameByteCnt=0;
						}						
					}
					break;
					
/////////////////////////////////////////////
// default condition , reset the state machine
				default:
					RF_RxBitCounter=0;					//reset byte counter
					RF_RxSynSemaphore=WAIT_SYN_F;		//reset the state machine
					frameByteCnt=0;
					break;
			}
		}
	}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////	
// falling edge, for sending data
	else if((tp1==0)&&(tp2==0)){
		if((CC1000Mode==RFinTX_MODE)&&(RF_TxCounter!=0)){
			IO0DIR  = IO0DIR|CC_DIO__P0_20;			// CC_DIO__P0_20 serve as outpin

// sending a bit
			RF_SendingBuf = RF_Tx_Buffer[RFt_outp];		// get the sending data
			buff=(0x01<<(7-RF_TxBitCounter));	// get the bit position of sending data

			if((RF_SendingBuf&buff)==buff){		// sending data on cc1000 pin
				IO0SET	= CC_DIO__P0_20;
				}
			else{
				IO0CLR	= CC_DIO__P0_20;
				}
				RF_TxBitCounter++;				//next bit

// sending 1 byte
			if((RF_TxCounter!=1)&&(RF_TxBitCounter>=8)){
				RF_TxBitCounter=0;
				RFt_outp++;		if(RFt_outp>=TX_BUFFER_LEN)  RFt_outp=0;
				RF_TxCounter--;						//byte counter-1
			}  				//last byte with two bit as ending padding
			else if((RF_TxCounter==1)&&(RF_TxBitCounter>=10)){
				RF_TxBitCounter=0;
				RFt_outp++;		if(RFt_outp>=TX_BUFFER_LEN)  RFt_outp=0;
				RF_TxCounter--;						//byte counter-1
			}
		}
	}
	
//////////////////////////////////////////////////////////////////////////////////////
////
	PINSEL1  = PINSEL1  & 0xfffffffc; 	// set p0.16 as GPIO
	PINSEL1  = PINSEL1  | 0x00000001;	// 设置管脚连接，P0.16为EINT0
//	EXTMODE  = EXTMODE  | 0x01;			// 设置EINT0为 edge 触发
//	EXTPOLAR = EXTPOLAR ^ 0x01;			// reverse interrupt trigger edge

	EXTINT  	= 0x01;					// 清除EINT0中断标志
	VICVectAddr = 0;					// 向量中断结束
}


///////////////////////////////////////////////////////////////////////////////////////
// initialize external int0(p0.16) as DCLK of CC1000
// p0.20 as DIO of CC1000

void EINT0_Initialize(void)
{
	PINSEL1  = PINSEL1 & 0xfffffcfc; 	// set p0.16 and p0.20 as GPIO
	PINSEL1  = PINSEL1 | 0x00000001;	// set P0.16 as EINT0, be used as DCLK

	EXTMODE  = 0x01;						// 设置EINT0为 edge 触发
	EXTPOLAR = 0x01;						// 设置EINT0为 raising edge trigger type

	EXTINT   = 0x01;						// 清除EINT0中断标志

//	VICIntSelect   = 0x00000000;			// 设置所有中断分配为IRQ中断/not FIQ interrupt
	VICVectCntl4   = 0x20|INT_EINT0;		// 0x20 vector enable,分配外部中断0到向量中断4
	VICVectAddr4   = (uint32)IRQ_Eint0Serving;	// 设置中断服务程序地址
	VICIntEnable   = 1<<INT_EINT0;			// 使能EINT0中断
}

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