www.pudn.com > fd.rar > remote.c


//#include "main.h" 
//#include "remote.h" 
//#include "key.h" 
#include "include.h" 
const uint PULSE_SHORT_MIN=PULSE_SHORT_MIN_TIME/8/4;    //1。8ms 
const uint PULSE_SHORT_MAX=PULSE_SHORT_MAX_TIME/8/4;    //3ms 
const uint PULSE_LONG_MIN=PULSE_SHORT_MIN_TIME/8/4*3; 
const uint PULSE_LONG_MAX=PULSE_SHORT_MAX_TIME/8/4*3; 
 
const uint PULSE_SYN_MAX=PULSE_SHORT_MAX_TIME/8/4*35; 
const uint PULSE_SYN_MIN=PULSE_SHORT_MIN_TIME/8/4*20; 
const uint DT=(uint)((PULSE_SHORT_MIN_TIME/8/4+PULSE_SHORT_MIN_TIME/8/4)*0.1/2); 
 
bank2 SharkFlagStruct SharkFlag={2}; 
bank1 ulong PassWord[2];       //waste 2B ram;   20bit 
 
static bank1 RemindStateEnum RemindState=DOOR_OPEN; 
static bank1 uchar PressUnlock=0; 
static Timer16Struct GuardQuiet5s={0,1};      //延时5s进入警戒状态; 
static bank1 AlarmGradeEnum AlarmGrade=Guard; 
static bank1 OpenStepEnum     OpenStep=OPEN_REMIND; 
static EnergencyEnum Energency=PRESS_FIND; 
static bank1 bit SystemGuardChangeFirstTime=0; 
bank2 LearnStepEnum LearnStep=FRIST_DATA; 
bank2 Timer16Struct AlarmSharkTimer={0,0}; 
 
bank1 Timer16Struct DoorOpenTimer={0,0}; 
bank1 uchar AlarmNoub=0; 
bit remote_key_dither(ulong data) 
{ 
      static bank1 ulong LastRemote; 
      if(data==LastRemote) 
      { 
            if(RemoteKey.Flag.FirstPress==1) 
            { 
                  RemoteKey.Flag.Press=1; 
                  RemoteKey.Flag.FirstPress=0; 
                  RemoteKey.Key=get_key(data); 
                  RemoteKey.Rec=data; 
            } 
            RemotePressTimeOut.Interval=0; 
            RemoteKey.Time.Interval=RemotePressTime.Interval; 
            RemotePressTime.enable=1; 
            RemotePressTimeOut.enable=1; 
            LastRemote=data; 
            //RemoteKey.Key=get_key(data); 
            return 1;  
      } 
 
      else 
      { 
            //for error process; 
            RemoteKey.Flag.Release=0; 
            RemoteKey.Flag.Press=0; 
            RemoteKey.Flag.FirstPress=1; 
            RemotePressTime.Interval=0; 
      }   
      LastRemote=data; 
      return 0; 
} 
 
ulong get_password(ulong data) 
{ 
      //ulong pass; 
      //pass=(data&0x00ffffff)>>4; 
      //return(pass); 
      return((data&0x00ffffff)>>4); 
} 
 
uchar get_key(ulong data) 
{ 
      ulong pd; 
      uchar KeyValue; 
       
      pd=data&0x0f; 
      KeyValue=(uchar)(pd); 
       
      if(KeyValue==0x08)      return KEY_LOCK; 
      else if(KeyValue==0x0c) return KEY_UNLOCK; 
      else if(KeyValue==0x03) return KEY_QUIET; 
      else if(KeyValue==0x0f) return KEY_FIND; 
      #ifdef BOOT_EN 
      else if(KeyValue==0x04) return KEY_BOOT; 
      #endif 
      else                    return KEY_UNKNOW; 
} 
 
bit decode(ulong data) 
{ 
      ulong Word; 
      Word=get_password(data); 
      if(PassWord[0]==Word||PassWord[1]==Word) 
            return 1; 
      else return 0; 
} 
 
