标题: EV1527遥控器的解码资料+单片机程序 供大家参考 [打印本页]

---

作者: zdw2019    时间: 2019-2-22 12:26
标题: 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. 
   
10. const uint PULSE_SYN_MAX=PULSE_SHORT_MAX_TIME/8/4*35;
    
11. const uint PULSE_SYN_MIN=PULSE_SHORT_MIN_TIME/8/4*20;
    
12. const uint DT=(uint)((PULSE_SHORT_MIN_TIME/8/4+PULSE_SHORT_MIN_TIME/8/4)*0.1/2);
    
13. 
    
14. bank2 SharkFlagStruct SharkFlag={2};
    
15. bank1 ulong PassWord[2];       //waste 2B ram;   20bit
    
16. 
    
17. static bank1 RemindStateEnum RemindState=DOOR_OPEN;
    
18. static bank1 uchar PressUnlock=0;
    
19. static Timer16Struct GuardQuiet5s={0,1};      //延时5s进入警戒状态;
    
20. static bank1 AlarmGradeEnum AlarmGrade=Guard;
    
21. static bank1 OpenStepEnum     OpenStep=OPEN_REMIND;
    
22. static EnergencyEnum Energency=PRESS_FIND;
    
23. static bank1 bit SystemGuardChangeFirstTime=0;
    
24. bank2 LearnStepEnum LearnStep=FRIST_DATA;
    
25. bank2 Timer16Struct AlarmSharkTimer={0,0};
    
26. 
    
27. bank1 Timer16Struct DoorOpenTimer={0,0};
    
28. bank1 uchar AlarmNoub=0;
    
29. bit remote_key_dither(ulong data)
    
30. {
    
31.       static bank1 ulong LastRemote;
    
32.       if(data==LastRemote)
    
33.       {
    
34.             if(RemoteKey.Flag.FirstPress==1)
    
35.             {
    
36.                   RemoteKey.Flag.Press=1;
    
37.                   RemoteKey.Flag.FirstPress=0;
    
38.                   RemoteKey.Key=get_key(data);
    
39.                   RemoteKey.Rec=data;
    
40.             }
    
41.             RemotePressTimeOut.Interval=0;
    
42.             RemoteKey.Time.Interval=RemotePressTime.Interval;
    
43.             RemotePressTime.enable=1;
    
44.             RemotePressTimeOut.enable=1;
    
45.             LastRemote=data;
    
46.             //RemoteKey.Key=get_key(data);
    
47.             return 1;
    
48.       }
    
49. 
    
50.       else
    
51.       {
    
52.             //for error process;
    
53.             RemoteKey.Flag.Release=0;
    
54.             RemoteKey.Flag.Press=0;
    
55.             RemoteKey.Flag.FirstPress=1;
    
56.             RemotePressTime.Interval=0;
    
57.       }  
    
58.       LastRemote=data;
    
59.       return 0;
    
60. }
    
61. 
    
62. ulong get_password(ulong data)
    
63. {
    
64.       //ulong pass;
    
65.       //pass=(data&0x00ffffff)>>4;
    
66.       //return(pass);
    
67.       return((data&0x00ffffff)>>4);
    
68. }
    
69. 
    
70. uchar get_key(ulong data)
    
71. {
    
72.       ulong pd;
    
73.       uchar KeyValue;
    
74.       
    
75.       pd=data&0x0f;
    
76.       KeyValue=(uchar)(pd);
    
77.       
    
78.       if(KeyValue==0x08)      return KEY_LOCK;
    
79.       else if(KeyValue==0x0c) return KEY_UNLOCK;
    
80.       else if(KeyValue==0x03) return KEY_QUIET;
    
81.       else if(KeyValue==0x0f) return KEY_FIND;
    
82.       #ifdef BOOT_EN
    
83.       else if(KeyValue==0x04) return KEY_BOOT;
    
84.       #endif
    
85.       else                    return KEY_UNKNOW;
    
86. }
    
87. 
    
88. bit decode(ulong data)
    
89. {
    
90.       ulong Word;
    
91.       Word=get_password(data);
    
92.       if(PassWord[0]==Word||PassWord[1]==Word)
    
93.             return 1;
    
94.       else return 0;
    
95. }
    
96. 
    
97. //void remind_shutdown(void)
    
98. bit remind_shutdown(void)
    
99. {
    
100.       
     
101.       static bank1 Timer16Struct DelayTime=0;
     
102.       
     
103.       if(InState.SideDoor==DOOR_OPENED)
     
104.       {
     
105.             RemindState=DOOR_OPEN;
     
106.             DelayTime.Interval=0;
     
107.       }
     
108.       switch(RemindState)
     
109.       {
     
110.             case DOOR_OPEN:
     
111.                   if(InState.SideDoor==DOOR_OPENED)
     
112.                         RemindState=DOOR_CLOSE;
     
113.                   break;
     
114.             case DOOR_CLOSE:
     
115.                   if(InState.SideDoor==DOOR_CLOSED)
     
116.                   {
     
117.                         RemindState=DELAY_5S;
     
118.                         DelayTime.Interval=0;
     
119.                   }
     
120.                   break;
     
121.             case DELAY_5S:
     
122.                   if(DelayTime.Interval++>=REMIND_SHUT_DELAY_TIME)
     
123.                   {
     
124.                         DelayTime.Interval=0;
     
125.                         RemindState=REMIND;
     
126.                         speak_act_precoss(0,0,0,RESET);     //reset speak;
     
127.                   }
     
128.                   break;
     
129.             case REMIND:
     
130.                   flash_trun_signal(120/TIME_BASE,1400/TIME_BASE,3);
     
131.                   if(speak_act_precoss(40/TIME_BASE,1480/TIME_BASE,3,SHORT))
     
132.                   {
     
133.                         RemindState=DELAY_60S;
     
134.                         flash_trun_signal(0,0,0);
     
135.                         speak_act_precoss(0,0,0,RESET);
     
136.                   }
     
137.                   break;
     
138.             case DELAY_60S:
     
139.                   if(DelayTime.Interval++>=REMIND_DELAY_60S)
     
140.                   {
     
141.                         RemindState=CHANGE_STATE;
     
142.                         DelayTime.Interval=0;
     
143.                   }
     
144.                   
     
145.                   break;
     
146.             case CHANGE_STATE:
     
147.                         RemindState=STATE_END;
     
148.                   if(Jump.SlefThorth)
     
149.                         {
     
150.                         system_state_change(State,GUARD_QUIET,1);
     
151.                           return 1;
     
152.                         }
     
153.                        
     
154.                         //PreState=State;
     
155.                   //State=GUARD_QUIET;
     
156.                   
     
157.                   break;
     
158.             case STATE_END:
     
159.                   break;
     
160.             default:break;
     
161.                
     
162.       }
     
163.         return 0;
     
164. }
     
