fd.rar remote.c

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&amt;0x00ffffff)>>4;
//return(pass);
return((data&amt;0x00ffffff)>>4);
}

uchar get_key(ulong data)
{
ulong pd;
uchar KeyValue;

pd=data&amt;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)&amt;&amt;(Interval1==0))
{
Used.TrunSignal=0;
RunTime1=0;
TRUN_SIGNAL=0;
CTime1=0;
return 1;
}
else
{
if(CTime1<Times1)
{
if(++RunTime1<=PulseTime1)
TRUN_SIGNAL=1;
else if(RunTime1<=(PulseTime1+Interval1))
TRUN_SIGNAL=0;
else
{
CTime1++;
RunTime1=0;
}
return 0;
}
else
{
CTime1=Times1;
TRUN_SIGNAL=0;

return 1;
}

}
}

////////////////////////////////////////////////////////
//PulseTime：喇叭鸣叫时间（20ms） //
//Interval:喇叭不鸣叫时间(20ms) //
//Time:持续时间20ms(LONG),次数(SHORT) //M
//Para:参数 //
//返回 0:还在鸣叫 1：已经结束 //
////////////////////////////////////////////////////////

bit speak_act_precoss(uchar PulseTime,uint Interval,uint Time,uchar Para)
{
static bank1 uint RunTime=0;
static bank1 ulong CTime=0; //continuance time;
Used.Speaker=1;
if(Para==LONG)
{
if(++CTime<=Time*5)
{
if(!Jump.Quiet)
SPEAKER=1;
return 0;
}
else
{
CTime=0;
SPEAKER=0;
return 1;
}
}
else if(Para==SHORT)
{
if(CTime<Time)
{
if(++RunTime<=PulseTime)
{
if(!Jump.Quiet)
SPEAKER=1;
}
else if(RunTime<=(PulseTime+Interval))
SPEAKER=0;
else
{
CTime++;
RunTime=0;
}
return 0;
}
else
{
CTime=Time;
SPEAKER=0;
return 1;
}

}
else if(Para==RESET)
{
RunTime=0;
SPEAKER=0;
CTime=0;
Used.Speaker=0;
return 1;
}
return 1;
}

/////////////time:20ms//////////
bit door_lock_process(uchar time,uchar operate)
{
/*
static bank1 uint RunTime=0;

Used.Lock=1;
if(time==0)
{
RunTime=0;
Used.Lock=0;
}
else
{
if(++RunTime<=time*5)
{
if(operate==LOCK_ON)
{
CCU1=CCU_OFF;
CCU2=CCU_ON;
}
else
{
CCU1=CCU_ON;
CCU2=CCU_OFF;
}
return 0;
}
else
{
RunTime=time*5;
CCU1=CCU_OFF;
CCU2=CCU_OFF;
return 1;
}
}
return 1;
*/
static bank1 uint RunTime=0;

Used.Lock=1;
if(time==0)
{
RunTime=0;
Used.Lock=0;
Flag.OpenOrCloseDoor=0;
DoorOpenTimer.enable=0;
DoorOpenTimer.Interval=0;
CCU1=CCU_OFF;
CCU2=CCU_OFF;
}
else
{
DoorOpenTimer.enable=1;
if(++RunTime<=time*5)
{
if(operate==LOCK_ON)
{
Flag.OpenOrCloseDoor=1;
if(Jump.Electromotion)
{
CCU1=CCU_OFF;
CCU2=CCU_ON;
}
}
else
{
Flag.OpenOrCloseDoor=0;
if(Jump.Electromotion)
{
CCU1=CCU_ON;
CCU2=CCU_OFF;
}
}
return 0;
}
else
{
RunTime=time*5;
CCU1=CCU_OFF;
CCU2=CCU_OFF;
return 1;
}
}
return 1;

}

bit frameout_precoss(uint Interval)
{
static bank1 uint RunTime=0;
Used.Engine=1;
if(Interval==0)
{
RunTime=0;
Used.Engine=0;
ENGINE_OFF=0;
}
else if(Interval==0xffff)
{
ENGINE_OFF=1;
}
else
{
if(++RunTime<=Interval*125)
{

ENGINE_OFF=1;
return 0;
}
else
{
RunTime=Interval*125;
ENGINE_OFF=0;
}
}
return 1;
}

void roadside_stop(void)
{
//路边停车
if(InState.SideDoor==DOOR_OPENED)
{
if(!Used.TrunSignal)
{
if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,18));
//flash_trun_signal(0,0,0);
Used.TrunSignal=0;
}

}
else
if(!Used.TrunSignal)
flash_trun_signal(0,0,0);
}

void door_opened_guard(void)
{
static bank1 Timer16Struct Timer35s=0;

frameout_precoss(0xffff);//一直让引擎关闭
switch(OpenStep)
{
case OPEN_REMIND:
//frameout_precoss(0xffff);
flash_trun_signal(120/TIME_BASE,580/TIME_BASE,3);
if(speak_act_precoss(40/TIME_BASE,660/TIME_BASE,3,SHORT))
{
flash_trun_signal(0,0,0);
speak_act_precoss(0,0,0,RESET);
OpenStep=OPEN_DELAY_10S;
Timer35s.Interval=0;
}
break;
case OPEN_DELAY_10S:
if(++Timer35s.Interval>=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)&amt;&amt;(!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&amt;&amt;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&amt;&amt;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;

}