//void remind_shutdown(void) 
bit remind_shutdown(void) 
{ 
       
      static bank1 Timer16Struct DelayTime=0; 
       
      if(InState.SideDoor==DOOR_OPENED) 
      { 
            RemindState=DOOR_OPEN; 
            DelayTime.Interval=0; 
      } 
      switch(RemindState) 
      { 
            case DOOR_OPEN: 
                  if(InState.SideDoor==DOOR_OPENED) 
                        RemindState=DOOR_CLOSE; 
                  break; 
            case DOOR_CLOSE: 
                  if(InState.SideDoor==DOOR_CLOSED) 
                  { 
                        RemindState=DELAY_5S; 
                        DelayTime.Interval=0; 
                  } 
                  break; 
            case DELAY_5S: 
                  if(DelayTime.Interval++>=REMIND_SHUT_DELAY_TIME) 
                  { 
                        DelayTime.Interval=0; 
                        RemindState=REMIND; 
                        speak_act_precoss(0,0,0,RESET);     //reset speak; 
                  } 
                  break; 
            case REMIND: 
                  flash_trun_signal(120/TIME_BASE,1400/TIME_BASE,3); 
                  if(speak_act_precoss(40/TIME_BASE,1480/TIME_BASE,3,SHORT)) 
                  { 
                        RemindState=DELAY_60S; 
                        flash_trun_signal(0,0,0); 
                        speak_act_precoss(0,0,0,RESET); 
                  } 
                  break; 
            case DELAY_60S: 
                  if(DelayTime.Interval++>=REMIND_DELAY_60S) 
                  { 
                        RemindState=CHANGE_STATE; 
                        DelayTime.Interval=0; 
                  } 
                   
                  break; 
            case CHANGE_STATE: 
			RemindState=STATE_END; 
                  if(Jump.SlefThorth) 
			{ 
                        system_state_change(State,GUARD_QUIET,1); 
                  	return 1; 
			} 
			 
			//PreState=State; 
                  //State=GUARD_QUIET; 
                   
                  break; 
            case STATE_END: 
                  break; 
            default:break; 
                
      } 
	return 0; 
} 
 
bit alarm_led_long_light(uchar LightTime,uchar DrownTime) 
{ 
      static Timer16Struct RunTime=0; 
       
      if(LightTime==0) 
      { 
            RunTime.Interval=0; 
            ALARM_LED=0; 
      } 
      else 
      { 
            if(++RunTime.Interval<=LightTime*125) 
            { 
                  ALARM_LED=1; 
            }    
            else if(RunTime.Interval<=125*(LightTime+DrownTime)) 
                  ALARM_LED=0; 
            else  
            { 
	            RunTime.Interval=0; 
	     		return 1; 
	     	} 
      } 
      return 0; 
} 
/*  
//////////////////////////////////////////// 
// Times :125ms                           // 
// Second: 1s                             // 
//////////////////////////////////////////// 
void flash_alarm_led(uchar Times,uchar Second) 
{ 
      if(AlarmLed.Flag.ms125) 
      { 
            AlarmLed.Flag.ms125=0; 
            AlarmLed.Flag.Time++; 
            if(AlarmLed.Flag.Time<=Times) 
                  ALARM_LED=!ALARM_LED; 
            else if(AlarmLed.Flag.Time<=Times+Second*8)      //2s 
                  ALARM_LED=0; 
            else 
                  AlarmLed.Flag.Time=0; 
      } 
} 
*/ 
bit flash_alarm_led(uchar Times,uchar Second) 
{ 
      if(AlarmLed.Flag.ms125) 
      { 
            AlarmLed.Flag.ms125=0; 
            AlarmLed.Flag.Time++; 
            if(AlarmLed.Flag.Time<=Times) 
                  ALARM_LED=!ALARM_LED; 
                  //ALARM_LED=1; 
            else if(AlarmLed.Flag.Time<=Times+Second*8)      //2s 
                  ALARM_LED=0; 
            else 
            { 
                  AlarmLed.Flag.Time=0; 
      		return 1; 
      	} 
      } 
      return 0; 
} 
 
 
       
void signal_led_alarm(AlarmGradeEnum state) 
{ 
       
      if(state==Guard) 
            flash_alarm_led(4,2); 
      else if(state==Shaked) 
            flash_alarm_led(6,2); 
      else if(state==Opened) 
            alarm_led_long_light(4,4); 
      else if(state==Unchain) 
            alarm_led_long_light(6,0); 
} 
       
uchar flash_trun_signal(uint PulseTime1,uint Interval1,uchar Times1) 
{ 
      static bank2 uint RunTime1=0; 
      static bank2 uchar CTime1=0;         //continuance time; 
       
      Used.TrunSignal=1; 
      if((PulseTime1==0)&&(Interval1==0)) 
      {  
            Used.TrunSignal=0; 
            RunTime1=0; 
            TRUN_SIGNAL=0; 
            CTime1=0; 
            return 1; 
      } 
      else 
      { 
            if(CTime1=10000/TIME_BASE) 
                        OpenStep=OPEN_ALARM; 
                	if(InState.SideDoor!=DOOR_OPENED) 
                		Flag.DoorOpenedGuard=0; 
                  break;       
            case OPEN_ALARM: 
                  flash_trun_signal(500/TIME_BASE,500/TIME_BASE,240);           
                  if(speak_act_precoss(0,0,240000/TIME_BASE/5,LONG)) 
                  { 
                        OpenStep=OPEN_STOP; 
                        flash_trun_signal(0,0,0); 
                        speak_act_precoss(0,0,0,RESET);      
                  } 
                  break; 
            case OPEN_STOP: 
            	Flag.DoorOpenedGuard=0; 
                  break; 
            default:break; 
      } 
} 
 