165. 
     
166. bit alarm_led_long_light(uchar LightTime,uchar DrownTime)
     
167. {
     
168.       static Timer16Struct RunTime=0;
     
169.       
     
170.       if(LightTime==0)
     
171.       {
     
172.             RunTime.Interval=0;
     
173.             ALARM_LED=0;
     
174.       }
     
175.       else
     
176.       {
     
177.             if(++RunTime.Interval<=LightTime*125)
     
178.             {
     
179.                   ALARM_LED=1;
     
180.             }   
     
181.             else if(RunTime.Interval<=125*(LightTime+DrownTime))
     
182.                   ALARM_LED=0;
     
183.             else
     
184.             {
     
185.                     RunTime.Interval=0;
     
186.                              return 1;
     
187.                      }
     
188.       }
     
189.       return 0;
     
190. }
     
191. /*
     
192. ////////////////////////////////////////////
     
193. // Times :125ms                           //
     
194. // Second: 1s                             //
     
195. ////////////////////////////////////////////
     
196. void flash_alarm_led(uchar Times,uchar Second)
     
197. {
     
198.       if(AlarmLed.Flag.ms125)
     
199.       {
     
200.             AlarmLed.Flag.ms125=0;
     
201.             AlarmLed.Flag.Time++;
     
202.             if(AlarmLed.Flag.Time<=Times)
     
203.                   ALARM_LED=!ALARM_LED;
     
204.             else if(AlarmLed.Flag.Time<=Times+Second*8)      //2s
     
205.                   ALARM_LED=0;
     
206.             else
     
207.                   AlarmLed.Flag.Time=0;
     
208.       }
     
209. }
     
210. */
     
211. bit flash_alarm_led(uchar Times,uchar Second)
     
212. {
     
213.       if(AlarmLed.Flag.ms125)
     
214.       {
     
215.             AlarmLed.Flag.ms125=0;
     
216.             AlarmLed.Flag.Time++;
     
217.             if(AlarmLed.Flag.Time<=Times)
     
218.                   ALARM_LED=!ALARM_LED;
     
219.                   //ALARM_LED=1;
     
220.             else if(AlarmLed.Flag.Time<=Times+Second*8)      //2s
     
221.                   ALARM_LED=0;
     
222.             else
     
223.             {
     
224.                   AlarmLed.Flag.Time=0;
     
225.                       return 1;
     
226.               }
     
227.       }
     
228.       return 0;
     
229. }
     
230. 
     
231. 
     
232.       
     
233. void signal_led_alarm(AlarmGradeEnum state)
     
234. {
     
235.       
     
236.       if(state==Guard)
     
237.             flash_alarm_led(4,2);
     
238.       else if(state==Shaked)
     
239.             flash_alarm_led(6,2);
     
240.       else if(state==Opened)
     
241.             alarm_led_long_light(4,4);
     
242.       else if(state==Unchain)
     
243.             alarm_led_long_light(6,0);
     
244. }
     
245.       
     
246. uchar flash_trun_signal(uint PulseTime1,uint Interval1,uchar Times1)
     
247. {
     
248.       static bank2 uint RunTime1=0;
     
249.       static bank2 uchar CTime1=0;         //continuance time;
     
250.       
     
251.       Used.TrunSignal=1;
     
252.       if((PulseTime1==0)&&(Interval1==0))
     
253.       {
     
254.             Used.TrunSignal=0;
     
255.             RunTime1=0;
     
256.             TRUN_SIGNAL=0;
     
257.             CTime1=0;
     
258.             return 1;
     
259.       }
     
260.       else
     
261.       {
     
262.             if(CTime1<Times1)
     
263.             {
     
264.                   if(++RunTime1<=PulseTime1)
     
265.                         TRUN_SIGNAL=1;
     
266.                   else if(RunTime1<=(PulseTime1+Interval1))
     
267.                         TRUN_SIGNAL=0;
     
268.                   else
     
269.                   {
     
270.                         CTime1++;
     
271.                         RunTime1=0;   
     
272.                   }
     
273.                   return 0;
     
274.             }
     
275.             else
     
276.             {
     
277.                   CTime1=Times1;
     
278.                   TRUN_SIGNAL=0;
     
279.                   
     
280.                   return 1;
     
281.             }
     
282.            
     
283.       }
     
284. }
     
285. 
     
286. ////////////////////////////////////////////////////////
     
287. //PulseTime：喇叭鸣叫时间（20ms）                     //
     
288. //Interval:喇叭不鸣叫时间(20ms)                       //
     
289. //Time:持续时间20ms(LONG),次数(SHORT)                 //M
     
290. //Para:参数                                           //
     
291. //返回 0:还在鸣叫 1：已经结束                         //
     
292. ////////////////////////////////////////////////////////
     
293. 
     
294. bit speak_act_precoss(uchar PulseTime,uint Interval,uint Time,uchar Para)
     
295. {
     
296.       static bank1 uint RunTime=0;
     
297.       static bank1 ulong CTime=0;         //continuance time;
     
298.       Used.Speaker=1;
     
299.       if(Para==LONG)
     
300.       {
     
301.             if(++CTime<=Time*5)
     
302.             {
     
303.                   if(!Jump.Quiet)
     
304.                         SPEAKER=1;
     
305.                   return 0;
     
306.             }
     
307.             else
     
308.             {
     
309.                   CTime=0;
     
310.                   SPEAKER=0;
     
311.                   return 1;
     
312.             }
     
313.       }
     
314.       else if(Para==SHORT)
     
315.       {
     
316.             if(CTime<Time)
     
317.             {
     
318.                   if(++RunTime<=PulseTime)
     
319.                   {
     
320.                         if(!Jump.Quiet)
     
321.                               SPEAKER=1;
     
322.                   }
     
323.                   else if(RunTime<=(PulseTime+Interval))
     
324.                         SPEAKER=0;
     
325.                   else
     
326.                   {
     
327.                         CTime++;
     
328.                         RunTime=0;
     
329.                   }
     
330.                   return 0;
     
331.             }
     
332.             else
     
333.             {
     
334.                   CTime=Time;
     
335.                   SPEAKER=0;
     
336.                   return 1;
     
337.             }
     
338.             
     
339.       }
     
340.       else if(Para==RESET)
     
341.       {
     
342.             RunTime=0;
     
343.             SPEAKER=0;
     
344.             CTime=0;
     
345.             Used.Speaker=0;
     
346.             return 1;
     
347.       }                       
     
348.       return 1;     
     
349. }  
     
350. 
     
351. /////////////time:20ms//////////
     
352. bit door_lock_process(uchar time,uchar operate)
     
