subroutine.c

基于ST72324设计的汽车无钥匙开门源程序

#define __DEFINE_REGISTERS_STVD7_INCLUDE__
#include "ST72324BLK2.h"
#include "Head.h" 
#include "Variables.h"
#include "Subroutine.h"
#undef  __DEFINE_REGISTERS_STVD7_INCLUDE__
#define asm_nop() _asm ("nop\n")
#define DI() _asm ("sim\n")
#define EI() _asm ("rim\n")

/*-----------------------------------------------------------------------------------
//  Interrupt sbroutine 
------------------------------------------------------------------------------------*/

@interrupt void SCIINT(void)
{
	 SCISR;
	 SCIDR=0XFF;
	 if(!TXCodeWidth)
	  {
	    SCICR2=0;     //Disable 
			TACR2=0;
			//Port_TX_1;
			TACR2&=~BIT7;
      TXLFCompleted=1; 
			return;
	  }	
	 else
	  {
		  if(FlagTXCode_Half)
       {
         if((*WakeUpCodeBytePoint) & BIT7)
				   {
            //Port_TX_1;
						TACR2&=~BIT7;
						SCIETPR=22;  //22
				   }	
         else
           {
						//Port_TX_0;
						TACR2|=BIT7;
						SCIETPR=12;  //12
           } 
         FlagTXCode_Half=0;
         WakeUpCode<<=1;
         TXCodeWidth--;
       }
      else
       {
				 //if(TXCodeWidth==16)
				if((TXCodeWidth==8) || ((TXCodeWidth==16) && (Flag_Learn1 && !Flag_Learn0 )))
						SCIBRR=0X09;
				if((*WakeUpCodeBytePoint) & BIT7)
           {				
						//Port_TX_0;
						TACR2|=BIT7;
						SCIETPR=12;
				   }	
        else
				   {
            //Port_TX_1;
						TACR2&=~BIT7;
						SCIETPR=22;
				   }	
        FlagTXCode_Half=1;      
       }

		}
 
}

/*-----------------------------------------------------------------------------------
//  common subroutine 
------------------------------------------------------------------------------------*/
void  Delay(unsigned int DelayTime)
{
  while(DelayTime--)
    ClrWD;
}  

void  TXCode(enum txcodemode TXCodeMode,enum intensity Intensity)
{
 unsigned char j;	
 WakeUpCode=0;
 if(Status&WhichKey)  
   j=(unsigned char)(IDCode1);
 else
   j=(unsigned char)(IDCode0);
 if(TXCodeMode==LearnREQ)
  {
		WakeUpCode=(unsigned int long)0x967554;
		WakeUpCode<<=8;
		TXCodeWidth=24;
	}
 else
  {
		
    WakeUpCode=(((unsigned int long)0xff96<<8)+j);
		WakeUpCode<<=8;
		TXCodeWidth=24;
  }


 WakeUpCodeBytePoint=(unsigned char*)(&WakeUpCode);
 TAOC1HR=0X00;
 TAOC2HR=0X00;
 if(Intensity==Strong) 
    TAOC1LR=1;   //15   
 else if(Intensity==Weak) 
  {
    TAOC1LR=1;    //5
  }	 
 TAOC2LR=6;   //35
 TAACLR=0;
 
 
 TACR1=(BIT2+BIT3);
 TACR2=(BIT4+BIT3+BIT7);
 
 SCICR2=(BIT6+BIT3);
 SCIBRR=0X00;
 SCIETPR=17;
 Port_TX_0;
 
}
/*==================================================================================*/
    
  void ReadCodeID(void)
{
	char i=0,j,k; 
	unsigned  long int *IntPointer;
	do
	{
	 j=0; 
	 k=8; 
	 i+=0x10;
	 RCBPointer=DataBuff;               
	 RW24XX(RCBPointer,10,i,Read24c01);    //CheckSum--DataBuff[8];  //DataBuff[0-3]--CodeID0;DataBuff[4-7]--CodeID1; 
	 RCBPointer=DataBuff;               
	 while(k--) 
	   {
   		 j+=*RCBPointer;
   	     RCBPointer++;
   	   } 
   	  } 
    while(j!=DataBuff[8] && i<0x30);
    
    if(i>=0x30) 
		   DataBuff[9]=0x02;
		else
       {
				 RCBPointer=&DataBuff[9]; 
		     RW24XX(RCBPointer,1,(i+0x09),Read24c01);   
		     Status=DataBuff[9];
				 
		     RCBPointer=(unsigned char*)(&SyncroCode0); 
		     RW24XX(RCBPointer,4,(0x40),Read24c01);    

         RCBPointer=(unsigned char*)(&SyncroCode1); 
		     RW24XX(RCBPointer,4,(0x44),Read24c01);    

		   }	
    IntPointer=(unsigned long int *)DataBuff;			 
    IDCode0=*IntPointer;
    IDCode1=*(IntPointer+1);
    Status=DataBuff[9];
		SyncroCode0&=0x007fffff;
		SyncroCode1&=0x007fffff;
}