#ifdef BOOT_EN 
bit open_boot(uchar Interval) 
{ 
      static bank1 BootTimer=0; 
      if(Interval==0) 
      { 
            BOOT=0; 
            BootTimer=0; 
      } 
      else 
      {  
            if(++BootTimer<=Interval*5) 
            { 
 
                  BOOT=1; 
                  return 0; 
            } 
            else 
            { 
                  BootTimer=Interval*5; 
                  BOOT=0; 
                  return 1; 
            } 
      } 
      return 1; 
       
} 
#endif 
 
void normal_process(void) 
{ 
      static bank1 AutoRestoreStruct AutoRestore=0; 
       
      if(Flag.SystemStateChange) 
      { 
            RemindState=DOOR_OPEN; 
             
            AutoRestore.Flag.Shaked=0; 
            AutoRestore.Flag.Opened=0; 
            AutoRestore.Time.Interval=0; 
            Flag.RememTouch=0; 
            switch(PreState) 
            { 
                   
                  case GUARD_SOUND: 
                        door_lock_process(500/TIME_BASE/5,LOCK_OFF); 
                        if(PressUnlock==0)  
                              speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT); 
                        if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2)) 
                        { 
                                    Flag.SystemStateChange=0; 
                                    flash_trun_signal(0,0,0); 
                                    speak_act_precoss(0,0,0,RESET); 
                                    if(Jump.Electromotion)  door_lock_process(0,0); 
                        } 
                        break; 
                  case GUARD_QUIET: 
                        door_lock_process(500/TIME_BASE/5,LOCK_OFF); 
                        //if(speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT)); 
                        if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2)) 
                        { 
                                    Flag.SystemStateChange=0; 
                                    flash_trun_signal(0,0,0); 
                                    speak_act_precoss(0,0,0,RESET); 
                                    if(Jump.Electromotion) door_lock_process(0,0); 
                        } 
                        break; 
                  case RUN: 
                        if(PressUnlock>0) 
                        { 
                               door_lock_process(500/TIME_BASE/5,LOCK_OFF); 
                              //if(speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT)); 
                              if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2)) 
                              { 
                                          Flag.SystemStateChange=0; 
                                          flash_trun_signal(0,0,0); 
                                          speak_act_precoss(0,0,0,RESET); 
                                          if(Jump.Electromotion) door_lock_process(0,0); 
                              }      
                        } 
                        else  
                        { 
                              if(door_lock_process(500/TIME_BASE/5,LOCK_OFF)) 
                              { 
                                    Flag.SystemStateChange=0; 
                                    if(Jump.Electromotion) door_lock_process(0,0); 
                              } 
                        } 
                        break; 
                  default: 
                        Flag.SystemStateChange=0; 
                        break; 
            } 
      } 
      else 
      { 
            if(RemoteKey.Flag.Press) 
            { 
                  RemoteKey.Flag.Press=0; 
                  switch(RemoteKey.Key) 
                  { 
                        case KEY_LOCK: 
                              system_state_change(State,GUARD_SOUND,1); 
                              //break; 
					return ; 
                        case KEY_QUIET: 
                              system_state_change(State,GUARD_QUIET,1); 
                              //break; 
					return ; 
                        case KEY_FIND: 
                              system_state_change(State,FIND,1); 
                              //break; 
					return ; 
                        case KEY_UNLOCK: 
                              if(++PressUnlock<=3) 
                              { 
                                    flash_trun_signal(0,0,0); 
                                    Flag.SystemStateChange=1; 
                              } 
                              else 
                                    PressUnlock=3; 
                              break; 
                        #ifdef BOOT_EN 
                         
                        case KEY_BOOT: 
                              Flag.Boot=1; 
                              open_boot(0); 
                              break; 
                        #endif 
                        default: 
                              break; 
                  } 
            } 
            // 进入行驶 
             
            #ifdef BOOT_EN 
            if(Flag.Boot) 
            { 
                  Flag.Boot=0; 
                  open_boot(500/TIME_BASE/5); 
            } 
            #endif 
            if(InState.Acc) 
            { 
                  system_state_change(State,RUN,1); 
                  return ; 
            } 
            //提醒设置防盗    for remind to shutdown  
            //if(PreState==RUN) 
                  //remind_shutdown(); 
		if(PreState==RUN) 
			Flag.FromRemindShutDown=remind_shutdown();  
            //路边停车 
            roadside_stop(); 
             
            //for auto restore 
            if(!InState.Shake) 
                  AutoRestore.Flag.Shaked=1; 
            if(InState.SideDoor==DOOR_OPENED) 
            { 
                  if(AlarmNoub>3)   AlarmNoub=3; 
                  if(AlarmNoub>0) 
                  { 
	                  AlarmNoub=0; 
                        Flag.RememTouch=1; 
                  	alarm_led_long_light(0,0); 
                  } 
                  AutoRestore.Flag.Opened=1;     
                  AlarmGrade=Guard; 
            }       
                   
            if((!AutoRestore.Flag.Shaked)&&(!AutoRestore.Flag.Opened)) 
            { 
                  if(PreState==GUARD_QUIET||PreState==GUARD_SOUND) 
                        if(AutoRestore.Time.Interval++>=AUTO_RESTORE_TIME) 
                        { 
                              system_state_change(State,PreState,1); 
                              AutoRestore.Time.Interval=0; 
                        } 
            } 
            else  AutoRestore.Time.Interval=0; 
            //记忆触发 
            if(Flag.RememTouch) 
            { 
			speak_act_precoss(50/TIME_BASE,950/TIME_BASE,1,SHORT); 
			if(alarm_led_long_light(6,1)) 
		    { 
				alarm_led_long_light(0,0);			   	 
				SIGNAL_LED=0; 
				AlarmNoub=0; 
				speak_act_precoss(0,0,0,RESET); 
				Flag.RememTouch=0; 
		     } 
		} 
      } 
} 
 