353. {
     
354.       /*
     
355.       static bank1 uint RunTime=0;
     
356.       
     
357.       Used.Lock=1;
     
358.       if(time==0)
     
359.       {
     
360.             RunTime=0;
     
361.             Used.Lock=0;
     
362.       }
     
363.       else
     
364.       {
     
365.             if(++RunTime<=time*5)
     
366.             {
     
367.                   if(operate==LOCK_ON)
     
368.                   {
     
369.                         CCU1=CCU_OFF;
     
370.                         CCU2=CCU_ON;
     
371.                   }
     
372.                   else
     
373.                   {
     
374.                         CCU1=CCU_ON;
     
375.                         CCU2=CCU_OFF;
     
376.                   }
     
377.                   return 0;
     
378.             }
     
379.             else
     
380.             {
     
381.                   RunTime=time*5;
     
382.                   CCU1=CCU_OFF;
     
383.                   CCU2=CCU_OFF;
     
384.                   return 1;
     
385.             }
     
386.       }
     
387.       return 1;
     
388.       */
     
389.       static bank1 uint RunTime=0;
     
390.       
     
391.       Used.Lock=1;
     
392.       if(time==0)
     
393.       {
     
394.             RunTime=0;
     
395.             Used.Lock=0;
     
396.             Flag.OpenOrCloseDoor=0;
     
397.             DoorOpenTimer.enable=0;
     
398.             DoorOpenTimer.Interval=0;
     
399.             CCU1=CCU_OFF;
     
400.             CCU2=CCU_OFF;
     
401.       }
     
402.       else
     
403.       {
     
404.             DoorOpenTimer.enable=1;
     
405.             if(++RunTime<=time*5)
     
406.             {
     
407.                   if(operate==LOCK_ON)
     
408.                   {
     
409.                         Flag.OpenOrCloseDoor=1;
     
410.                         if(Jump.Electromotion)
     
411.                         {
     
412.                               CCU1=CCU_OFF;
     
413.                               CCU2=CCU_ON;
     
414.                         }
     
415.                   }
     
416.                   else
     
417.                   {
     
418.                         Flag.OpenOrCloseDoor=0;
     
419.                         if(Jump.Electromotion)
     
420.                         {
     
421.                               CCU1=CCU_ON;
     
422.                               CCU2=CCU_OFF;
     
423.                         }
     
424.                   }
     
425.                   return 0;
     
426.             }
     
427.             else
     
428.             {
     
429.                   RunTime=time*5;
     
430.                   CCU1=CCU_OFF;
     
431.                   CCU2=CCU_OFF;
     
432.                   return 1;
     
433.             }
     
434.       }
     
435.       return 1;
     
436.       
     
437. }
     
438. 
     
439. bit frameout_precoss(uint Interval)
     
440. {
     
441.       static bank1 uint RunTime=0;
     
442.       Used.Engine=1;
     
443.       if(Interval==0)
     
444.       {
     
445.             RunTime=0;
     
446.             Used.Engine=0;
     
447.             ENGINE_OFF=0;
     
448.       }
     
449.       else if(Interval==0xffff)
     
450.       {
     
451.             ENGINE_OFF=1;
     
452.       }
     
453.       else
     
454.       {
     
455.             if(++RunTime<=Interval*125)
     
456.             {
     
457. 
     
458.                   ENGINE_OFF=1;
     
459.                   return 0;
     
460.             }
     
461.             else
     
462.             {
     
463.                   RunTime=Interval*125;
     
464.                   ENGINE_OFF=0;
     
465.             }
     
466.       }
     
467.       return 1;
     
468. }
     
469. 
     
470. void roadside_stop(void)
     
471. {
     
472.       //路边停车
     
473.       if(InState.SideDoor==DOOR_OPENED)
     
474.       {
     
475.             if(!Used.TrunSignal)
     
476.             {
     
477.                   if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,18));
     
478.                        //flash_trun_signal(0,0,0);
     
479.                   Used.TrunSignal=0;
     
480.             }
     
481.       
     
482.       }
     
483.       else
     
484.            if(!Used.TrunSignal)
     
485.                  flash_trun_signal(0,0,0);
     
486. }
     
487. 
     
488. void door_opened_guard(void)
     
489. {     
     
490.       static bank1 Timer16Struct Timer35s=0;
     
491.       
     
492.       frameout_precoss(0xffff);//一直让引擎关闭
     
493.       switch(OpenStep)
     
494.       {
     
495.             case OPEN_REMIND:      
     
496.                     //frameout_precoss(0xffff);                        
     
497.                   flash_trun_signal(120/TIME_BASE,580/TIME_BASE,3);
     
498.                   if(speak_act_precoss(40/TIME_BASE,660/TIME_BASE,3,SHORT))
     
499.                   {      
     
500.                         flash_trun_signal(0,0,0);
     
501.                         speak_act_precoss(0,0,0,RESET);
     
502.                         OpenStep=OPEN_DELAY_10S;
     
503.                         Timer35s.Interval=0;
     
504.                   }
     
505.                   break;
     
506.             case OPEN_DELAY_10S:
     
507.                   if(++Timer35s.Interval>=10000/TIME_BASE)
     
508.                         OpenStep=OPEN_ALARM;
     
509.                         if(InState.SideDoor!=DOOR_OPENED)
     
510.                                 Flag.DoorOpenedGuard=0;
     
511.                   break;      
     
512.             case OPEN_ALARM:
     
513.                   flash_trun_signal(500/TIME_BASE,500/TIME_BASE,240);         
     
514.                   if(speak_act_precoss(0,0,240000/TIME_BASE/5,LONG))
     
515.                   {
     
516.                         OpenStep=OPEN_STOP;
     
517.                         flash_trun_signal(0,0,0);
     
518.                         speak_act_precoss(0,0,0,RESET);     
     
519.                   }
     
520.                   break;
     
521.             case OPEN_STOP:
     
522.                     Flag.DoorOpenedGuard=0;
     
523.                   break;
     
524.             default:break;
     
525.       }
     
526. }
     
527. 
     
528. #ifdef BOOT_EN
     
529. bit open_boot(uchar Interval)
     
530. {
     
531.       static bank1 BootTimer=0;
     
532.       if(Interval==0)
     
533.       {
     
534.             BOOT=0;
     
535.             BootTimer=0;
     
536.       }
     
537.       else
     
538.       {
     
539.             if(++BootTimer<=Interval*5)
     
540.             {
     
541. 
     
542.                   BOOT=1;
     
543.                   return 0;
     
544.             }
     
545.             else
     
546.             {
     
547.                   BootTimer=Interval*5;
     
548.                   BOOT=0;
     
549.                   return 1;
     
550.             }
     
551.       }
     
552.       return 1;
     
553.       
     
554. }
     