/*======================================================================*/

	
void StoreStatus(void)
{
  if(Status!=DataBuff[9])
   {  
       DataBuff[9]=Status;
       RCBPointer=&DataBuff[9]; 
       RW24XX(RCBPointer,1,0x19,Write24c01);  /*CheckSum--DataBuff[7];  DataBuff[0-2]--CodeID0;DataBuff[3-5]--CodeID1; */
       RW24XX(RCBPointer,1,0x29,Write24c01);  /*CheckSum--DataBuff[7];  DataBuff[0-2]--CodeID0;DataBuff[3-5]--CodeID1; */
   } 
	 else if(Flag_Store_SyncroCode0)
	 {
			 Flag_Store_SyncroCode0=0;
			 RCBPointer=(unsigned char*)(&SyncroCode0); 
		   RW24XX(RCBPointer,4,0x40,Write24c01);    
	 }
	 else if(Flag_Store_SyncroCode1)
	 {
			 Flag_Store_SyncroCode1=0;
			 RCBPointer=(unsigned char*)(&SyncroCode1); 
		   RW24XX(RCBPointer,4,0x44,Write24c01);    
	 }
	 
}   	

/*======================================================================*/

void StoreCodeID(void)
{
     char i;
     unsigned  long int *IntPointer;
		 IntPointer=(unsigned long int *)DataBuff;	
    	*IntPointer=IDCode0;
    	*(IntPointer+1)=IDCode1;
    	RCBPointer=DataBuff;
     	DataBuff[8]=0;
    	i=8;
    	while(i--) 
          {
   	       DataBuff[8]+=*(RCBPointer++);  
  	      }
       RCBPointer=DataBuff; 
       RW24XX(RCBPointer,9,0x10,Write24c01);  /*CheckSum--DataBuff[7];  DataBuff[0-2]--CodeID0;DataBuff[3-5]--CodeID1; */
       RCBPointer=DataBuff; 
       RW24XX(RCBPointer,9,0x20,Write24c01);  /*CheckSum--DataBuff[7];  DataBuff[0-2]--CodeID0;DataBuff[3-5]--CodeID1; */
}

/*======================================================================*/
// for learn IDCode from key
void  LearnIDCode(void)
{
 unsigned char i;	 
 if(Port_Learn_AT && !Flag_Learn0)
   {
		  Port_LED_1;
			Delay(100);         
			if(Port_Learn_AT)  //ensure
			 {
					if(!Flag_Learn1)
					 {
						   OutputCtrl(WAIT,60);  //15S 
						   Flag_Learn1=1;
					 } 
					 AutoLockTimer=17;
           if(Flag_Learned)
					   {
							  DI();
							  if(!Flag_LearnFirst)
								  {
										IDCode0=IDCode1;
										SyncroCode0=0;
										Flag_LearnFirst=1;
										i=13;
									}
	              else
                  {
										i=14; 
										Flag_LearnFirst=0; 
										Flag_Learn0=1;
										SyncroCode1=0;
                  }
                while(i--)
                  {
										if(!i)
										 Port_Horn_1;
										Delay(10000);
										Port_LED_Toggle;
								  }	
                StoreCodeID();
								Port_Horn_0;
								Flag_Learned=0; 
                EI();									
						 }

			 } 
	 }
 else if(!Port_Learn_AT)
	{ 
				  Flag_Learn1=0;
					Flag_Learn0=0;
					Flag_LearnFirst=0;
	}

	 
	
}
/*======================================================================*/
void MonitorRAM(void)
{
	unsigned  long int *IntPointer;
  IntPointer=(unsigned long int *)DataBuff;			 
  DI();
	if(IDCode0^*IntPointer)   
		while(1);
  else if(IDCode1^*(IntPointer+1))
	  while(1);
	else if(    PBDDR!=(BIT0+BIT3+BIT4)
				   || PBOR!=(BIT0+BIT3+BIT4)
					 || PCDDR!=(BIT0)
					 || PCOR!=(Port_Fuel_Ctrl+Port_Learn)
					 || PDDDR!=(BIT0+BIT1)
					 || PDOR!=(BIT0+BIT1)
					 || PEDDR!=(BIT1)
					 || PEOR!=BIT1
					 || PFDDR!=(BIT0+BIT1+BIT4+BIT6+BIT7)
					 || PFOR!=(BIT0+BIT1+BIT4+BIT6+BIT7)
					)
	  while(1);
	else if( 
	           (TBCR2&0X7E)!=(BIT2+BIT1)
					 || TBCSR&BIT2 
					 ||(MCCSR&0XFE)!=(BIT3+BIT2+BIT1)
         )	
		while(1);		 
	EI();	
}