void guard_process(uchar Mode) 
{ 
	if(GuardQuiet5s.Interval++>=5000/TIME_BASE) 
	{ 
	      GuardQuiet5s.enable=0; 
	      GuardQuiet5s.Interval=0; 
	      Flag.BeginGuard=1; 
	} 
	if(Flag.BeginGuard) 
	{ 
	      if(Flag.DoorOpenedGuard) 
	            door_opened_guard(); 
	      else  
	      { 
	            if(!InState.Shake) 
	            { 
	              
	             	if(AlarmSharkTimer.Interval==0) 
	             	{ 
	              		SharkFlag.Time=1; 
	             		AlarmSharkTimer.enable=1; 
	          		} 
	          		else if(AlarmSharkTimer.Interval<15000/TIME_BASE) 
	          			SharkFlag.Time=2; 
	          		else 
	          		{ 
	           			SharkFlag.Time=1; 
	          			AlarmSharkTimer.enable=1; 
	                  } 
	                  AlarmSharkTimer.Interval=0; 
	                  if(Mode==QUIET_MODE) 
	                  	system_state_change(State,ALARM_QUIET,1); 
	                  else if(Mode==SOUND_MODE) 
	                  	system_state_change(State,ALARM_SOUND,1); 
	            } 
	            if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake) 
	                  system_state_change(State,ALARM_DOOR_OPENED,1); 
	      } 
	}       
 
} 
 
void guard_quiet_process(void) 
{ 
      // 5s later into the guard mode 
      signal_led_alarm(AlarmGrade); 
       
      if(!Flag.GuardEngineOFF) 
      { 
            if(PreState!=FIND) 
            { 
                  if(Flag.DoorOpenedGuard) 
                        Flag.GuardEngineOFF=1; 
                  if(frameout_precoss(40)) 
                        Flag.GuardEngineOFF=1; 
            } 
            else Flag.GuardEngineOFF=1;          
      } 
      if(Flag.SystemStateChange) 
      { 
            if(PreState!=FIND) 
            { 
                  if(!Flag.FromRemindShutDown) 
				door_lock_process(500/TIME_BASE/5,LOCK_ON); 
                  if(flash_trun_signal(500/TIME_BASE,200/TIME_BASE,1)) 
                  { 
                              Flag.SystemStateChange=0; 
                              flash_trun_signal(0,0,0); 
                              if(Jump.Electromotion)  door_lock_process(0,0); 
                              speak_act_precoss(0,0,0,RESET); 
                  } 
            GuardQuiet5s.Interval=0; 
            } 
            else Flag.SystemStateChange=0; 
            Flag.BeginGuard=0; 
            /////////////////////////////////当进入防盗系统的时候 如果门未关好 提醒用户关门//////////////// 
            if(SystemGuardChangeFirstTime) 
            { 
	            if(InState.SideDoor==DOOR_OPENED) 
	            { 
	                  Flag.DoorOpenedGuard=1; 
	                  OpenStep=OPEN_REMIND; 
	            } 
	            else 
	            	Flag.DoorOpenedGuard=0; 
            } 
            SystemGuardChangeFirstTime=0; 
          	AlarmSharkTimer.enable=0; 
          	AlarmSharkTimer.Interval=0; 
      } 
      else 
      {  
	      guard_process(QUIET_MODE); 
		if(RemoteKey.Flag.Press) 
		{ 
		      RemoteKey.Flag.Press=0; 
		      switch(RemoteKey.Key) 
		      { 
		            case KEY_LOCK: 
		                  system_state_change(State,GUARD_SOUND,1); 
		                  break; 
		            case KEY_UNLOCK: 
		                  ALARM_LED=0; 
		                  system_state_change(State,NORMAL,1); 
		                  break; 
		            case KEY_FIND: 
		                  system_state_change(State,FIND,1); 
		                  break; 
		            case KEY_QUIET: 
		                  Flag.GuardEngineOFF=0; 
		                  frameout_precoss(0); 
		                  Flag.SystemStateChange=1; 
		                  break; 
		            #ifdef BOOT_EN 
		            case KEY_BOOT: 
		                  Flag.Boot=1; 
		                  open_boot(0); 
		                  break; 
		            #endif 
		             
		            default:break; 
		      } 
		} 
      } 
} 
 