555. #endif
     
556. 
     
557. void normal_process(void)
     
558. {
     
559.       static bank1 AutoRestoreStruct AutoRestore=0;
     
560.       
     
561.       if(Flag.SystemStateChange)
     
562.       {
     
563.             RemindState=DOOR_OPEN;
     
564.             
     
565.             AutoRestore.Flag.Shaked=0;
     
566.             AutoRestore.Flag.Opened=0;
     
567.             AutoRestore.Time.Interval=0;
     
568.             Flag.RememTouch=0;
     
569.             switch(PreState)
     
570.             {
     
571.                   
     
572.                   case GUARD_SOUND:
     
573.                         door_lock_process(500/TIME_BASE/5,LOCK_OFF);
     
574.                         if(PressUnlock==0)
     
575.                               speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT);
     
576.                         if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2))
     
577.                         {
     
578.                                     Flag.SystemStateChange=0;
     
579.                                     flash_trun_signal(0,0,0);
     
580.                                     speak_act_precoss(0,0,0,RESET);
     
581.                                     if(Jump.Electromotion)  door_lock_process(0,0);
     
582.                         }
     
583.                         break;
     
584.                   case GUARD_QUIET:
     
585.                         door_lock_process(500/TIME_BASE/5,LOCK_OFF);
     
586.                         //if(speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT));
     
587.                         if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2))
     
588.                         {
     
589.                                     Flag.SystemStateChange=0;
     
590.                                     flash_trun_signal(0,0,0);
     
591.                                     speak_act_precoss(0,0,0,RESET);
     
592.                                     if(Jump.Electromotion) door_lock_process(0,0);
     
593.                         }
     
594.                         break;
     
595.                   case RUN:
     
596.                         if(PressUnlock>0)
     
597.                         {
     
598.                                door_lock_process(500/TIME_BASE/5,LOCK_OFF);
     
599.                               //if(speak_act_precoss(50/TIME_BASE,200/TIME_BASE,2,SHORT));
     
600.                               if(flash_trun_signal(250/TIME_BASE,250/TIME_BASE,2))
     
601.                               {
     
602.                                           Flag.SystemStateChange=0;
     
603.                                           flash_trun_signal(0,0,0);
     
604.                                           speak_act_precoss(0,0,0,RESET);
     
605.                                           if(Jump.Electromotion) door_lock_process(0,0);
     
606.                               }     
     
607.                         }
     
608.                         else
     
609.                         {
     
610.                               if(door_lock_process(500/TIME_BASE/5,LOCK_OFF))
     
611.                               {
     
612.                                     Flag.SystemStateChange=0;
     
613.                                     if(Jump.Electromotion) door_lock_process(0,0);
     
614.                               }
     
615.                         }
     
616.                         break;
     
617.                   default:
     
618.                         Flag.SystemStateChange=0;
     
619.                         break;
     
620.             }
     
621.       }
     
622.       else
     
623.       {
     
624.             if(RemoteKey.Flag.Press)
     
625.             {
     
626.                   RemoteKey.Flag.Press=0;
     
627.                   switch(RemoteKey.Key)
     
628.                   {
     
629.                         case KEY_LOCK:
     
630.                               system_state_change(State,GUARD_SOUND,1);
     
631.                               //break;
     
632.                                         return ;
     
633.                         case KEY_QUIET:
     
634.                               system_state_change(State,GUARD_QUIET,1);
     
635.                               //break;
     
636.                                         return ;
     
637.                         case KEY_FIND:
     
638.                               system_state_change(State,FIND,1);
     
639.                               //break;
     
640.                                         return ;
     
641.                         case KEY_UNLOCK:
     
642.                               if(++PressUnlock<=3)
     
643.                               {
     
644.                                     flash_trun_signal(0,0,0);
     
645.                                     Flag.SystemStateChange=1;
     
646.                               }
     
647.                               else
     
648.                                     PressUnlock=3;
     
649.                               break;
     
650.                         #ifdef BOOT_EN
     
651.                         
     
652.                         case KEY_BOOT:
     
653.                               Flag.Boot=1;
     
654.                               open_boot(0);
     
655.                               break;
     
656.                         #endif
     
657.                         default:
     
658.                               break;
     
659.                   }
     
660.             }
     
661.             // 进入行驶
     
662.             
     
663.             #ifdef BOOT_EN
     
664.             if(Flag.Boot)
     
665.             {
     
666.                   Flag.Boot=0;
     
667.                   open_boot(500/TIME_BASE/5);
     
668.             }
     
669.             #endif
     
670.             if(InState.Acc)
     
671.             {
     
672.                   system_state_change(State,RUN,1);
     
673.                   return ;
     
674.             }
     
675.             //提醒设置防盗    for remind to shutdown
     
676.             //if(PreState==RUN)
     
677.                   //remind_shutdown();
     
678.                 if(PreState==RUN)
     
679.                         Flag.FromRemindShutDown=remind_shutdown();
     
680.             //路边停车
     
681.             roadside_stop();
     
682.             
     
683.             //for auto restore
     
684.             if(!InState.Shake)
     
685.                   AutoRestore.Flag.Shaked=1;
     
686.             if(InState.SideDoor==DOOR_OPENED)
     
687.             {
     
688.                   if(AlarmNoub>3)   AlarmNoub=3;
     
689.                   if(AlarmNoub>0)
     
690.                   {
     
691.                           AlarmNoub=0;
     
692.                         Flag.RememTouch=1;
     
693.                           alarm_led_long_light(0,0);
     
694.                   }
     
695.                   AutoRestore.Flag.Opened=1;   
     
696.                   AlarmGrade=Guard;
     
697.             }      
     
698.                   
     
699.             if((!AutoRestore.Flag.Shaked)&&(!AutoRestore.Flag.Opened))
     
700.             {
     
701.                   if(PreState==GUARD_QUIET||PreState==GUARD_SOUND)
     
702.                         if(AutoRestore.Time.Interval++>=AUTO_RESTORE_TIME)
     
703.                         {
     
704.                               system_state_change(State,PreState,1);
     
705.                               AutoRestore.Time.Interval=0;
     
706.                         }
     
707.             }
     
708.             else  AutoRestore.Time.Interval=0;
     
709.             //记忆触发
     
710.             if(Flag.RememTouch)
     
711.             {
     
712.                         speak_act_precoss(50/TIME_BASE,950/TIME_BASE,1,SHORT);
     
713.                         if(alarm_led_long_light(6,1))
     
714.                     {
     
715.                                 alarm_led_long_light(0,0);                                  
     
716.                                 SIGNAL_LED=0;
     
717.                                 AlarmNoub=0;
     
718.                                 speak_act_precoss(0,0,0,RESET);
     
719.                                 Flag.RememTouch=0;
     
720.                      }
     
721.                 }
     
722.       }
     
