单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3354|回复: 2
打印 上一主题 下一主题
收起左侧

EV1527遥控器的解码资料+单片机程序 供大家参考

[复制链接]
跳转到指定楼层
楼主
附件是EV1527的用单片机解码的详细资料,欢迎下载参考!

Altium Designer画的原理图和PCB图如下:(51hei附件中可下载工程文件)


单片机源程序如下:
  1. //#include "main.h"
  2. //#include "remote.h"
  3. //#include "key.h"
  4. #include "include.h"
  5. const uint PULSE_SHORT_MIN=PULSE_SHORT_MIN_TIME/8/4;    //1。8ms
  6. const uint PULSE_SHORT_MAX=PULSE_SHORT_MAX_TIME/8/4;    //3ms
  7. const uint PULSE_LONG_MIN=PULSE_SHORT_MIN_TIME/8/4*3;
  8. const uint PULSE_LONG_MAX=PULSE_SHORT_MAX_TIME/8/4*3;

  9. const uint PULSE_SYN_MAX=PULSE_SHORT_MAX_TIME/8/4*35;
  10. const uint PULSE_SYN_MIN=PULSE_SHORT_MIN_TIME/8/4*20;
  11. const uint DT=(uint)((PULSE_SHORT_MIN_TIME/8/4+PULSE_SHORT_MIN_TIME/8/4)*0.1/2);

  12. bank2 SharkFlagStruct SharkFlag={2};
  13. bank1 ulong PassWord[2];       //waste 2B ram;   20bit

  14. static bank1 RemindStateEnum RemindState=DOOR_OPEN;
  15. static bank1 uchar PressUnlock=0;
  16. static Timer16Struct GuardQuiet5s={0,1};      //延时5s进入警戒状态;
  17. static bank1 AlarmGradeEnum AlarmGrade=Guard;
  18. static bank1 OpenStepEnum     OpenStep=OPEN_REMIND;
  19. static EnergencyEnum Energency=PRESS_FIND;
  20. static bank1 bit SystemGuardChangeFirstTime=0;
  21. bank2 LearnStepEnum LearnStep=FRIST_DATA;
  22. bank2 Timer16Struct AlarmSharkTimer={0,0};

  23. bank1 Timer16Struct DoorOpenTimer={0,0};
  24. bank1 uchar AlarmNoub=0;
  25. bit remote_key_dither(ulong data)
  26. {
  27.       static bank1 ulong LastRemote;
  28.       if(data==LastRemote)
  29.       {
  30.             if(RemoteKey.Flag.FirstPress==1)
  31.             {
  32.                   RemoteKey.Flag.Press=1;
  33.                   RemoteKey.Flag.FirstPress=0;
  34.                   RemoteKey.Key=get_key(data);
  35.                   RemoteKey.Rec=data;
  36.             }
  37.             RemotePressTimeOut.Interval=0;
  38.             RemoteKey.Time.Interval=RemotePressTime.Interval;
  39.             RemotePressTime.enable=1;
  40.             RemotePressTimeOut.enable=1;
  41.             LastRemote=data;
  42.             //RemoteKey.Key=get_key(data);
  43.             return 1;
  44.       }

  45.       else
  46.       {
  47.             //for error process;
  48.             RemoteKey.Flag.Release=0;
  49.             RemoteKey.Flag.Press=0;
  50.             RemoteKey.Flag.FirstPress=1;
  51.             RemotePressTime.Interval=0;
  52.       }  
  53.       LastRemote=data;
  54.       return 0;
  55. }

  56. ulong get_password(ulong data)
  57. {
  58.       //ulong pass;
  59.       //pass=(data&0x00ffffff)>>4;
  60.       //return(pass);
  61.       return((data&0x00ffffff)>>4);
  62. }

  63. uchar get_key(ulong data)
  64. {
  65.       ulong pd;
  66.       uchar KeyValue;
  67.       
  68.       pd=data&0x0f;
  69.       KeyValue=(uchar)(pd);
  70.       
  71.       if(KeyValue==0x08)      return KEY_LOCK;
  72.       else if(KeyValue==0x0c) return KEY_UNLOCK;
  73.       else if(KeyValue==0x03) return KEY_QUIET;
  74.       else if(KeyValue==0x0f) return KEY_FIND;
  75.       #ifdef BOOT_EN
  76.       else if(KeyValue==0x04) return KEY_BOOT;
  77.       #endif
  78.       else                    return KEY_UNKNOW;
  79. }

  80. bit decode(ulong data)
  81. {
  82.       ulong Word;
  83.       Word=get_password(data);
  84.       if(PassWord[0]==Word||PassWord[1]==Word)
  85.             return 1;
  86.       else return 0;
  87. }

  88. //void remind_shutdown(void)
  89. bit remind_shutdown(void)
  90. {
  91.       
  92.       static bank1 Timer16Struct DelayTime=0;
  93.       
  94.       if(InState.SideDoor==DOOR_OPENED)
  95.       {
  96.             RemindState=DOOR_OPEN;
  97.             DelayTime.Interval=0;
  98.       }
  99.       switch(RemindState)
  100.       {
  101.             case DOOR_OPEN:
  102.                   if(InState.SideDoor==DOOR_OPENED)
  103.                         RemindState=DOOR_CLOSE;
  104.                   break;
  105.             case DOOR_CLOSE:
  106.                   if(InState.SideDoor==DOOR_CLOSED)
  107.                   {
  108.                         RemindState=DELAY_5S;
  109.                         DelayTime.Interval=0;
  110.                   }
  111.                   break;
  112.             case DELAY_5S:
  113.                   if(DelayTime.Interval++>=REMIND_SHUT_DELAY_TIME)
  114.                   {
  115.                         DelayTime.Interval=0;
  116.                         RemindState=REMIND;
  117.                         speak_act_precoss(0,0,0,RESET);     //reset speak;
  118.                   }
  119.                   break;
  120.             case REMIND:
  121.                   flash_trun_signal(120/TIME_BASE,1400/TIME_BASE,3);
  122.                   if(speak_act_precoss(40/TIME_BASE,1480/TIME_BASE,3,SHORT))
  123.                   {
  124.                         RemindState=DELAY_60S;
  125.                         flash_trun_signal(0,0,0);
  126.                         speak_act_precoss(0,0,0,RESET);
  127.                   }
  128.                   break;
  129.             case DELAY_60S:
  130.                   if(DelayTime.Interval++>=REMIND_DELAY_60S)
  131.                   {
  132.                         RemindState=CHANGE_STATE;
  133.                         DelayTime.Interval=0;
  134.                   }
  135.                   
  136.                   break;
  137.             case CHANGE_STATE:
  138.                         RemindState=STATE_END;
  139.                   if(Jump.SlefThorth)
  140.                         {
  141.                         system_state_change(State,GUARD_QUIET,1);
  142.                           return 1;
  143.                         }
  144.                        
  145.                         //PreState=State;
  146.                   //State=GUARD_QUIET;
  147.                   
  148.                   break;
  149.             case STATE_END:
  150.                   break;
  151.             default:break;
  152.                
  153.       }
  154.         return 0;
  155. }

  156. bit alarm_led_long_light(uchar LightTime,uchar DrownTime)
  157. {
  158.       static Timer16Struct RunTime=0;
  159.       
  160.       if(LightTime==0)
  161.       {
  162.             RunTime.Interval=0;
  163.             ALARM_LED=0;
  164.       }
  165.       else
  166.       {
  167.             if(++RunTime.Interval<=LightTime*125)
  168.             {
  169.                   ALARM_LED=1;
  170.             }   
  171.             else if(RunTime.Interval<=125*(LightTime+DrownTime))
  172.                   ALARM_LED=0;
  173.             else
  174.             {
  175.                     RunTime.Interval=0;
  176.                              return 1;
  177.                      }
  178.       }
  179.       return 0;
  180. }
  181. /*
  182. ////////////////////////////////////////////
  183. // Times :125ms                           //
  184. // Second: 1s                             //
  185. ////////////////////////////////////////////
  186. void flash_alarm_led(uchar Times,uchar Second)
  187. {
  188.       if(AlarmLed.Flag.ms125)
  189.       {
  190.             AlarmLed.Flag.ms125=0;
  191.             AlarmLed.Flag.Time++;
  192.             if(AlarmLed.Flag.Time<=Times)
  193.                   ALARM_LED=!ALARM_LED;
  194.             else if(AlarmLed.Flag.Time<=Times+Second*8)      //2s
  195.                   ALARM_LED=0;
  196.             else
  197.                   AlarmLed.Flag.Time=0;
  198.       }
  199. }
  200. */
  201. bit flash_alarm_led(uchar Times,uchar Second)
  202. {
  203.       if(AlarmLed.Flag.ms125)
  204.       {
  205.             AlarmLed.Flag.ms125=0;
  206.             AlarmLed.Flag.Time++;
  207.             if(AlarmLed.Flag.Time<=Times)
  208.                   ALARM_LED=!ALARM_LED;
  209.                   //ALARM_LED=1;
  210.             else if(AlarmLed.Flag.Time<=Times+Second*8)      //2s
  211.                   ALARM_LED=0;
  212.             else
  213.             {
  214.                   AlarmLed.Flag.Time=0;
  215.                       return 1;
  216.               }
  217.       }
  218.       return 0;
  219. }


  220.       
  221. void signal_led_alarm(AlarmGradeEnum state)
  222. {
  223.       
  224.       if(state==Guard)
  225.             flash_alarm_led(4,2);
  226.       else if(state==Shaked)
  227.             flash_alarm_led(6,2);
  228.       else if(state==Opened)
  229.             alarm_led_long_light(4,4);
  230.       else if(state==Unchain)
  231.             alarm_led_long_light(6,0);
  232. }
  233.       
  234. uchar flash_trun_signal(uint PulseTime1,uint Interval1,uchar Times1)
  235. {
  236.       static bank2 uint RunTime1=0;
  237.       static bank2 uchar CTime1=0;         //continuance time;
  238.       
  239.       Used.TrunSignal=1;
  240.       if((PulseTime1==0)&&(Interval1==0))
  241.       {
  242.             Used.TrunSignal=0;
  243.             RunTime1=0;
  244.             TRUN_SIGNAL=0;
  245.             CTime1=0;
  246.             return 1;
  247.       }
  248.       else
  249.       {
  250.             if(CTime1<Times1)
  251.             {
  252.                   if(++RunTime1<=PulseTime1)
  253.                         TRUN_SIGNAL=1;
  254.                   else if(RunTime1<=(PulseTime1+Interval1))
  255.                         TRUN_SIGNAL=0;
  256.                   else
  257.                   {
  258.                         CTime1++;
  259.                         RunTime1=0;   
  260.                   }
  261.                   return 0;
  262.             }
  263.             else
  264.             {
  265.                   CTime1=Times1;
  266.                   TRUN_SIGNAL=0;
  267.                   
  268.                   return 1;
  269.             }
  270.            
  271.       }
  272. }

  273. ////////////////////////////////////////////////////////
  274. //PulseTime:喇叭鸣叫时间(20ms)                     //
  275. //Interval:喇叭不鸣叫时间(20ms)                       //
  276. //Time:持续时间20ms(LONG),次数(SHORT)                 //M
  277. //Para:参数                                           //
  278. //返回 0:还在鸣叫 1:已经结束                         //
  279. ////////////////////////////////////////////////////////

  280. bit speak_act_precoss(uchar PulseTime,uint Interval,uint Time,uchar Para)
  281. {
  282.       static bank1 uint RunTime=0;
  283.       static bank1 ulong CTime=0;         //continuance time;
  284.       Used.Speaker=1;
  285.       if(Para==LONG)
  286.       {
  287.             if(++CTime<=Time*5)
  288.             {
  289.                   if(!Jump.Quiet)
  290.                         SPEAKER=1;
  291.                   return 0;
  292.             }
  293.             else
  294.             {
  295.                   CTime=0;
  296.                   SPEAKER=0;
  297.                   return 1;
  298.             }
  299.       }
  300.       else if(Para==SHORT)
  301.       {
  302.             if(CTime<Time)
  303.             {
  304.                   if(++RunTime<=PulseTime)
  305.                   {
  306.                         if(!Jump.Quiet)
  307.                               SPEAKER=1;
  308.                   }
  309.                   else if(RunTime<=(PulseTime+Interval))
  310.                         SPEAKER=0;
  311.                   else
  312.                   {
  313.                         CTime++;
  314.                         RunTime=0;
  315.                   }
  316.                   return 0;
  317.             }
  318.             else
  319.             {
  320.                   CTime=Time;
  321.                   SPEAKER=0;
  322.                   return 1;
  323.             }
  324.             
  325.       }
  326.       else if(Para==RESET)
  327.       {
  328.             RunTime=0;
  329.             SPEAKER=0;
  330.             CTime=0;
  331.             Used.Speaker=0;
  332.             return 1;
  333.       }                       
  334.       return 1;     
  335. }  

  336. /////////////time:20ms//////////
  337. bit door_lock_process(uchar time,uchar operate)
  338. {
  339.       /*
  340.       static bank1 uint RunTime=0;
  341.       
  342.       Used.Lock=1;
  343.       if(time==0)
  344.       {
  345.             RunTime=0;
  346.             Used.Lock=0;
  347.       }
  348.       else
  349.       {
  350.             if(++RunTime<=time*5)
  351.             {
  352.                   if(operate==LOCK_ON)
  353.                   {
  354.                         CCU1=CCU_OFF;
  355.                         CCU2=CCU_ON;
  356.                   }
  357.                   else
  358.                   {
  359.                         CCU1=CCU_ON;
  360.                         CCU2=CCU_OFF;
  361.                   }
  362.                   return 0;
  363.             }
  364.             else
  365.             {
  366.                   RunTime=time*5;
  367.                   CCU1=CCU_OFF;
  368.                   CCU2=CCU_OFF;
  369.                   return 1;
  370.             }
  371.       }
  372.       return 1;
  373.       */
  374.       static bank1 uint RunTime=0;
  375.       
  376.       Used.Lock=1;
  377.       if(time==0)
  378.       {
  379.             RunTime=0;
  380.             Used.Lock=0;
  381.             Flag.OpenOrCloseDoor=0;
  382.             DoorOpenTimer.enable=0;
  383.             DoorOpenTimer.Interval=0;
  384.             CCU1=CCU_OFF;
  385.             CCU2=CCU_OFF;
  386.       }
  387.       else
  388.       {
  389.             DoorOpenTimer.enable=1;
  390.             if(++RunTime<=time*5)
  391.             {
  392.                   if(operate==LOCK_ON)
  393.                   {
  394.                         Flag.OpenOrCloseDoor=1;
  395.                         if(Jump.Electromotion)
  396.                         {
  397.                               CCU1=CCU_OFF;
  398.                               CCU2=CCU_ON;
  399.                         }
  400.                   }
  401.                   else
  402.                   {
  403.                         Flag.OpenOrCloseDoor=0;
  404.                         if(Jump.Electromotion)
  405.                         {
  406.                               CCU1=CCU_ON;
  407.                               CCU2=CCU_OFF;
  408.                         }
  409.                   }
  410.                   return 0;
  411.             }
  412.             else
  413.             {
  414.                   RunTime=time*5;
  415.                   CCU1=CCU_OFF;
  416.                   CCU2=CCU_OFF;
  417.                   return 1;
  418.             }
  419.       }
  420.       return 1;
  421.       
  422. }

  423. bit frameout_precoss(uint Interval)
  424. {
  425.       static bank1 uint RunTime=0;
  426.       Used.Engine=1;
  427.       if(Interval==0)
  428.       {
  429.             RunTime=0;
  430.             Used.Engine=0;
  431.             ENGINE_OFF=0;
  432.       }
  433.       else if(Interval==0xffff)
  434.       {
  435.             ENGINE_OFF=1;
  436.       }
  437.       else
  438.       {
  439.             if(++RunTime<=Interval*125)
  440.             {

  441.                   ENGINE_OFF=1;
  442.                   return 0;
  443.             }
  444.             else
  445.             {
  446.                   RunTime=Interval*125;
  447.                   ENGINE_OFF=0;
  448.             }
  449.       }
  450.       return 1;
  451. }

  452. void roadside_stop(void)
  453. {
  454.       //路边停车
  455.       if(InState.SideDoor==DOOR_OPENED)
  456.       {
  457.             if(!Used.TrunSignal)
  458.             {
  459.                   if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,18));
  460.                        //flash_trun_signal(0,0,0);
  461.                   Used.TrunSignal=0;
  462.             }
  463.       
  464.       }
  465.       else
  466.            if(!Used.TrunSignal)
  467.                  flash_trun_signal(0,0,0);
  468. }

  469. void door_opened_guard(void)
  470. {     
  471.       static bank1 Timer16Struct Timer35s=0;
  472.       
  473.       frameout_precoss(0xffff);//一直让引擎关闭
  474.       switch(OpenStep)
  475.       {
  476.             case OPEN_REMIND:      
  477.                     //frameout_precoss(0xffff);                        
  478.                   flash_trun_signal(120/TIME_BASE,580/TIME_BASE,3);
  479.                   if(speak_act_precoss(40/TIME_BASE,660/TIME_BASE,3,SHORT))
  480.                   {      
  481.                         flash_trun_signal(0,0,0);
  482.                         speak_act_precoss(0,0,0,RESET);
  483.                         OpenStep=OPEN_DELAY_10S;
  484.                         Timer35s.Interval=0;
  485.                   }
  486.                   break;
  487.             case OPEN_DELAY_10S:
  488.                   if(++Timer35s.Interval>=10000/TIME_BASE)
  489.                         OpenStep=OPEN_ALARM;
  490.                         if(InState.SideDoor!=DOOR_OPENED)
  491.                                 Flag.DoorOpenedGuard=0;
  492.                   break;      
  493.             case OPEN_ALARM:
  494.                   flash_trun_signal(500/TIME_BASE,500/TIME_BASE,240);         
  495.                   if(speak_act_precoss(0,0,240000/TIME_BASE/5,LONG))
  496.                   {
  497.                         OpenStep=OPEN_STOP;
  498.                         flash_trun_signal(0,0,0);
  499.                         speak_act_precoss(0,0,0,RESET);     
  500.                   }
  501.                   break;
  502.             case OPEN_STOP:
  503.                     Flag.DoorOpenedGuard=0;
  504.                   break;
  505.             default:break;
  506.       }
  507. }

  508. #ifdef BOOT_EN
  509. bit open_boot(uchar Interval)
  510. {
  511.       static bank1 BootTimer=0;
  512.       if(Interval==0)
  513.       {
  514.             BOOT=0;
  515.             BootTimer=0;
  516.       }
  517.       else
  518.       {
  519.             if(++BootTimer<=Interval*5)
  520.             {

  521.                   BOOT=1;
  522.                   return 0;
  523.             }
  524.             else
  525.             {
  526.                   BootTimer=Interval*5;
  527.                   BOOT=0;
  528.                   return 1;
  529.             }
  530.       }
  531.       return 1;
  532.       
  533. }
  534. #endif

  535. void normal_process(void)
  536. {
  537.       static bank1 AutoRestoreStruct AutoRestore=0;
  538.       
  539.       if(Flag.SystemStateChange)
  540.       {
  541.             RemindState=DOOR_OPEN;
  542.             
  543.             AutoRestore.Flag.Shaked=0;
  544.             AutoRestore.Flag.Opened=0;
  545.             AutoRestore.Time.Interval=0;
  546.             Flag.RememTouch=0;
  547.             switch(PreState)
  548.             {
  549.                   
  550.                   case GUARD_SOUND:
  551.                         door_lock_process(500/TIME_BASE/5,LOCK_OFF);
  552.                         if(PressUnlock==0)
  553.                               speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT);
  554.                         if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2))
  555.                         {
  556.                                     Flag.SystemStateChange=0;
  557.                                     flash_trun_signal(0,0,0);
  558.                                     speak_act_precoss(0,0,0,RESET);
  559.                                     if(Jump.Electromotion)  door_lock_process(0,0);
  560.                         }
  561.                         break;
  562.                   case GUARD_QUIET:
  563.                         door_lock_process(500/TIME_BASE/5,LOCK_OFF);
  564.                         //if(speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT));
  565.                         if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2))
  566.                         {
  567.                                     Flag.SystemStateChange=0;
  568.                                     flash_trun_signal(0,0,0);
  569.                                     speak_act_precoss(0,0,0,RESET);
  570.                                     if(Jump.Electromotion) door_lock_process(0,0);
  571.                         }
  572.                         break;
  573.                   case RUN:
  574.                         if(PressUnlock>0)
  575.                         {
  576.                                door_lock_process(500/TIME_BASE/5,LOCK_OFF);
  577.                               //if(speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT));
  578.                               if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2))
  579.                               {
  580.                                           Flag.SystemStateChange=0;
  581.                                           flash_trun_signal(0,0,0);
  582.                                           speak_act_precoss(0,0,0,RESET);
  583.                                           if(Jump.Electromotion) door_lock_process(0,0);
  584.                               }     
  585.                         }
  586.                         else
  587.                         {
  588.                               if(door_lock_process(500/TIME_BASE/5,LOCK_OFF))
  589.                               {
  590.                                     Flag.SystemStateChange=0;
  591.                                     if(Jump.Electromotion) door_lock_process(0,0);
  592.                               }
  593.                         }
  594.                         break;
  595.                   default:
  596.                         Flag.SystemStateChange=0;
  597.                         break;
  598.             }
  599.       }
  600.       else
  601.       {
  602.             if(RemoteKey.Flag.Press)
  603.             {
  604.                   RemoteKey.Flag.Press=0;
  605.                   switch(RemoteKey.Key)
  606.                   {
  607.                         case KEY_LOCK:
  608.                               system_state_change(State,GUARD_SOUND,1);
  609.                               //break;
  610.                                         return ;
  611.                         case KEY_QUIET:
  612.                               system_state_change(State,GUARD_QUIET,1);
  613.                               //break;
  614.                                         return ;
  615.                         case KEY_FIND:
  616.                               system_state_change(State,FIND,1);
  617.                               //break;
  618.                                         return ;
  619.                         case KEY_UNLOCK:
  620.                               if(++PressUnlock<=3)
  621.                               {
  622.                                     flash_trun_signal(0,0,0);
  623.                                     Flag.SystemStateChange=1;
  624.                               }
  625.                               else
  626.                                     PressUnlock=3;
  627.                               break;
  628.                         #ifdef BOOT_EN
  629.                         
  630.                         case KEY_BOOT:
  631.                               Flag.Boot=1;
  632.                               open_boot(0);
  633.                               break;
  634.                         #endif
  635.                         default:
  636.                               break;
  637.                   }
  638.             }
  639.             // 进入行驶
  640.             
  641.             #ifdef BOOT_EN
  642.             if(Flag.Boot)
  643.             {
  644.                   Flag.Boot=0;
  645.                   open_boot(500/TIME_BASE/5);
  646.             }
  647.             #endif
  648.             if(InState.Acc)
  649.             {
  650.                   system_state_change(State,RUN,1);
  651.                   return ;
  652.             }
  653.             //提醒设置防盗    for remind to shutdown
  654.             //if(PreState==RUN)
  655.                   //remind_shutdown();
  656.                 if(PreState==RUN)
  657.                         Flag.FromRemindShutDown=remind_shutdown();
  658.             //路边停车
  659.             roadside_stop();
  660.             
  661.             //for auto restore
  662.             if(!InState.Shake)
  663.                   AutoRestore.Flag.Shaked=1;
  664.             if(InState.SideDoor==DOOR_OPENED)
  665.             {
  666.                   if(AlarmNoub>3)   AlarmNoub=3;
  667.                   if(AlarmNoub>0)
  668.                   {
  669.                           AlarmNoub=0;
  670.                         Flag.RememTouch=1;
  671.                           alarm_led_long_light(0,0);
  672.                   }
  673.                   AutoRestore.Flag.Opened=1;   
  674.                   AlarmGrade=Guard;
  675.             }      
  676.                   
  677.             if((!AutoRestore.Flag.Shaked)&&(!AutoRestore.Flag.Opened))
  678.             {
  679.                   if(PreState==GUARD_QUIET||PreState==GUARD_SOUND)
  680.                         if(AutoRestore.Time.Interval++>=AUTO_RESTORE_TIME)
  681.                         {
  682.                               system_state_change(State,PreState,1);
  683.                               AutoRestore.Time.Interval=0;
  684.                         }
  685.             }
  686.             else  AutoRestore.Time.Interval=0;
  687.             //记忆触发
  688.             if(Flag.RememTouch)
  689.             {
  690.                         speak_act_precoss(50/TIME_BASE,950/TIME_BASE,1,SHORT);
  691.                         if(alarm_led_long_light(6,1))
  692.                     {
  693.                                 alarm_led_long_light(0,0);                                  
  694.                                 SIGNAL_LED=0;
  695.                                 AlarmNoub=0;
  696.                                 speak_act_precoss(0,0,0,RESET);
  697.                                 Flag.RememTouch=0;
  698.                      }
  699.                 }
  700.       }
  701. }

  702. void guard_process(uchar Mode)
  703. {
  704.         if(GuardQuiet5s.Interval++>=5000/TIME_BASE)
  705.         {
  706.               GuardQuiet5s.enable=0;
  707.               GuardQuiet5s.Interval=0;
  708.               Flag.BeginGuard=1;
  709.         }
  710.         if(Flag.BeginGuard)
  711.         {
  712.               if(Flag.DoorOpenedGuard)
  713.                     door_opened_guard();
  714.               else
  715.               {
  716.                     if(!InState.Shake)
  717.                     {
  718.                      
  719.                              if(AlarmSharkTimer.Interval==0)
  720.                              {
  721.                                       SharkFlag.Time=1;
  722.                                      AlarmSharkTimer.enable=1;
  723.                                   }
  724.                                   else if(AlarmSharkTimer.Interval<15000/TIME_BASE)
  725.                                           SharkFlag.Time=2;
  726.                                   else
  727.                                   {
  728.                                            SharkFlag.Time=1;
  729.                                           AlarmSharkTimer.enable=1;
  730.                           }
  731.                           AlarmSharkTimer.Interval=0;
  732.                           if(Mode==QUIET_MODE)
  733.                                   system_state_change(State,ALARM_QUIET,1);
  734.                           else if(Mode==SOUND_MODE)
  735.                                   system_state_change(State,ALARM_SOUND,1);
  736.                     }
  737.                     if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake)
  738.                           system_state_change(State,ALARM_DOOR_OPENED,1);
  739.               }
  740.         }      

  741. }

  742. void guard_quiet_process(void)
  743. {
  744.       // 5s later into the guard mode
  745.       signal_led_alarm(AlarmGrade);
  746.       
  747.       if(!Flag.GuardEngineOFF)
  748.       {
  749.             if(PreState!=FIND)
  750.             {
  751.                   if(Flag.DoorOpenedGuard)
  752.                         Flag.GuardEngineOFF=1;
  753.                   if(frameout_precoss(40))
  754.                         Flag.GuardEngineOFF=1;
  755.             }
  756.             else Flag.GuardEngineOFF=1;         
  757.       }
  758.       if(Flag.SystemStateChange)
  759.       {
  760.             if(PreState!=FIND)
  761.             {
  762.                   if(!Flag.FromRemindShutDown)
  763.                                 door_lock_process(500/TIME_BASE/5,LOCK_ON);
  764.                   if(flash_trun_signal(500/TIME_BASE,200/TIME_BASE,1))
  765.                   {
  766.                               Flag.SystemStateChange=0;
  767.                               flash_trun_signal(0,0,0);
  768.                               if(Jump.Electromotion)  door_lock_process(0,0);
  769.                               speak_act_precoss(0,0,0,RESET);
  770.                   }
  771.             GuardQuiet5s.Interval=0;
  772.             }
  773.             else Flag.SystemStateChange=0;
  774.             Flag.BeginGuard=0;
  775.             /////////////////////////////////当进入防盗系统的时候 如果门未关好 提醒用户关门////////////////
  776.             if(SystemGuardChangeFirstTime)
  777.             {
  778.                     if(InState.SideDoor==DOOR_OPENED)
  779.                     {
  780.                           Flag.DoorOpenedGuard=1;
  781.                           OpenStep=OPEN_REMIND;
  782.                     }
  783.                     else
  784.                             Flag.DoorOpenedGuard=0;
  785.             }
  786.             SystemGuardChangeFirstTime=0;
  787.                   AlarmSharkTimer.enable=0;
  788.                   AlarmSharkTimer.Interval=0;
  789.       }
  790.       else
  791.       {
  792.               guard_process(QUIET_MODE);
  793.                 if(RemoteKey.Flag.Press)
  794.                 {
  795.                       RemoteKey.Flag.Press=0;
  796.                       switch(RemoteKey.Key)
  797.                       {
  798.                             case KEY_LOCK:
  799.                                   system_state_change(State,GUARD_SOUND,1);
  800.                                   break;
  801.                             case KEY_UNLOCK:
  802.                                   ALARM_LED=0;
  803.                                   system_state_change(State,NORMAL,1);
  804.                                   break;
  805.                             case KEY_FIND:
  806.                                   system_state_change(State,FIND,1);
  807.                                   break;
  808.                             case KEY_QUIET:
  809.                                   Flag.GuardEngineOFF=0;
  810.                                   frameout_precoss(0);
  811.                                   Flag.SystemStateChange=1;
  812.                                   break;
  813.                             #ifdef BOOT_EN
  814.                             case KEY_BOOT:
  815.                                   Flag.Boot=1;
  816.                                   open_boot(0);
  817.                                   break;
  818.                             #endif
  819.                            
  820.                             default:break;
  821.                       }
  822.                 }
  823.       }
  824. }

  825. void guard_sound_process(void)
  826. {
  827.       //flash_alarm_led(4,2);
  828.       signal_led_alarm(AlarmGrade);
  829.       if(!Flag.GuardEngineOFF)
  830.       {
  831.             if(PreState!=FIND)
  832.             {
  833.                   if(Flag.DoorOpenedGuard)
  834.                   {
  835.                         Flag.GuardEngineOFF=1;
  836.                   }
  837.                   if(frameout_precoss(40))
  838.                         Flag.GuardEngineOFF=1;
  839.             }
  840.             else Flag.GuardEngineOFF=1;         
  841.       }
  842.       
  843.       if(Flag.SystemStateChange)
  844.       {
  845.             if(PreState!=FIND)
  846.             {
  847.                   speak_act_precoss(50/TIME_BASE,200/TIME_BASE,1,SHORT);
  848.                   door_lock_process(500/TIME_BASE/5,LOCK_ON);
  849.                   if(flash_trun_signal(500/TIME_BASE,200/TIME_BASE,1))
  850.                   {
  851.                               Flag.SystemStateChange=0;
  852.                               speak_act_precoss(0,0,0,RESET);
  853.                               flash_trun_signal(0,0,0);
  854.                               if(Jump.Electromotion) door_lock_process(0,0);
  855.                   }
  856.                   GuardQuiet5s.enable=1;
  857.                   GuardQuiet5s.Interval=0;
  858.             }
  859.             else Flag.SystemStateChange=0;
  860.             Flag.BeginGuard=0;
  861.             /////////////////////////////////当进入防盗系统的时候 如果门未关好 提醒用户关门////////////////
  862.             if(SystemGuardChangeFirstTime)
  863.             {
  864.                     if(InState.SideDoor==DOOR_OPENED)
  865.                     {
  866.                           Flag.DoorOpenedGuard=1;
  867.                           OpenStep=OPEN_REMIND;
  868.                     }
  869.                                 else Flag.DoorOpenedGuard=0;
  870.                         }
  871.                         SystemGuardChangeFirstTime=0;
  872.             AlarmSharkTimer.enable=0;
  873.             AlarmSharkTimer.Interval=0;
  874.             
  875.       }
  876.       else
  877.       {     
  878.                 guard_process(SOUND_MODE);
  879.             if(RemoteKey.Flag.Press)
  880.             {
  881.                   RemoteKey.Flag.Press=0;
  882.                   switch(RemoteKey.Key)
  883.                   {
  884.                         case KEY_LOCK:
  885.                               system_state_change(State,GUARD_SOUND,1);
  886.                               break;
  887.                               
  888.                         case KEY_UNLOCK:
  889.                               ALARM_LED=0;
  890.                               system_state_change(State,NORMAL,1);
  891.                               break;
  892.                         case KEY_FIND:
  893.                               system_state_change(State,FIND,1);
  894.                               break;
  895.                         case KEY_QUIET:
  896.                               system_state_change(State,GUARD_QUIET,1);
  897.                               break;
  898.                         default:break;
  899.                   }
  900.             }
  901.       }
  902. }

  903. void find_process(void)
  904. {
  905.       flash_trun_signal(500/TIME_BASE,500/TIME_BASE,5);
  906.       if(speak_act_precoss(0,0,5000/TIME_BASE/5,LONG))
  907.       {
  908.             speak_act_precoss(0,0,0,RESET);
  909.             flash_trun_signal(0,0,0);
  910.             system_state_change(State,PreState,0);
  911.       }      
  912.       if(RemoteKey.Flag.Press)
  913.       {
  914.             RemoteKey.Flag.Press=0;
  915.             switch(RemoteKey.Key)
  916.             {
  917.                   case KEY_LOCK:
  918.                         system_state_change(State,PreState,0);
  919.                         break;
  920.                   case KEY_UNLOCK:
  921.                         
  922.                         system_state_change(State,PreState,0);
  923.                         break;
  924.                   case KEY_FIND:
  925.                         system_state_change(State,PreState,0);
  926.                         break;
  927.                   case KEY_QUIET:
  928.                         system_state_change(State,PreState,0);
  929.                   default:break;
  930.             }
  931.       }
  932. }


  933. typedef struct
  934. {
  935.       unsigned char Lock:1;
  936.       unsigned char Unlock:1;
  937.       unsigned char Help:1;
  938.       unsigned char Call:1;
  939.       unsigned char DoorOpened:1;
  940.       unsigned char State:2;
  941. }RunStruct;
  942. void run_process(void)
  943. {
  944.       static bank1 RunStruct Run=0;
  945.       
  946.       ///////////15s后自动锁门////////
  947.       static Timer16Struct AutoLock=0;
  948.       if(Flag.SystemStateChange)
  949.       {
  950.             AlarmNoub=0;
  951.             Flag.SystemStateChange=0;
  952.             Run.State=0;
  953.             AutoLock.Interval=0;
  954.             Run.DoorOpened=0;
  955.       }
  956.       switch(Run.State)
  957.       {
  958.             case 0:
  959.                   if(InState.SideDoor)
  960.                         Run.DoorOpened=1;
  961.                   if(!InState.SideDoor&&Run.DoorOpened)
  962.                   {
  963.                         Run.State=0;
  964.                         Run.DoorOpened=0;
  965.                         AutoLock.Interval=0;
  966.                   }
  967.                   if(++AutoLock.Interval>=15000/TIME_BASE)
  968.                   {
  969.                         Run.State=1;
  970.                         AutoLock.Interval=0;
  971.                   }
  972.                   break;
  973.             case 1:
  974.                   if(InState.Brake)
  975.                   {
  976.                         Run.Lock=1;
  977.                         Run.State=2;
  978.                   }
  979.                   break;
  980.             case 2:
  981.                   if(InState.SideDoor)
  982.                         Run.DoorOpened=1;
  983.                   if(!InState.SideDoor&&Run.DoorOpened)
  984.                   {
  985.                         Run.State=0;
  986.                         Run.DoorOpened=0;
  987.                   }
  988.                   break;      
  989.             default:
  990.                   Run.State=2;
  991.                   break;
  992.       }
  993.       /////////////////////////////////
  994.       if(RemoteKey.Flag.Press)
  995.       {
  996.             switch(RemoteKey.Key)
  997.             {
  998.                   case KEY_LOCK:
  999.                                   Run.Unlock=0;
  1000.                         Run.Lock=1;
  1001.                         door_lock_process(0,0);
  1002.                         RemoteKey.Flag.Press=0;
  1003.                         break;
  1004.                   case KEY_UNLOCK:
  1005.                                   Run.Lock=0;
  1006.                         Run.Unlock=1;
  1007.                         door_lock_process(0,0);
  1008.                         RemoteKey.Flag.Press=0;
  1009.                         break;
  1010.                   case KEY_FIND:
  1011.                         if(RemoteKey.Time.Interval>=1500/TIME_BASE)
  1012.                         {
  1013.                               RemoteKey.Flag.Press=0;
  1014.                               system_state_change(State,ALARM_HELP,1);
  1015.                         }
  1016.                         break;
  1017.                   case KEY_QUIET:
  1018.                         if(RemoteKey.Time.Interval>=1500/TIME_BASE)
  1019.                         {
  1020.                               RemoteKey.Flag.Press=0;
  1021.                               Energency=PRESS_FIND;
  1022.                               system_state_change(State,ALARM_ENERGENCY,1);
  1023.                         }
  1024.                         break;
  1025.                   default:break;
  1026.             }
  1027.       }
  1028.       
  1029.       roadside_stop();
  1030.       
  1031.       if(!InState.Acc)
  1032.       {
  1033.             //PreState=State;
  1034.             //State=NORMAL;
  1035.             system_state_change(State,NORMAL,1);
  1036.       }
  1037.       if(Run.Unlock)
  1038.       {
  1039.             if(door_lock_process(500/TIME_BASE/5,LOCK_OFF))
  1040.             {
  1041.                   Run.Unlock=0;
  1042.                   if(Jump.Electromotion)
  1043.                         door_lock_process(0,0);
  1044.             }
  1045.       }
  1046.       else if(Run.Lock)
  1047.             if(door_lock_process(500/TIME_BASE/5,LOCK_ON))
  1048.             {
  1049.                   Run.Lock=0;
  1050.                   if(Jump.Electromotion)
  1051.                         door_lock_process(0,0);
  1052.             }
  1053. }
  1054. void alarm_down_opened_process(void)
  1055. {
  1056.       //alarm_led_long_light(4,4);
  1057.       
  1058.       if(Flag.SystemStateChange)
  1059.       {
  1060.             Flag.SystemStateChange=0;
  1061.             if(AlarmNoub++>=3) AlarmNoub=3;
  1062.       }
  1063.       
  1064.       if(AlarmGrade<=Opened)
  1065.             AlarmGrade=Opened;
  1066.       signal_led_alarm(AlarmGrade);
  1067.       frameout_precoss(60);
  1068.       flash_trun_signal(500/TIME_BASE,500/TIME_BASE,26);
  1069.       if(speak_act_precoss(0,0,26000/TIME_BASE/5,LONG))
  1070.       {
  1071.             speak_act_precoss(0,0,0,RESET);
  1072.             flash_trun_signal(0,0,0);
  1073.             system_state_change(State,PreState,0);
  1074.       }
  1075.       if(RemoteKey.Flag.Press)
  1076.       {
  1077.             RemoteKey.Flag.Press=0;
  1078.             switch(RemoteKey.Key)
  1079.             {
  1080.                   case KEY_LOCK:
  1081.                         system_state_change(State,PreState,0);
  1082.                         break;
  1083.                   case KEY_UNLOCK:
  1084.                         system_state_change(PreState,NORMAL,1);
  1085.                         break;
  1086.                   case KEY_FIND:
  1087.                         system_state_change(State,PreState,0);
  1088.                         break;
  1089.                   case KEY_QUIET:
  1090.                         system_state_change(State,PreState,0);
  1091.                   default:break;
  1092.             }
  1093.       }
  1094. }

  1095. void shark_alarm(uchar Mode)
  1096. {
  1097.         if(Flag.SystemStateChange)
  1098.       {
  1099.             Flag.SystemStateChange=0;
  1100.             if(AlarmNoub++>=3) AlarmNoub=3;
  1101.       }
  1102.       if(AlarmGrade<=Shaked)
  1103.             AlarmGrade=Shaked;
  1104.         signal_led_alarm(AlarmGrade);
  1105.         if(SharkFlag.Time==1)
  1106.         {
  1107.               //if(frameout_precoss(60));
  1108.               if(Mode==SOUND_MODE)
  1109.                         if(speak_act_precoss(50/TIME_BASE,950/TIME_BASE,5,SHORT));
  1110.                 if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,5))
  1111.               {
  1112.                     speak_act_precoss(0,0,0,RESET);
  1113.                     flash_trun_signal(0,0,0);
  1114.                     system_state_change(State,PreState,0);
  1115.               }

  1116.         }
  1117.       else if(SharkFlag.Time==2)
  1118.       {
  1119.               if(frameout_precoss(61));
  1120.               if(Mode==SOUND_MODE)  
  1121.                         if(speak_act_precoss(0,0,27000/TIME_BASE/5,LONG));
  1122.               if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,26))
  1123.               {
  1124.                     speak_act_precoss(0,0,0,RESET);
  1125.                     flash_trun_signal(0,0,0);
  1126.                     system_state_change(State,PreState,0);
  1127.               }
  1128.       }      
  1129.         if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake)
  1130.             system_state_change(PreState,ALARM_DOOR_OPENED,1);
  1131. }
  1132. void alarm_quiet_process(void)
  1133. {
  1134.       //if(Flag.SystemStateChange)
  1135.       //{
  1136.             //Flag.SystemStateChange=0;
  1137.             //if(AlarmNoub++>=3) AlarmNoub=3;
  1138.       //}
  1139.       //if(AlarmGrade<=Shaked)
  1140.             //AlarmGrade=Shaked;
  1141.       
  1142.       
  1143.         shark_alarm(QUIET_MODE);
  1144.       
  1145.       if(RemoteKey.Flag.Press)
  1146.       {
  1147.             RemoteKey.Flag.Press=0;
  1148.             switch(RemoteKey.Key)
  1149.             {
  1150.                   case KEY_LOCK:
  1151.                         system_state_change(State,PreState,0);
  1152.                         break;
  1153.                   case KEY_UNLOCK:
  1154.                         
  1155.                         system_state_change(PreState,NORMAL,1);
  1156.                         break;
  1157.                   case KEY_FIND:
  1158.                         system_state_change(State,PreState,0);
  1159.                         break;
  1160.                   case KEY_QUIET:
  1161.                         system_state_change(State,PreState,0);
  1162.                   default:break;
  1163.             }
  1164.       }
  1165. }

  1166. void alarm_sound_process(void)
  1167. {
  1168.       
  1169.       //signal_led_alarm(AlarmGrade);
  1170.       
  1171.         shark_alarm(SOUND_MODE);
  1172.       //if(InState.SideDoor==DOOR_OPENED)
  1173.       //if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake)
  1174.             //system_state_change(PreState,ALARM_DOOR_OPENED,1);
  1175.       if(RemoteKey.Flag.Press)
  1176.       {
  1177.             RemoteKey.Flag.Press=0;
  1178.             switch(RemoteKey.Key)
  1179.             {
  1180.                   case KEY_LOCK:
  1181.                         system_state_change(State,PreState,0);
  1182.                         break;
  1183.                   case KEY_UNLOCK:  
  1184.                         system_state_change(PreState,NORMAL,1);
  1185.                         break;
  1186.                   case KEY_FIND:
  1187.                         system_state_change(State,PreState,0);
  1188.                         break;
  1189.                   case KEY_QUIET:
  1190.                         system_state_change(State,PreState,0);
  1191.                   default:break;
  1192.             }
  1193.       }
  1194. }

  1195. void alarm_energency(void)
  1196. {     
  1197.       static Timer16Struct Timer8S=0;
  1198.       switch(Energency)
  1199.       {
  1200.             case PRESS_FIND:
  1201.                   if(flash_trun_signal(4000/TIME_BASE,0,1))
  1202.                   {
  1203.                         flash_trun_signal(0,0,0);
  1204.                         system_state_change(State,PreState,1);
  1205.                   }
  1206.                   if(RemoteKey.Flag.Press)
  1207.                   {
  1208.       
  1209.                         switch(RemoteKey.Key)
  1210.                         {
  1211.                               case KEY_LOCK:
  1212.                                     RemoteKey.Flag.Press=0;
  1213.                                     system_state_change(State,PreState,1);
  1214.                                     break;
  1215.                               case KEY_UNLOCK:  
  1216.                                     RemoteKey.Flag.Press=0;
  1217.                                     system_state_change(State,PreState,1);
  1218.                                     break;
  1219.                               case KEY_FIND:
  1220.                                     if(RemoteKey.Time.Interval>=600/TIME_BASE)
  1221.                                     {
  1222.                                           RemoteKey.Flag.Press=0;
  1223.                                           Energency=TRUN_FLASH;
  1224.                                           flash_trun_signal(0,0,0);
  1225.                                           if(speak_act_precoss(0,0,0,RESET));
  1226.                                     }                                
  1227.                                     break;
  1228.                               case KEY_QUIET:
  1229.                                     RemoteKey.Flag.Press=0;
  1230.                                     system_state_change(State,PreState,1);
  1231.                               default:break;
  1232.                         }
  1233.                   }
  1234.                   break;         
  1235.             case TRUN_FLASH:
  1236.                   if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,33));
  1237.                   if(speak_act_precoss(0,0,33000/TIME_BASE/5,LONG))
  1238.                   {
  1239.                         flash_trun_signal(0,0,0);
  1240.                         speak_act_precoss(0,0,0,RESET);
  1241.                         Energency=DELAY_8S;
  1242.                         Timer8S.Interval=0;
  1243.                   }
  1244.                   if(RemoteKey.Flag.Press)
  1245.                   {
  1246.                         RemoteKey.Flag.Press=0;
  1247.                         switch(RemoteKey.Key)
  1248.                         {
  1249.                               case KEY_UNLOCK:
  1250.                                     system_state_change(State,PreState,0);
  1251.                                     break;
  1252.                               default:break;
  1253.                         }
  1254.                   }
  1255.                   break;   
  1256.             case DELAY_8S:
  1257.                   if(++Timer8S.Interval>=8000/TIME_BASE)
  1258.                         Energency=TRUN_FLASH;
  1259.                   if(RemoteKey.Flag.Press)
  1260.                   {
  1261.                         RemoteKey.Flag.Press=0;
  1262.                         switch(RemoteKey.Key)
  1263.                         {
  1264.                               case KEY_UNLOCK:
  1265.                                     system_state_change(State,PreState,0);
  1266.                                     break;
  1267.                               default:break;
  1268.                         }
  1269.                   }
  1270. ……………………

  1271. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
EV1527编码解码.rar (1.37 MB, 下载次数: 77)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 转播转播 分享分享 分享淘帖 顶 踩
回复

使用道具 举报

无效楼层,该帖已经被删除
板凳
918kb 发表于 2019-5-12 17:54 | 只看该作者
很好的学习资料   谢谢楼主
回复

使用道具 举报

地板
hkhk 发表于 2019-8-14 15:34 | 只看该作者
下载不到啊
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51黑电子论坛单片机 联系QQ:125739409;技术交流QQ群582644647

Powered by 单片机教程网

快速回复 返回顶部 返回列表