void guard_sound_process(void) 
{ 
      //flash_alarm_led(4,2); 
      signal_led_alarm(AlarmGrade); 
      if(!Flag.GuardEngineOFF) 
      { 
            if(PreState!=FIND) 
            { 
                  if(Flag.DoorOpenedGuard) 
                  { 
                        Flag.GuardEngineOFF=1; 
                  } 
                  if(frameout_precoss(40)) 
                        Flag.GuardEngineOFF=1; 
            } 
            else Flag.GuardEngineOFF=1;          
      } 
       
      if(Flag.SystemStateChange) 
      { 
            if(PreState!=FIND) 
            { 
                  speak_act_precoss(50/TIME_BASE,200/TIME_BASE,1,SHORT); 
                  door_lock_process(500/TIME_BASE/5,LOCK_ON); 
                  if(flash_trun_signal(500/TIME_BASE,200/TIME_BASE,1)) 
                  { 
                              Flag.SystemStateChange=0; 
                              speak_act_precoss(0,0,0,RESET); 
                              flash_trun_signal(0,0,0); 
                              if(Jump.Electromotion) door_lock_process(0,0); 
                  } 
                  GuardQuiet5s.enable=1; 
                  GuardQuiet5s.Interval=0; 
            } 
            else Flag.SystemStateChange=0; 
            Flag.BeginGuard=0; 
            /////////////////////////////////当进入防盗系统的时候 如果门未关好 提醒用户关门//////////////// 
            if(SystemGuardChangeFirstTime) 
            { 
	            if(InState.SideDoor==DOOR_OPENED) 
	            { 
	                  Flag.DoorOpenedGuard=1; 
	                  OpenStep=OPEN_REMIND; 
	            } 
				else Flag.DoorOpenedGuard=0; 
			} 
			SystemGuardChangeFirstTime=0; 
            AlarmSharkTimer.enable=0; 
            AlarmSharkTimer.Interval=0; 
             
      } 
      else 
      {      
		guard_process(SOUND_MODE); 
            if(RemoteKey.Flag.Press) 
            { 
                  RemoteKey.Flag.Press=0; 
                  switch(RemoteKey.Key) 
                  { 
                        case KEY_LOCK: 
                              system_state_change(State,GUARD_SOUND,1); 
                              break; 
                               
                        case KEY_UNLOCK: 
                              ALARM_LED=0; 
                              system_state_change(State,NORMAL,1); 
                              break; 
                        case KEY_FIND: 
                              system_state_change(State,FIND,1); 
                              break; 
                        case KEY_QUIET: 
                              system_state_change(State,GUARD_QUIET,1); 
                              break; 
                        default:break; 
                  } 
            } 
      } 
} 
 