723. }
     
724. 
     
725. void guard_process(uchar Mode)
     
726. {
     
727.         if(GuardQuiet5s.Interval++>=5000/TIME_BASE)
     
728.         {
     
729.               GuardQuiet5s.enable=0;
     
730.               GuardQuiet5s.Interval=0;
     
731.               Flag.BeginGuard=1;
     
732.         }
     
733.         if(Flag.BeginGuard)
     
734.         {
     
735.               if(Flag.DoorOpenedGuard)
     
736.                     door_opened_guard();
     
737.               else
     
738.               {
     
739.                     if(!InState.Shake)
     
740.                     {
     
741.                      
     
742.                              if(AlarmSharkTimer.Interval==0)
     
743.                              {
     
744.                                       SharkFlag.Time=1;
     
745.                                      AlarmSharkTimer.enable=1;
     
746.                                   }
     
747.                                   else if(AlarmSharkTimer.Interval<15000/TIME_BASE)
     
748.                                           SharkFlag.Time=2;
     
749.                                   else
     
750.                                   {
     
751.                                            SharkFlag.Time=1;
     
752.                                           AlarmSharkTimer.enable=1;
     
753.                           }
     
754.                           AlarmSharkTimer.Interval=0;
     
755.                           if(Mode==QUIET_MODE)
     
756.                                   system_state_change(State,ALARM_QUIET,1);
     
757.                           else if(Mode==SOUND_MODE)
     
758.                                   system_state_change(State,ALARM_SOUND,1);
     
759.                     }
     
760.                     if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake)
     
761.                           system_state_change(State,ALARM_DOOR_OPENED,1);
     
762.               }
     
763.         }      
     
764. 
     
765. }
     
766. 
     
767. void guard_quiet_process(void)
     
768. {
     
769.       // 5s later into the guard mode
     
770.       signal_led_alarm(AlarmGrade);
     
771.       
     
772.       if(!Flag.GuardEngineOFF)
     
773.       {
     
774.             if(PreState!=FIND)
     
775.             {
     
776.                   if(Flag.DoorOpenedGuard)
     
777.                         Flag.GuardEngineOFF=1;
     
778.                   if(frameout_precoss(40))
     
779.                         Flag.GuardEngineOFF=1;
     
780.             }
     
781.             else Flag.GuardEngineOFF=1;         
     
782.       }
     
783.       if(Flag.SystemStateChange)
     
784.       {
     
785.             if(PreState!=FIND)
     
786.             {
     
787.                   if(!Flag.FromRemindShutDown)
     
788.                                 door_lock_process(500/TIME_BASE/5,LOCK_ON);
     
789.                   if(flash_trun_signal(500/TIME_BASE,200/TIME_BASE,1))
     
790.                   {
     
791.                               Flag.SystemStateChange=0;
     
792.                               flash_trun_signal(0,0,0);
     
793.                               if(Jump.Electromotion)  door_lock_process(0,0);
     
794.                               speak_act_precoss(0,0,0,RESET);
     
795.                   }
     
796.             GuardQuiet5s.Interval=0;
     
797.             }
     
798.             else Flag.SystemStateChange=0;
     
799.             Flag.BeginGuard=0;
     
800.             /////////////////////////////////当进入防盗系统的时候 如果门未关好 提醒用户关门////////////////
     
801.             if(SystemGuardChangeFirstTime)
     
802.             {
     
803.                     if(InState.SideDoor==DOOR_OPENED)
     
804.                     {
     
805.                           Flag.DoorOpenedGuard=1;
     
806.                           OpenStep=OPEN_REMIND;
     
807.                     }
     
808.                     else
     
809.                             Flag.DoorOpenedGuard=0;
     
810.             }
     
811.             SystemGuardChangeFirstTime=0;
     
812.                   AlarmSharkTimer.enable=0;
     
813.                   AlarmSharkTimer.Interval=0;
     
814.       }
     
815.       else
     
816.       {
     
817.               guard_process(QUIET_MODE);
     
818.                 if(RemoteKey.Flag.Press)
     
819.                 {
     
820.                       RemoteKey.Flag.Press=0;
     
821.                       switch(RemoteKey.Key)
     
822.                       {
     
823.                             case KEY_LOCK:
     
824.                                   system_state_change(State,GUARD_SOUND,1);
     
825.                                   break;
     
826.                             case KEY_UNLOCK:
     
827.                                   ALARM_LED=0;
     
828.                                   system_state_change(State,NORMAL,1);
     
829.                                   break;
     
830.                             case KEY_FIND:
     
831.                                   system_state_change(State,FIND,1);
     
832.                                   break;
     
833.                             case KEY_QUIET:
     
834.                                   Flag.GuardEngineOFF=0;
     
835.                                   frameout_precoss(0);
     
836.                                   Flag.SystemStateChange=1;
     
837.                                   break;
     
838.                             #ifdef BOOT_EN
     
839.                             case KEY_BOOT:
     
840.                                   Flag.Boot=1;
     
841.                                   open_boot(0);
     
842.                                   break;
     
843.                             #endif
     
844.                            
     
845.                             default:break;
     
846.                       }
     
847.                 }
     
848.       }
     
849. }
     
850. 
     
851. void guard_sound_process(void)
     
852. {
     
853.       //flash_alarm_led(4,2);
     
854.       signal_led_alarm(AlarmGrade);
     
855.       if(!Flag.GuardEngineOFF)
     
856.       {
     
857.             if(PreState!=FIND)
     
858.             {
     
859.                   if(Flag.DoorOpenedGuard)
     
860.                   {
     
861.                         Flag.GuardEngineOFF=1;
     
862.                   }
     
863.                   if(frameout_precoss(40))
     
864.                         Flag.GuardEngineOFF=1;
     
865.             }
     
866.             else Flag.GuardEngineOFF=1;         
     
867.       }
     
868.       
     
869.       if(Flag.SystemStateChange)
     
870.       {
     
871.             if(PreState!=FIND)
     
872.             {
     
873.                   speak_act_precoss(50/TIME_BASE,200/TIME_BASE,1,SHORT);
     
874.                   door_lock_process(500/TIME_BASE/5,LOCK_ON);
     
875.                   if(flash_trun_signal(500/TIME_BASE,200/TIME_BASE,1))
     
876.                   {
     
877.                               Flag.SystemStateChange=0;
     
878.                               speak_act_precoss(0,0,0,RESET);
     
879.                               flash_trun_signal(0,0,0);
     
880.                               if(Jump.Electromotion) door_lock_process(0,0);
     
881.                   }
     
882.                   GuardQuiet5s.enable=1;
     
883.                   GuardQuiet5s.Interval=0;
     
884.             }
     
885.             else Flag.SystemStateChange=0;
     
886.             Flag.BeginGuard=0;
     
887.             /////////////////////////////////当进入防盗系统的时候 如果门未关好 提醒用户关门////////////////
     
888.             if(SystemGuardChangeFirstTime)
     
889.             {
     
890.                     if(InState.SideDoor==DOOR_OPENED)
     
891.                     {
     
892.                           Flag.DoorOpenedGuard=1;
     
893.                           OpenStep=OPEN_REMIND;
     
894.                     }
     
895.                                 else Flag.DoorOpenedGuard=0;
     
896.                         }
     
897.                         SystemGuardChangeFirstTime=0;
     
898.             AlarmSharkTimer.enable=0;
     
899.             AlarmSharkTimer.Interval=0;
     
900.             
     
901.       }
     
902.       else
     
903.       {     
     
904.                 guard_process(SOUND_MODE);
     
905.             if(RemoteKey.Flag.Press)
     
906.             {
     
907.                   RemoteKey.Flag.Press=0;
     
908.                   switch(RemoteKey.Key)
     
909.                   {
     
910.                         case KEY_LOCK:
     
911.                               system_state_change(State,GUARD_SOUND,1);
     
912.                               break;
     
913.                               
     
914.                         case KEY_UNLOCK:
     
915.                               ALARM_LED=0;
     
916.                               system_state_change(State,NORMAL,1);
     
917.                               break;
     
918.                         case KEY_FIND:
     
919.                               system_state_change(State,FIND,1);
     
920.                               break;
     
921.                         case KEY_QUIET:
     
922.                               system_state_change(State,GUARD_QUIET,1);
     
923.                               break;
     
924.                         default:break;
     
925.                   }
     
926.             }
     
927.       }
     
928. }
     
929. 
     
930. void find_process(void)
     
931. {
     
932.       flash_trun_signal(500/TIME_BASE,500/TIME_BASE,5);
     
933.       if(speak_act_precoss(0,0,5000/TIME_BASE/5,LONG))
     
934.       {
     
935.             speak_act_precoss(0,0,0,RESET);
     
936.             flash_trun_signal(0,0,0);
     
937.             system_state_change(State,PreState,0);
     
938.       }      
     
939.       if(RemoteKey.Flag.Press)
     
940.       {
     
941.             RemoteKey.Flag.Press=0;
     
942.             switch(RemoteKey.Key)
     
943.             {
     
944.                   case KEY_LOCK:
     
945.                         system_state_change(State,PreState,0);
     
946.                         break;
     
947.                   case KEY_UNLOCK:
     
948.                         
     
949.                         system_state_change(State,PreState,0);
     
950.                         break;
     
951.                   case KEY_FIND:
     
952.                         system_state_change(State,PreState,0);
     
953.                         break;
     
954.                   case KEY_QUIET:
     
955.                         system_state_change(State,PreState,0);
     
956.                   default:break;
     
957.             }
     
958.       }
     
959. }
     
960. 
     
961. 
     
962. typedef struct
     
963. {
     
964.       unsigned char Lock:1;
     
965.       unsigned char Unlock:1;
     
966.       unsigned char Help:1;
     
967.       unsigned char Call:1;
     
968.       unsigned char DoorOpened:1;
     
969.       unsigned char State:2;
     
970. }RunStruct;
     
971. void run_process(void)
     
972. {
     
973.       static bank1 RunStruct Run=0;
     
974.       
     
975.       ///////////15s后自动锁门////////
     
976.       static Timer16Struct AutoLock=0;
     
977.       if(Flag.SystemStateChange)
     
978.       {
     
979.             AlarmNoub=0;
     
980.             Flag.SystemStateChange=0;
     
981.             Run.State=0;
     
982.             AutoLock.Interval=0;
     
983.             Run.DoorOpened=0;
     
984.       }
     
985.       switch(Run.State)
     
986.       {
     
987.             case 0:
     
988.                   if(InState.SideDoor)
     
989.                         Run.DoorOpened=1;
     
990.                   if(!InState.SideDoor&&Run.DoorOpened)
     
991.                   {
     
992.                         Run.State=0;
     
993.                         Run.DoorOpened=0;
     
994.                         AutoLock.Interval=0;
     
995.                   }
     
996.                   if(++AutoLock.Interval>=15000/TIME_BASE)
     
997.                   {
     
998.                         Run.State=1;
     
999.                         AutoLock.Interval=0;
     
1000.                   }
      
1001.                   break;
      
1002.             case 1:
      
1003.                   if(InState.Brake)
      
1004.                   {
      
1005.                         Run.Lock=1;
      
1006.                         Run.State=2;
      
1007.                   }
      
1008.                   break;
      
1009.             case 2:
      
1010.                   if(InState.SideDoor)
      
1011.                         Run.DoorOpened=1;
      
1012.                   if(!InState.SideDoor&&Run.DoorOpened)
      
1013.                   {
      
1014.                         Run.State=0;
      
1015.                         Run.DoorOpened=0;
      
1016.                   }
      
1017.                   break;      
      
1018.             default:
      
1019.                   Run.State=2;
      
1020.                   break;
      
1021.       }
      
1022.       /////////////////////////////////
      
1023.       if(RemoteKey.Flag.Press)
      
1024.       {
      
1025.             switch(RemoteKey.Key)
      
1026.             {
      
1027.                   case KEY_LOCK:
      
1028.                                   Run.Unlock=0;
      
1029.                         Run.Lock=1;
      
1030.                         door_lock_process(0,0);
      
1031.                         RemoteKey.Flag.Press=0;
      
1032.                         break;
      
1033.                   case KEY_UNLOCK:
      
1034.                                   Run.Lock=0;
      
1035.                         Run.Unlock=1;
      
1036.                         door_lock_process(0,0);
      
1037.                         RemoteKey.Flag.Press=0;
      
1038.                         break;
      
1039.                   case KEY_FIND:
      
1040.                         if(RemoteKey.Time.Interval>=1500/TIME_BASE)
      
1041.                         {
      
1042.                               RemoteKey.Flag.Press=0;
      
1043.                               system_state_change(State,ALARM_HELP,1);
      
1044.                         }
      
1045.                         break;
      
1046.                   case KEY_QUIET:
      
1047.                         if(RemoteKey.Time.Interval>=1500/TIME_BASE)
      
1048.                         {
      
1049.                               RemoteKey.Flag.Press=0;
      
1050.                               Energency=PRESS_FIND;
      
1051.                               system_state_change(State,ALARM_ENERGENCY,1);
      
1052.                         }
      
1053.                         break;
      
1054.                   default:break;
      
1055.             }
      
1056.       }
      
1057.       
      
1058.       roadside_stop();
      
1059.       
      
1060.       if(!InState.Acc)
      
1061.       {
      
1062.             //PreState=State;
      
1063.             //State=NORMAL;
      
1064.             system_state_change(State,NORMAL,1);
      
1065.       }
      
1066.       if(Run.Unlock)
      
1067.       {
      
1068.             if(door_lock_process(500/TIME_BASE/5,LOCK_OFF))
      
1069.             {
      
1070.                   Run.Unlock=0;
      
1071.                   if(Jump.Electromotion)
      
1072.                         door_lock_process(0,0);
      
1073.             }
      
1074.       }
      
1075.       else if(Run.Lock)
      
1076.             if(door_lock_process(500/TIME_BASE/5,LOCK_ON))
      
1077.             {
      
1078.                   Run.Lock=0;
      
1079.                   if(Jump.Electromotion)
      
1080.                         door_lock_process(0,0);
      
1081.             }
      
1082. }
      