void find_process(void) 
{ 
      flash_trun_signal(500/TIME_BASE,500/TIME_BASE,5); 
      if(speak_act_precoss(0,0,5000/TIME_BASE/5,LONG)) 
      { 
            speak_act_precoss(0,0,0,RESET); 
            flash_trun_signal(0,0,0); 
            system_state_change(State,PreState,0); 
      }       
      if(RemoteKey.Flag.Press) 
      { 
            RemoteKey.Flag.Press=0; 
            switch(RemoteKey.Key) 
            { 
                  case KEY_LOCK: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_UNLOCK: 
                         
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_FIND: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_QUIET: 
                        system_state_change(State,PreState,0); 
                  default:break; 
            } 
      } 
} 
 
 
typedef struct 
{ 
      unsigned char Lock:1; 
      unsigned char Unlock:1; 
      unsigned char Help:1; 
      unsigned char Call:1; 
      unsigned char DoorOpened:1; 
      unsigned char State:2; 
}RunStruct; 
void run_process(void) 
{ 
      static bank1 RunStruct Run=0; 
       
      ///////////15s后自动锁门//////// 
      static Timer16Struct AutoLock=0; 
      if(Flag.SystemStateChange) 
      { 
            AlarmNoub=0; 
            Flag.SystemStateChange=0; 
            Run.State=0; 
            AutoLock.Interval=0; 
            Run.DoorOpened=0; 
      } 
      switch(Run.State) 
      { 
            case 0: 
                  if(InState.SideDoor) 
                        Run.DoorOpened=1; 
                  if(!InState.SideDoor&&Run.DoorOpened) 
                  { 
                        Run.State=0; 
                        Run.DoorOpened=0; 
                        AutoLock.Interval=0; 
                  } 
                  if(++AutoLock.Interval>=15000/TIME_BASE) 
                  { 
                        Run.State=1; 
                        AutoLock.Interval=0; 
                  } 
                  break; 
            case 1: 
                  if(InState.Brake) 
                  { 
                        Run.Lock=1; 
                        Run.State=2; 
                  } 
                  break; 
            case 2: 
                  if(InState.SideDoor) 
                        Run.DoorOpened=1; 
                  if(!InState.SideDoor&&Run.DoorOpened) 
                  { 
                        Run.State=0; 
                        Run.DoorOpened=0; 
                  } 
                  break;       
            default: 
                  Run.State=2; 
                  break; 
      } 
      ///////////////////////////////// 
      if(RemoteKey.Flag.Press) 
      { 
            switch(RemoteKey.Key) 
            { 
                  case KEY_LOCK: 
                  		Run.Unlock=0; 
                        Run.Lock=1; 
                        door_lock_process(0,0); 
                        RemoteKey.Flag.Press=0; 
                        break; 
                  case KEY_UNLOCK: 
                  		Run.Lock=0; 
                        Run.Unlock=1; 
                        door_lock_process(0,0); 
                        RemoteKey.Flag.Press=0; 
                        break; 
                  case KEY_FIND: 
                        if(RemoteKey.Time.Interval>=1500/TIME_BASE) 
                        { 
                              RemoteKey.Flag.Press=0; 
                              system_state_change(State,ALARM_HELP,1); 
                        } 
                        break; 
                  case KEY_QUIET: 
                        if(RemoteKey.Time.Interval>=1500/TIME_BASE) 
                        { 
                              RemoteKey.Flag.Press=0; 
                              Energency=PRESS_FIND; 
                              system_state_change(State,ALARM_ENERGENCY,1); 
                        } 
                        break; 
                  default:break; 
            } 
      } 
       
      roadside_stop(); 
       
      if(!InState.Acc) 
      { 
            //PreState=State; 
            //State=NORMAL; 
            system_state_change(State,NORMAL,1); 
      } 
      if(Run.Unlock) 
      { 
            if(door_lock_process(500/TIME_BASE/5,LOCK_OFF)) 
            { 
                  Run.Unlock=0; 
                  if(Jump.Electromotion) 
                        door_lock_process(0,0); 
            } 
      } 
      else if(Run.Lock) 
            if(door_lock_process(500/TIME_BASE/5,LOCK_ON)) 
            { 
                  Run.Lock=0; 
                  if(Jump.Electromotion)  
                        door_lock_process(0,0); 
            } 
} 
void alarm_down_opened_process(void) 
{ 
      //alarm_led_long_light(4,4); 
       
      if(Flag.SystemStateChange) 
      { 
            Flag.SystemStateChange=0; 
            if(AlarmNoub++>=3) AlarmNoub=3; 
      } 
       
      if(AlarmGrade<=Opened) 
            AlarmGrade=Opened; 
      signal_led_alarm(AlarmGrade); 
      frameout_precoss(60); 
      flash_trun_signal(500/TIME_BASE,500/TIME_BASE,26); 
      if(speak_act_precoss(0,0,26000/TIME_BASE/5,LONG)) 
      { 
            speak_act_precoss(0,0,0,RESET); 
            flash_trun_signal(0,0,0); 
            system_state_change(State,PreState,0); 
      }  
      if(RemoteKey.Flag.Press) 
      { 
            RemoteKey.Flag.Press=0; 
            switch(RemoteKey.Key) 
            { 
                  case KEY_LOCK: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_UNLOCK: 
                        system_state_change(PreState,NORMAL,1); 
                        break; 
                  case KEY_FIND: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_QUIET: 
                        system_state_change(State,PreState,0); 
                  default:break; 
            } 
      } 
} 
 