1083. void alarm_down_opened_process(void)
      
1084. {
      
1085.       //alarm_led_long_light(4,4);
      
1086.       
      
1087.       if(Flag.SystemStateChange)
      
1088.       {
      
1089.             Flag.SystemStateChange=0;
      
1090.             if(AlarmNoub++>=3) AlarmNoub=3;
      
1091.       }
      
1092.       
      
1093.       if(AlarmGrade<=Opened)
      
1094.             AlarmGrade=Opened;
      
1095.       signal_led_alarm(AlarmGrade);
      
1096.       frameout_precoss(60);
      
1097.       flash_trun_signal(500/TIME_BASE,500/TIME_BASE,26);
      
1098.       if(speak_act_precoss(0,0,26000/TIME_BASE/5,LONG))
      
1099.       {
      
1100.             speak_act_precoss(0,0,0,RESET);
      
1101.             flash_trun_signal(0,0,0);
      
1102.             system_state_change(State,PreState,0);
      
1103.       }
      
1104.       if(RemoteKey.Flag.Press)
      
1105.       {
      
1106.             RemoteKey.Flag.Press=0;
      
1107.             switch(RemoteKey.Key)
      
1108.             {
      
1109.                   case KEY_LOCK:
      
1110.                         system_state_change(State,PreState,0);
      
1111.                         break;
      
1112.                   case KEY_UNLOCK:
      
1113.                         system_state_change(PreState,NORMAL,1);
      
1114.                         break;
      
1115.                   case KEY_FIND:
      
1116.                         system_state_change(State,PreState,0);
      
1117.                         break;
      
1118.                   case KEY_QUIET:
      
1119.                         system_state_change(State,PreState,0);
      
1120.                   default:break;
      
1121.             }
      
1122.       }
      
1123. }
      
1124. 
      
1125. void shark_alarm(uchar Mode)
      
1126. {
      
1127.         if(Flag.SystemStateChange)
      
1128.       {
      
1129.             Flag.SystemStateChange=0;
      
1130.             if(AlarmNoub++>=3) AlarmNoub=3;
      
1131.       }
      
1132.       if(AlarmGrade<=Shaked)
      
1133.             AlarmGrade=Shaked;
      
1134.         signal_led_alarm(AlarmGrade);
      
1135.         if(SharkFlag.Time==1)
      
1136.         {
      
1137.               //if(frameout_precoss(60));
      
1138.               if(Mode==SOUND_MODE)
      
1139.                         if(speak_act_precoss(50/TIME_BASE,950/TIME_BASE,5,SHORT));
      
1140.                 if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,5))
      
1141.               {
      
1142.                     speak_act_precoss(0,0,0,RESET);
      
1143.                     flash_trun_signal(0,0,0);
      
1144.                     system_state_change(State,PreState,0);
      
1145.               }
      
1146. 
      
1147.         }
      
1148.       else if(SharkFlag.Time==2)
      
1149.       {
      
1150.               if(frameout_precoss(61));
      
1151.               if(Mode==SOUND_MODE)  
      
1152.                         if(speak_act_precoss(0,0,27000/TIME_BASE/5,LONG));
      
1153.               if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,26))
      
1154.               {
      
1155.                     speak_act_precoss(0,0,0,RESET);
      
1156.                     flash_trun_signal(0,0,0);
      
1157.                     system_state_change(State,PreState,0);
      
1158.               }
      
1159.       }      
      
1160.         if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake)
      
1161.             system_state_change(PreState,ALARM_DOOR_OPENED,1);
      
1162. }
      
1163. void alarm_quiet_process(void)
      
1164. {
      
1165.       //if(Flag.SystemStateChange)
      
1166.       //{
      
1167.             //Flag.SystemStateChange=0;
      
1168.             //if(AlarmNoub++>=3) AlarmNoub=3;
      
1169.       //}
      
1170.       //if(AlarmGrade<=Shaked)
      
1171.             //AlarmGrade=Shaked;
      
1172.       
      
1173.       
      
1174.         shark_alarm(QUIET_MODE);
      
1175.       
      
1176.       if(RemoteKey.Flag.Press)
      
1177.       {
      
1178.             RemoteKey.Flag.Press=0;
      
1179.             switch(RemoteKey.Key)
      
1180.             {
      
1181.                   case KEY_LOCK:
      
1182.                         system_state_change(State,PreState,0);
      
1183.                         break;
      
1184.                   case KEY_UNLOCK:
      
1185.                         
      
1186.                         system_state_change(PreState,NORMAL,1);
      
1187.                         break;
      
1188.                   case KEY_FIND:
      
1189.                         system_state_change(State,PreState,0);
      
1190.                         break;
      
1191.                   case KEY_QUIET:
      
1192.                         system_state_change(State,PreState,0);
      
1193.                   default:break;
      
1194.             }
      
1195.       }
      
1196. }
      
1197. 
      
1198. void alarm_sound_process(void)
      
1199. {
      
1200.       
      
1201.       //signal_led_alarm(AlarmGrade);
      
1202.       
      
1203.         shark_alarm(SOUND_MODE);
      
1204.       //if(InState.SideDoor==DOOR_OPENED)
      
1205.       //if(InState.SideDoor==DOOR_OPENED||InState.Acc||InState.Brake)
      
1206.             //system_state_change(PreState,ALARM_DOOR_OPENED,1);
      
1207.       if(RemoteKey.Flag.Press)
      
1208.       {
      
1209.             RemoteKey.Flag.Press=0;
      
1210.             switch(RemoteKey.Key)
      
1211.             {
      
1212.                   case KEY_LOCK:
      
1213.                         system_state_change(State,PreState,0);
      
1214.                         break;
      
1215.                   case KEY_UNLOCK:  
      
1216.                         system_state_change(PreState,NORMAL,1);
      
1217.                         break;
      
1218.                   case KEY_FIND:
      
1219.                         system_state_change(State,PreState,0);
      
1220.                         break;
      
1221.                   case KEY_QUIET:
      
1222.                         system_state_change(State,PreState,0);
      
1223.                   default:break;
      
1224.             }
      
1225.       }
      
1226. }
      