void shark_alarm(uchar Mode) 
{ 
	if(Flag.SystemStateChange) 
      { 
            Flag.SystemStateChange=0; 
            if(AlarmNoub++>=3) AlarmNoub=3; 
      } 
      if(AlarmGrade<=Shaked) 
            AlarmGrade=Shaked; 
	signal_led_alarm(AlarmGrade); 
	if(SharkFlag.Time==1) 
	{ 
	      //if(frameout_precoss(60)); 
	      if(Mode==SOUND_MODE)  
			if(speak_act_precoss(50/TIME_BASE,950/TIME_BASE,5,SHORT)); 
		if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,5)) 
	      { 
	            speak_act_precoss(0,0,0,RESET); 
	            flash_trun_signal(0,0,0); 
	            system_state_change(State,PreState,0); 
	      } 
 
	} 
      else if(SharkFlag.Time==2) 
      { 
	      if(frameout_precoss(61)); 
	      if(Mode==SOUND_MODE)   
			if(speak_act_precoss(0,0,27000/TIME_BASE/5,LONG)); 
	      if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,26)) 
	      { 
	            speak_act_precoss(0,0,0,RESET); 
	            flash_trun_signal(0,0,0); 
	            system_state_change(State,PreState,0); 
	      } 
      }        
	if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake) 
            system_state_change(PreState,ALARM_DOOR_OPENED,1); 
} 
void alarm_quiet_process(void) 
{ 
      //if(Flag.SystemStateChange) 
      //{ 
            //Flag.SystemStateChange=0; 
            //if(AlarmNoub++>=3) AlarmNoub=3; 
      //} 
      //if(AlarmGrade<=Shaked) 
            //AlarmGrade=Shaked; 
       
       
	shark_alarm(QUIET_MODE); 
       
      if(RemoteKey.Flag.Press) 
      { 
            RemoteKey.Flag.Press=0; 
            switch(RemoteKey.Key) 
            { 
                  case KEY_LOCK: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_UNLOCK: 
                         
                        system_state_change(PreState,NORMAL,1); 
                        break; 
                  case KEY_FIND: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_QUIET: 
                        system_state_change(State,PreState,0); 
                  default:break; 
            } 
      } 
} 
 
void alarm_sound_process(void) 
{ 
       
      //signal_led_alarm(AlarmGrade); 
       
	shark_alarm(SOUND_MODE); 
      //if(InState.SideDoor==DOOR_OPENED) 
      //if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake) 
            //system_state_change(PreState,ALARM_DOOR_OPENED,1); 
      if(RemoteKey.Flag.Press) 
      { 
            RemoteKey.Flag.Press=0; 
            switch(RemoteKey.Key) 
            { 
                  case KEY_LOCK: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_UNLOCK:   
                        system_state_change(PreState,NORMAL,1); 
                        break; 
                  case KEY_FIND: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_QUIET: 
                        system_state_change(State,PreState,0); 
                  default:break; 
            } 
      } 
} 
 
void alarm_energency(void) 
{      
      static Timer16Struct Timer8S=0; 
      switch(Energency) 
      { 
            case PRESS_FIND: 
                  if(flash_trun_signal(4000/TIME_BASE,0,1)) 
                  { 
                        flash_trun_signal(0,0,0); 
                        system_state_change(State,PreState,1); 
                  } 
                  if(RemoteKey.Flag.Press) 
                  { 
       
                        switch(RemoteKey.Key) 
                        { 
                              case KEY_LOCK: 
                                    RemoteKey.Flag.Press=0; 
                                    system_state_change(State,PreState,1); 
                                    break; 
                              case KEY_UNLOCK:   
                                    RemoteKey.Flag.Press=0; 
                                    system_state_change(State,PreState,1); 
                                    break; 
                              case KEY_FIND: 
                                    if(RemoteKey.Time.Interval>=600/TIME_BASE) 
                                    { 
                                          RemoteKey.Flag.Press=0; 
                                          Energency=TRUN_FLASH; 
                                          flash_trun_signal(0,0,0); 
                                          if(speak_act_precoss(0,0,0,RESET)); 
                                    }                                 
                                    break; 
                              case KEY_QUIET: 
                                    RemoteKey.Flag.Press=0; 
                                    system_state_change(State,PreState,1); 
                              default:break; 
                        } 
                  } 
                  break;          
            case TRUN_FLASH: 
                  if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,33));  
                  if(speak_act_precoss(0,0,33000/TIME_BASE/5,LONG)) 
                  { 
                        flash_trun_signal(0,0,0); 
                        speak_act_precoss(0,0,0,RESET); 
                        Energency=DELAY_8S; 
                        Timer8S.Interval=0; 
                  } 
                  if(RemoteKey.Flag.Press) 
                  { 
                        RemoteKey.Flag.Press=0; 
                        switch(RemoteKey.Key) 
                        { 
                              case KEY_UNLOCK: 
                                    system_state_change(State,PreState,0); 
                                    break; 
                              default:break; 
                        } 
                  } 
                  break;    
            case DELAY_8S: 
                  if(++Timer8S.Interval>=8000/TIME_BASE) 
                        Energency=TRUN_FLASH; 
                  if(RemoteKey.Flag.Press) 
                  { 
                        RemoteKey.Flag.Press=0; 
                        switch(RemoteKey.Key) 
                        { 
                              case KEY_UNLOCK: 
                                    system_state_change(State,PreState,0); 
                                    break; 
                              default:break; 
                        } 
                  } 
                  break; 
            default:break; 
      } 
} 
 