1227. 
      
1228. void alarm_energency(void)
      
1229. {     
      
1230.       static Timer16Struct Timer8S=0;
      
1231.       switch(Energency)
      
1232.       {
      
1233.             case PRESS_FIND:
      
1234.                   if(flash_trun_signal(4000/TIME_BASE,0,1))
      
1235.                   {
      
1236.                         flash_trun_signal(0,0,0);
      
1237.                         system_state_change(State,PreState,1);
      
1238.                   }
      
1239.                   if(RemoteKey.Flag.Press)
      
1240.                   {
      
1241.       
      
1242.                         switch(RemoteKey.Key)
      
1243.                         {
      
1244.                               case KEY_LOCK:
      
1245.                                     RemoteKey.Flag.Press=0;
      
1246.                                     system_state_change(State,PreState,1);
      
1247.                                     break;
      
1248.                               case KEY_UNLOCK:  
      
1249.                                     RemoteKey.Flag.Press=0;
      
1250.                                     system_state_change(State,PreState,1);
      
1251.                                     break;
      
1252.                               case KEY_FIND:
      
1253.                                     if(RemoteKey.Time.Interval>=600/TIME_BASE)
      
1254.                                     {
      
1255.                                           RemoteKey.Flag.Press=0;
      
1256.                                           Energency=TRUN_FLASH;
      
1257.                                           flash_trun_signal(0,0,0);
      
1258.                                           if(speak_act_precoss(0,0,0,RESET));
      
1259.                                     }                                
      
1260.                                     break;
      
1261.                               case KEY_QUIET:
      
1262.                                     RemoteKey.Flag.Press=0;
      
1263.                                     system_state_change(State,PreState,1);
      
1264.                               default:break;
      
1265.                         }
      
1266.                   }
      
1267.                   break;         
      
1268.             case TRUN_FLASH:
      
1269.                   if(flash_trun_signal(500/TIME_BASE,500/TIME_BASE,33));
      
1270.                   if(speak_act_precoss(0,0,33000/TIME_BASE/5,LONG))
      
1271.                   {
      
1272.                         flash_trun_signal(0,0,0);
      
1273.                         speak_act_precoss(0,0,0,RESET);
      
1274.                         Energency=DELAY_8S;
      
1275.                         Timer8S.Interval=0;
      
1276.                   }
      
1277.                   if(RemoteKey.Flag.Press)
      
1278.                   {
      
1279.                         RemoteKey.Flag.Press=0;
      
1280.                         switch(RemoteKey.Key)
      
1281.                         {
      
1282.                               case KEY_UNLOCK:
      
1283.                                     system_state_change(State,PreState,0);
      
1284.                                     break;
      
1285.                               default:break;
      
1286.                         }
      
1287.                   }
      
1288.                   break;   
      
1289.             case DELAY_8S:
      
1290.                   if(++Timer8S.Interval>=8000/TIME_BASE)
      
1291.                         Energency=TRUN_FLASH;
      
1292.                   if(RemoteKey.Flag.Press)
      
1293.                   {
      
1294.                         RemoteKey.Flag.Press=0;
      
1295.                         switch(RemoteKey.Key)
      
1296.                         {
      
1297.                               case KEY_UNLOCK:
      
1298.                                     system_state_change(State,PreState,0);
      
1299.                                     break;
      
1300.                               default:break;
      
1301.                         }
      
1302.                   }
      
1303. ……………………
      
1304. 
      
1305. …………限于本文篇幅 余下代码请从51黑下载附件…………
      

复制代码

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

2019-2-22 12:26 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: 918kb    时间: 2019-5-12 17:54
很好的学习资料   谢谢楼主

---

作者: hkhk    时间: 2019-8-14 15:34
下载不到啊

---

作者: meilidianzhi    时间: 2019-8-29 19:23
学习一下谢谢楼主

---

作者: hanxufu    时间: 2019-9-16 15:25
下载学习下

---

作者: jzyjsjt    时间: 2019-9-28 13:25
很好的学习资料   感谢！

---

作者: 阿飞7812    时间: 2019-11-27 08:57
谢谢分亨

---

作者: waerdeng    时间: 2019-11-27 12:07

谢谢楼主 很好的学习资料 下载了  

---

作者: sxh123    时间: 2019-12-17 07:55


谢谢楼主分享，下载学习！

---

作者: 阿飞7812    时间: 2019-12-27 09:33
谢谢分亨 好资源

---

作者: 双悦电子    时间: 2019-12-27 12:47
太好了，我现在在学

---

作者: 双悦电子    时间: 2019-12-27 12:50
谢谢分享

---

作者: 双悦电子    时间: 2019-12-27 13:12
谢谢分享

---

作者: yifenghua    时间: 2020-3-19 15:35
谢谢分享

---

作者: fengrenjie    时间: 2020-5-1 15:15
433M 第一次做 谢谢资料

---

作者: 中恒电子asus    时间: 2020-7-13 01:00
很好的学习资料   谢谢楼主

---

作者: chengfgc    时间: 2020-9-11 10:52
很好的学习资料,多多交流

---

作者: czj7221    时间: 2020-9-29 11:39
很完整的资料，谢谢楼主分享！

---

作者: jyllf52    时间: 2020-10-30 19:52
很好的学习资料，楼主辛苦了！

---

作者: nanfuB    时间: 2020-11-15 17:15
谢谢分享，看起来是带遥控启动的

---

作者: radio0326    时间: 2021-5-18 13:26
东西很不错啊，难得学习实践资料

---

作者: wlefa    时间: 2021-5-20 22:05
学习汽车电子资料

---

作者: zkele    时间: 2021-7-19 07:55
谢谢分享,很好的学习资料

---

作者: bowaterbo    时间: 2021-12-26 17:35
东西很不错啊，难得学习实践资料

---

作者: noshape    时间: 2022-1-20 20:42
谢谢分享,很好的学习资料，Mark

---

作者: davidxu    时间: 2022-2-24 17:39
很好的学习资料   谢谢楼主

---

作者: dykhuable1    时间: 2022-6-3 11:04

很好的学习资料   谢谢楼主

---

作者: zbysir51888    时间: 2022-8-27 11:01

很好的学习资料   感谢分享！

---

作者: fj51hei    时间: 2023-8-6 10:21
这个利害了，都是干货

---

作者: jxdianqi    时间: 2024-2-27 17:50
由衷感谢楼主无私，下载学习了

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1