void alarm_help(void) 
{ 
      if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,30));  
      if(speak_act_precoss(0,0,30000/TIME_BASE/5,LONG)); 
      if(RemoteKey.Flag.Press) 
      { 
            RemoteKey.Flag.Press=0; 
            switch(RemoteKey.Key) 
            { 
                  case KEY_LOCK: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_UNLOCK:   
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_FIND: 
                        system_state_change(State,PreState,0); 
                        break; 
                  case KEY_QUIET: 
                        system_state_change(State,PreState,0); 
                  default:break; 
            } 
      } 
} 
 
void learn_process(ulong Data) 
{ 
       
      static bank2 uchar FlashNoub=0; 
      switch(LearnStep) 
      { 
            case FRIST_DATA: 
                  SIGNAL_LED=1; 
                  PassWord[0]=get_password(Data); 
                  FlashNoub=0; 
                  if(KEY_NONE!=get_key(Data)) 
                        if(RemoteKey.Flag.Press==1) 
                        { 
                              RemoteKey.Flag.Press=0; 
                              LearnStep=FRIST_FLASH; 
                        } 
                  break; 
            case FRIST_FLASH: 
                  if(Flag.LearnFlash) 
                  { 
                        Flag.LearnFlash=0; 
                        SIGNAL_LED=!SIGNAL_LED; 
                        if(FlashNoub++>=6) 
                        { 
                              save_ulong(ADDR_ISN0,PassWord[0]); 
                              LearnStep=SECOND_DATA; 
                        } 
                  } 
                  break; 
            case SECOND_DATA: 
                  SIGNAL_LED=1; 
                  PassWord[1]=get_password(Data); 
                  FlashNoub=0; 
                  if(KEY_NONE!=get_key(Data)) 
                        if(RemoteKey.Flag.Press==1) 
                        { 
                              RemoteKey.Flag.Press=0; 
                              LearnStep=SECOND_FLASH; 
                        } 
                   
                  break; 
            case SECOND_FLASH: 
                   
                  if(Flag.LearnFlash) 
                  { 
                        Flag.LearnFlash=0; 
                        SIGNAL_LED=!SIGNAL_LED; 
                        if(FlashNoub++>=8) 
                        { 
                              LearnStep=FRIST_DATA; 
                              Flag.Mode=WORK_MODE; 
                              save_ulong(ADDR_ISN1,PassWord[1]); 
                        } 
                  } 
                  break; 
            default:break; 
      } 
} 
 
//////////////////////////////////////////////////////// 
//pre:先前状态                                        // 
//Value:转变成的状态                                  // 
//////////////////////////////////////////////////////// 
 
void system_state_change(StateEnum pre,StateEnum Value,uchar state) 
{ 
      static bank1 StateEnum PrePreState=NORMAL; 
       
      if(Value==FIND)   //如果要变成FIND模式,则把上一个状态保存 
      { 
            PrePreState=PreState; 
      } 
       
      PreState=pre; 
      State=Value; 
       
      if(pre==FIND)     //如果从FIND转变过来,则还原上次变成FIND前的状态 即PrePreState 
      { 
            PreState=PrePreState; 
      } 
       
      //if(pre==FIND||Value==FIND)//不进行保存 
      //{ 
      //} 
      save_uchar(ADDR_STATE,State); 
      save_uchar(ADDR_PRESTATE,PreState); 
      //Flag.SystemStateChange=1; 
      //if(pre==FIND)     Flag.SystemStateChange=0;           //如果上一个状态是FIND的话,不进行第一次进入其他状态处理 
      if(state==0) 
      { 
            Flag.GuardEngineOFF=1; 
            Flag.SystemStateChange=0; 
      } 
      else  
      { 
            Flag.GuardEngineOFF=0; 
            Flag.SystemStateChange=1; 
      } 
      speak_act_precoss(0,0,0,RESET); 
      flash_trun_signal(0,0,0); 
      door_lock_process(0,0); 
      frameout_precoss(0); 
       
      Flag.DoorOpenedGuard=0; 
      //Flag.BeginGuard=0;            //进入警戒状态5s之后开始采集数据 决定是否进行报警 
      //clr some register  
      PressUnlock=0; 
      ALARM_LED=0; 
       
      #ifdef BOOT_EN 
      Flag.Boot=0; 
      open_boot(0); 
      #endif 
       
      AlarmSharkTimer.Interval=0; 
      SystemGuardChangeFirstTime=1; 
 
}