标题: PL1167SPI通讯固定频率发信号STM8程序源码(RF认证用) [打印本页]

---

作者: zrzhou    时间: 2018-9-13 10:11
标题: PL1167SPI通讯固定频率发信号STM8程序源码(RF认证用)
代码用于客户产品的PL1167 RF认证用，SPI通讯PL1167，固定频率一直发一个信号。供参考
MCU：STM8S103
IDE : IAR FOR STM8


单片机源程序如下:

1. #include "PL1167Certify.h"
   
2. 
   
3. u8 u8DeviceMode;
   
4. bool bFlagTimer100us,bFlagTimer4ms,bFlagTimer1s,bFlagTimer4ms1,bFlagAcOn,bFlagBtOffTimerOk,bFlagUartTxOn,bFlagSppCmdSend;
   
5. 
   
6. u8 u8IntensityLevel;
   
7. 
   
8. bool bFlagKeyPauseChk,bFlagKeyProcess,bFlagKeyLock;
   
9. extern bool bFlagKeyPress;
   
10. extern u8 u8KeyValue,u8KeyStatus;
    
11. u8 u8KeyValueBuffer;
    
12. 
    
13. extern bool bFlagDcPowerOn;
    
14. 
    
15. bool bFlagRfRxGet;
    
16. bool bFlagLed1,bFlagLed2,bFlagLed3,bFlagLed4,bFlagLed5,bFlagLed6,bFlagLedStatus;
    
17. u8 u8LedFlashCount;
    
18. 
    
19. u16 u16LedFlashSet[21][2]={
    
20.         {0,0},
    
21.         {210,50},{200,50},{190,50},{180,50},{170,50},
    
22.         {160,50},{150,50},{140,50},{130,50},{120,50},
    
23.         {110,50},{100,50},{90,50},{80,50},{70,50},
    
24.         {60,40},{50,40},{40,30},{30,20},{20,15}
    
25. };
    
26. u16 u16DcCount;
    
27. u16 u16DcCountBuf[6]={0,0,0,0,0,0
    
28. };
    
29. 
    
30. //u16 u16IntensLevelDuty[20]={
    
31. 
    
32. //};
    
33. u8 u8PwmCycleLargeCount,u8PwmCycleLargeCountMax;
    
34. u8 u8PwmCycleLittleCount,u8PwmCycleLittleCountOffset,u8PwmCycleLittleCountEnd;
    
35. u8 u8PwmOnCycleLittleCount,u8PwmOnCycleLittleCountOffset,u8PwmOnCycleLittleCountEnd;
    
36. u8 u8PwmCycleMidCount,u8PwmCycleMidCountBuffer,u8PwmCycleMidRepeat,u8PwmCycleMidRepeatMax;
    
37. u16 u16PwmCycleMidCount,u16PwmCycleMidCountMax;
    
38. u8 u8PwmCycleLittleCountBuffer,u8PwmCycle2LittleCount;
    
39. u8 u8RepeatCount;
    
40. 
    
41. u16 u16PwmOffCycle;
    
42. bool bFlagPwm2On,bFlagPwmCycleInc,bFlagPwmOnCycleInc,bFlagPwmCycleEnd;
    
43. bool bFlagPwmPro3Run;
    
44. bool bFlagPwmPro4Run,bFlagPwmPro4Next,bFlagPwmPro4End,bFlagPwmPro4First,bFlagPro4Second;
    
45. bool bFlagPwmOffCycle;
    
46. bool bFlagPwmDischarge=FALSE;
    
47. u8 u8DischargeCount=0;
    
48. u8 u8DischargeDuty=0;
    
49. extern u16 u16Pwm1DutySet[21];
    
50. extern u16 u16Pwm1Duty;
    
51. u16 u16Pwm1DutySave,u16Pwm2DutySave,u16Pwm3DutySave;
    
52. bool bFlagPwmPhaseEnd;
    
53. u8 u8PwmCyclePhase;
    
54. u8 u8RfRxBuffer[16],u8RfTxBuffer[16];
    
55. u8 u8RfStatus,u8RfAckCount;
    
56. bool bFlagRfReceive;
    
57. 
    
58. u8 u8SystemMode;
    
59. u8 u8Timer100us,u8Timer2ms,u8Timer4ms,u8TimerRf4ms,u8Timer1s,u8Timer1m;
    
60. u8 u8Hours=0X0,u8Minutes=0X0,u8Seconds=0X0,u8Months=0X1,u8Dates=0X1;
    
61. u16 u16Years=0X2014;
    
62. u8 u8TimerMinutesCountDown,u8TimerSecondsCountDown;
    
63. u8 u8TimerMode;
    
64. 
    
65. main()
    
66. {
    
67.   MCU_init();
    
68.   System_init();
    
69.   system_off_init();
    
70.   while(1)
    
71.   {       
    
72.           enableInterrupts();
    
73.           if (bFlagTimer4ms)
    
74.           {
    
75.                         bFlagTimer4ms=FALSE;
    
76.                         switch (u8SystemMode)
    
77.                         {
    
78.                         case SYSTEM_ON:
    
79.                                
    
80.                                 //if (bFlagTimer4ms1)
    
81.                                 {
    
82.                                         //bFlagTimer4ms1=FALSE;
    
83.                                         key_pro_system_on();
    
84.                                         led_pro_system_on();
    
85.                                 }
    
86.         send_rf_key_inc();
    
87.                                 timer_count_down_pro();
    
88.                                 break;
    
89.                         case SYSTEM_OFF:
    
90.                         default:
    
91.                                 all_output_off();
    
92.                                 delay(KEY_DELAY);
    
93.                                 if ((KEY_INPUT)&&(u8KeyStatus==KEY_RELEASE)&&(u8RfAckCount==0)&&(!POWER_IN))
    
94.                                 {
    
95.                     //PULSE donot output
    
96. //                   GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_SLOW);
    
97. //                   GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3), GPIO_MODE_OUT_PP_HIGH_SLOW);
    
98. //                   delay(20000);
    
99. //                   GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_SLOW);
    
100.                     pl1167_init();
     
101.                     pl1167_write_reg(0x23,0x4380);
     
102.                                         active_to_sleep();
     
103.                                         halt();
     
104.                     nop();
     
105.                     nop();
     
106.                     nop();
     
107.                     nop();
     
108.                                         sleep_to_active();
     
109.                     pl1167_init();
     
110.                     //pl1167_write_reg(0x23,0xc380);
     
111.                                 }
     
112.                 if(!bFlagDcPowerOn)
     
113.                 {
     
114.                     key_pro_system_off();
     
115.                 }
     
116.                                 break;
     
117.                         }
     
118.                         watchdog_reset();
     
119.                         key_scan();
     
120.           }
     
121.   }
     
122. }
     
123. 
     
124. void
     
125. device_mode1_init()
     
126. {
     
127.         u8DeviceMode=DEVICE_MODE1;
     
128.     u8IntensityLevel=INTENS_MIN;
     
129.         mode1_phase1_init();
     
130. }
     
131. void
     
132. device_mode2_init()
     
133. {
     
134.         u8DeviceMode=DEVICE_MODE2;
     
135.     u8IntensityLevel=INTENS_MIN;
     
136.         mode2_phase1_init();
     
137. 
     
138. }
     
139. void
     
140. device_mode3_init()
     
141. {
     
142.         u8DeviceMode=DEVICE_MODE3;
     
143.     u8IntensityLevel=INTENS_MIN;
     
144.         mode3_phase1_init();
     
145. }
     
146. void
     
147. device_mode4_init()
     
148. {
     
149.         u8DeviceMode=DEVICE_MODE4;
     
150.     u8IntensityLevel=INTENS_MIN;
     
151.         u8PwmCycleLargeCount=0;
     
152.         u8PwmCycleLittleCount=0;
     
153.         u8PwmCycleMidCount=0;
     
154.     TIM2_OC3Init(TIM2_OCMODE_PWM1, TIM2_OUTPUTSTATE_ENABLE, 0x0000, TIM2_OCPOLARITY_HIGH);
     
155.         u8PwmCycleLittleCountBuffer=MODE4_PWM_CYCLE_LITTLE_START;
     
156.     pwm_cycle_pro3();
     
157. //        pwm1_set_period(23726);
     
158. //        pwm1_set_duty(0);
     
159. //        pwm2_set_duty(20905);
     
160. //        pwm3_set_duty(20905);
     
161. }
     
162. void
     
163. device_mode5_init()
     
164. {
     
165.         u8DeviceMode=DEVICE_MODE5;
     
166.     u8IntensityLevel=INTENS_MIN;
     
167.         u8PwmCycleLargeCount=0;
     
168.         u8PwmCycleLittleCount=0;
     
169.         u8PwmCycleMidCount=0;
     
170.     TIM2_OC3Init(TIM2_OCMODE_PWM1, TIM2_OUTPUTSTATE_ENABLE, 0x0000, TIM2_OCPOLARITY_HIGH);
     
171. //        u8PwmCycleLittleCountBuffer=MODE4_PWM_CYCLE_LITTLE_START;
     
172.     pwm_cycle_pro3();
     
173. 
     
174. }
     
175. void
     
176. device_mode6_init()
     
177. {
     
178.         u8DeviceMode=DEVICE_MODE6;
     
179.     u8IntensityLevel=INTENS_MIN;
     
180.     u8PwmCyclePhase=1;
     
181.         mode6_phase1_init();
     
182. }
     
183. 
     
184. void
     
185. discharge_pro(void)
     
186. {
     
187. 
     
188. }
     
189. 
     
190. void
     
191. key_pro_system_on()
     
192. {
     
193.         if (u8KeyStatus==KEY_RELEASE)
     
194.         {
     
195.                 bFlagKeyProcess=FALSE;
     
196. /*                if (bFlagKeyPauseChk)
     
197.                 {
     
198.                         send_rf_key_pause();
     
199.                         bFlagKeyPauseChk=FALSE;
     
200.                 }*/
     
201.         }
     
202.         if ((u8KeyStatus!=KEY_RELEASE)&&(bFlagKeyProcess==FALSE))
     
203.         {
     
204.                 switch (u8KeyValue)
     
205.                 {
     
206.                 case KEY_ON:
     
207.                        
     
208. //                        if (u8KeyStatus==KEY_KEEP_1S)
     
209. //                        {
     
210.                                 bFlagKeyPauseChk=FALSE;
     
211.                                 system_off_init();
     
212.                                 //send_rf_key_off();
     
213.                                 bFlagKeyProcess=TRUE;
     
214. //                        }
     
215. //                        else
     
216. //                                bFlagKeyPauseChk=TRUE;
     
217. 
     
218.                         //rfTxBufferFill();
     
219.                         break;
     
220.                 default:
     
221.                         break;
     
222.                        
     
223.                 }
     
224.         }
     
225. }
     
226. 
     
227. void
     
228. key_pro_system_off()
     
229. {
     
230.         if (u8KeyStatus==KEY_RELEASE)
     
231.         {
     
232.                 bFlagKeyProcess=FALSE;
     
233.         }
     
234.         if ((u8KeyStatus!=KEY_RELEASE)&&(bFlagKeyProcess==FALSE))
     
235.         {
     
236.                 bFlagKeyProcess=TRUE;
     
237.                 switch (u8KeyValue)
     
238.                 {
     
239.                 case KEY_ON:
     
240.                         system_on_init();
     
241. 
     
242.                         send_rf_key_on();
     
243.                         break;
     
244.                 default:
     
245.                         break;
     
246.                        
     
247.                 }
     
248.         }
     
249. }
     
250. void
     
251. led_pro_system_on()
     
252. {
     
253.         if (u8LedFlashCount>u16LedFlashSet[u8IntensityLevel][1])
     
254.         {
     
255.                 led_off();
     
256.         }
     
257.         else
     
258.                 led_on();
     
259.         u8LedFlashCount++;
     
260.         if (u8LedFlashCount>u16LedFlashSet[u8IntensityLevel][0])
     
261.         {
     
262.                 u8LedFlashCount=0;
     
263.         }
     
264. }
     
265. void
     
266. led_pro_device_mode()
     
267. {
     
268.         led_flag_clear();
     
269.         switch (u8DeviceMode)
     
270.     {
     
271.     case DEVICE_MODE1:
     
272.                 bFlagLed1=TRUE;
     
273.                 break;
     
274.     case DEVICE_MODE2:
     
275.                 bFlagLed2=TRUE;
     
276.                 break;
     
277.     case DEVICE_MODE3:
     
278.                 bFlagLed1=TRUE;
     
279.                 bFlagLed2=TRUE;
     
280.                 break;
     
281.     case DEVICE_MODE4:
     
282.                 bFlagLed3=TRUE;
     
283.                 break;
     
284.     case DEVICE_MODE5:
     
285.                 bFlagLed4=TRUE;
     
286.                 break;
     
287.     case DEVICE_MODE6:
     
288.                 bFlagLed3=TRUE;
     
289.                 bFlagLed4=TRUE;
     
290.                 break;
     
291.     default:
     
292.                 break;
     
293.     }
     
294. 
     
295. }
     
296. void
     
297. led_flag_clear()
     
298. {
     
299.         bFlagLed1=FALSE;
     
300. }
     
301. 
     
302. 
     
303. void
     
304. mode_phase_inc(u8 u8PhaseMax)
     
305. {       
     
306.         u8PwmCyclePhase++;
     
307.         if (u8PwmCyclePhase>u8PhaseMax)
     
308.         {
     
309.                 u8PwmCyclePhase=1;
     
310.         }
     
311. }
     
312. 
     
313. void
     
314. mode1_phase1_init()
     
315. {
     
316.         u8PwmCyclePhase=1;
     
317.         u8PwmCycleLittleCount=0;
     
318.         u8PwmCycleLittleCountBuffer=MODE1_PWM_CYCLE_LITTLE_START;
     
319.         u8PwmCycleLittleCountEnd=MODE1_PWM_CYCLE_LITTLE_END;
     
320.         bFlagPwmCycleInc=TRUE;
     
321.         u8PwmCycleLittleCountOffset=MODE1_PWM_CYCLE_LITTLE_OFFSET;
     
322. 
     
323.         u8PwmOnCycleLittleCountEnd=MODE1_PWM_ON_CYCLE_LITTLE_END;
     
324.         u8PwmOnCycleLittleCount=MODE1_PWM_ON_CYCLE_LITTLE_START;
     
325.         bFlagPwmOnCycleInc=TRUE;
     
326.         u8PwmOnCycleLittleCountOffset=MODE1_PWM_ON_CYCLE_LITTLE_OFFSET;
     
327. 
     
328.         u8PwmCycleMidRepeat=1;
     
329.         u8PwmCycleMidRepeatMax=MODE1_PWM_CYCLE_MID_REPEAT_MAX;
     
330.         u16PwmCycleMidCount=1;
     
331.         u16PwmCycleMidCountMax=MODE1_PWM_CYCLE_MID_MAX;
     
332. 
     
333.         //clear flag for phase end/cycle end
     
334.         bFlagPwmPhaseEnd=FALSE;
     
335.         bFlagPwmCycleEnd=FALSE;
     
336. }
     
337. 
     
338. void mode2_phase1_init()
     
339. {
     
340.         u8PwmCyclePhase=1;
     
341.         u8PwmCycleLittleCount=0;
     
342.         u8PwmCycleLittleCountBuffer=MODE2_PWM_CYCLE_LITTLE_START;
     
343.         u8PwmCycleLittleCountEnd=MODE2_PWM_CYCLE_LITTLE_END;
     
344.         bFlagPwmCycleInc=FALSE;
     
345.         u8PwmCycleLittleCountOffset=MODE2_PWM_CYCLE_LITTLE_OFFSET;
     
346. 
     
347.         u8PwmOnCycleLittleCountEnd=MODE2_PWM_ON_CYCLE_LITTLE_END;
     
348.         u8PwmOnCycleLittleCount=MODE2_PWM_ON_CYCLE_LITTLE_START;
     
349.         bFlagPwmOnCycleInc=TRUE;
     
350.         u8PwmOnCycleLittleCountOffset=MODE2_PWM_ON_CYCLE_LITTLE_OFFSET;
     
351. 
     
352.         u8PwmCycleMidRepeat=1;
     
353.         u8PwmCycleMidRepeatMax=MODE2_PWM_CYCLE_MID_REPEAT_MAX;
     
354.         u16PwmCycleMidCount=1;
     
355.         u16PwmCycleMidCountMax=MODE2_PWM_CYCLE_MID_MAX;
     
356. 
     
357.         //clear flag for phase end/cycle end
     
358.         bFlagPwmPhaseEnd=FALSE;
     
359.         bFlagPwmCycleEnd=FALSE;
     
360. 
     
361. }
     
362. void mode2_phase5_init()
     
363. {
     
364.         u8PwmCyclePhase=5;
     
365. 
     
366.         u8PwmCycleLittleCount=0;
     
367.         u8PwmCycleLittleCountBuffer=202;
     
368.         u8PwmCycleLittleCountEnd=202;
     
369.     bFlagPwmCycleInc=TRUE;
     
370.         u8PwmCycleLittleCountOffset=0;
     
371. 
     
372.         u8PwmOnCycleLittleCountEnd=202;
     
373.         u8PwmOnCycleLittleCount=202;
     
374.         bFlagPwmOnCycleInc=FALSE;
     
375.         u8PwmOnCycleLittleCountOffset=0;
     
376. 
     
377.         u8PwmCycleMidRepeat=1;
     
378.         u8PwmCycleMidRepeatMax=1;
     
379.     u16PwmCycleMidCountMax=1;
     
380.     u16PwmCycleMidCount=1;
     
381. 
     
382.         //clear flag for phase end/cycle end
     
383.         bFlagPwmPhaseEnd=FALSE;
     
384.         bFlagPwmCycleEnd=FALSE;
     
385. 
     
386. }
     
387. 
     
388. void mode3_phase1_init()
     
389. {
     
390.         u8PwmCyclePhase=1;
     
391.         u8PwmCycleLittleCount=0;
     
392.         u8PwmCycleLittleCountBuffer=MODE3_PWM_CYCLE_LITTLE_START;
     
393.         u8PwmCycleLittleCountEnd=MODE3_PWM_CYCLE_LITTLE_END;
     
394.         bFlagPwmCycleInc=TRUE;
     
395.         u8PwmCycleLittleCountOffset=MODE3_PWM_CYCLE_LITTLE_OFFSET;
     
396. 
     
397.         u8PwmOnCycleLittleCountEnd=MODE3_PWM_ON_CYCLE_LITTLE_END;
     
398.         u8PwmOnCycleLittleCount=MODE3_PWM_ON_CYCLE_LITTLE_START;
     
399.         bFlagPwmOnCycleInc=TRUE;
     
400.         u8PwmOnCycleLittleCountOffset=MODE3_PWM_ON_CYCLE_LITTLE_OFFSET;
     
401. 
     
402.         u8PwmCycleMidRepeat=1;
     
403.         u8PwmCycleMidRepeatMax=MODE3_PWM_CYCLE_MID_REPEAT_MAX;
     
404.         u16PwmCycleMidCount=1;
     
405.         u16PwmCycleMidCountMax=MODE3_PWM_CYCLE_MID_MAX;
     
406. 
     
407.         //clear flag for phase end/cycle end
     
408.         bFlagPwmPhaseEnd=FALSE;
     
409.         bFlagPwmCycleEnd=FALSE;
     
410. 
     
411. }
     
412. void mode3_phase3_init()
     
413. {
     
414.         u8PwmCyclePhase=3;
     
415.         u16PwmOffCycle=MODE3_PWM_OFF_CYCLE_LITTLE_MAX;
     
416. }
     
417. 
     
418. void
     
419. mode6_phase1_init()
     
420. {
     
421.         pwm_cycle_count_reset();
     
422.         u8PwmCycleLittleCountBuffer=PWM_PRO1_CYCLE_LITTLE_START;
     
423.         u8PwmCycleLittleCountEnd=40;
     
424.         u8PwmOnCycleLittleCountEnd=40;
     
425.         u8PwmOnCycleLittleCount=40;
     
426.     bFlagPwmCycleInc=FALSE;
     
427.         u8PwmCycleLittleCountOffset=6;
     
428.         bFlagPwmOnCycleInc=TRUE;
     
429.         u8PwmOnCycleLittleCountOffset=0;
     
430.         u8PwmCycleMidRepeat=1;
     
431.         u8PwmCycleMidRepeatMax=PWM_PRO1_CYCLE_MID_MAX;
     
432.     u16PwmCycleMidCountMax=403;
     
433.     u16PwmCycleMidCount=1;
     
434.         //clear flag for phase end/cycle end
     
435.         bFlagPwmPhaseEnd=FALSE;
     
436.         bFlagPwmCycleEnd=FALSE;
     
437. }
     
438. void
     
439. mode6_phase3_1_init()
     
440. {
     
441.         pwm_cycle_count_reset();
     
442.         u8PwmCycleLittleCountBuffer=82;
     
443.         u8PwmCycleLittleCountEnd=82;
     
444.     bFlagPwmCycleInc=TRUE;
     
445.         u8PwmCycleLittleCountOffset=0;
     
446. 
     
447.         u8PwmOnCycleLittleCountEnd=82;
     
448.         u8PwmOnCycleLittleCount=82;
     
449.         bFlagPwmOnCycleInc=TRUE;
     
450.         u8PwmOnCycleLittleCountOffset=0;
     
451. 
     
452.         u8PwmCycleMidRepeat=1;
     
453.         u8PwmCycleMidRepeatMax=1;
     
454.     u16PwmCycleMidCountMax=1;
     
455.     u16PwmCycleMidCount=1;
     
456. 
     
457.         //clear flag for phase end/cycle end
     
458.         bFlagPwmPhaseEnd=FALSE;
     
459.         bFlagPwmCycleEnd=FALSE;
     
460. }
     
461. void
     
462. mode6_phase5_init()
     
463. {
     
464. //        pwm_cycle_count_reset();
     
465. 
     
466.         u8PwmCycleLittleCount=0;
     
467.         u8PwmCycleLittleCountBuffer=PWM_PRO1_CYCLE_LITTLE_END+2;
     
468.         u8PwmCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
     
469.     bFlagPwmCycleInc=TRUE;
     
470.         u8PwmCycleLittleCountOffset=0;
     
471. 
     
472.         u8PwmOnCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
     
473.         u8PwmOnCycleLittleCount=5;
     
474.         bFlagPwmOnCycleInc=TRUE;
     
475.         u8PwmOnCycleLittleCountOffset=3;
     
476. 
     
477.         u8PwmCycleMidRepeat=1;
     
478.         u8PwmCycleMidRepeatMax=1;
     
479.     u16PwmCycleMidCountMax=40;
     
480.     u16PwmCycleMidCount=1;
     
481. 
     
482.         //clear flag for phase end/cycle end
     
483.         bFlagPwmPhaseEnd=FALSE;
     
484.         bFlagPwmCycleEnd=FALSE;
     
485. }
     
486. void
     
487. mode6_phase11_1_init()
     
488. {
     
489.         bFlagPwmPro3Run=TRUE;
     
490. }
     
491. void
     
492. mode6_phase11_2_init()
     
493. {
     
494.         u8PwmCycleLittleCount=0;
     
495.         u8PwmCycleLittleCountBuffer=PWM_PRO1_CYCLE_LITTLE_END+2;
     
496.         u8PwmCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
     
497.     bFlagPwmCycleInc=TRUE;
     
498.         u8PwmCycleLittleCountOffset=0;
     
499. 
     
500.         u8PwmOnCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
     
501.         u8PwmOnCycleLittleCount=4;
     
502.         bFlagPwmOnCycleInc=TRUE;
     
503.         u8PwmOnCycleLittleCountOffset=2;
     
504. 
     
505.         u8PwmCycleMidRepeat=1;
     
506.         u8PwmCycleMidRepeatMax=1;
     
507.     u16PwmCycleMidCountMax=81;
     
508.     u16PwmCycleMidCount=1;
     
509. 
     
510.         //clear flag for phase end/cycle end
     
511.         bFlagPwmPhaseEnd=FALSE;
     
512.         bFlagPwmCycleEnd=FALSE;
     
513. }
     
514. void
     
515. mode6_phase11_3_init()
     
516. {
     
517.         u8PwmCycleLittleCount=0;
     
518.         u8PwmCycleLittleCountBuffer=PWM_PRO1_CYCLE_LITTLE_END+2;
     
519.         u8PwmCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
     
520.     bFlagPwmCycleInc=TRUE;
     
521.         u8PwmCycleLittleCountOffset=0;
     
522. 
     
523.         u8PwmOnCycleLittleCountEnd=4;
     
524.         u8PwmOnCycleLittleCount=PWM_PRO1_CYCLE_LITTLE_END+2;
     
525.         bFlagPwmOnCycleInc=FALSE;
     
526.         u8PwmOnCycleLittleCountOffset=2;
     
527. 
     
528.         u8PwmCycleMidRepeat=1;
     
529.         u8PwmCycleMidRepeatMax=1;
     
530.     u16PwmCycleMidCountMax=19;
     
531.     u16PwmCycleMidCount=1;
     
532. 
     
533.         //clear flag for phase end/cycle end
     
534.         bFlagPwmPhaseEnd=FALSE;
     
535.         bFlagPwmCycleEnd=FALSE;
     
536. }
     
537. void
     
538. mode6_phase17_1_init()
     
539. {
     
540.         bFlagPwmPro3Run=TRUE;
     
541. }
     
542. void
     
543. mode6_phase17_2_init()
     
544. {
     
545.         u8PwmCycleLittleCount=0;
     
546.         u8PwmCycleLittleCountBuffer=202;
     
547.         u8PwmCycleLittleCountEnd=202;
     
548.     bFlagPwmCycleInc=TRUE;
     
549.         u8PwmCycleLittleCountOffset=0;
     
550. 
     
551.         u8PwmOnCycleLittleCountEnd=202;
     
552.         u8PwmOnCycleLittleCount=202;
     
553.         bFlagPwmOnCycleInc=FALSE;
     
554.         u8PwmOnCycleLittleCountOffset=0;
     
555. 
     
556.         u8PwmCycleMidRepeat=1;
     
557.         u8PwmCycleMidRepeatMax=1;
     
558.     u16PwmCycleMidCountMax=1;
     
559.     u16PwmCycleMidCount=1;
     
560. 
     
561.         //clear flag for phase end/cycle end
     
562.         bFlagPwmPhaseEnd=FALSE;
     
563.         bFlagPwmCycleEnd=FALSE;
     
564. }
     
565. 
     
566. void
     
567. mode6_phase17_1_deinit()
     
568. {
     
569.         bFlagPwmPro3Run=FALSE;
     
570. }
     
571. void
     
572. rf_pro()
     
573. {
     
574.         if (u8RfAckCount)
     
575.         {
     
576.                 u8RfAckCount--;
     
577.                 send_rf_ack();
     
578.         }
     
579.         else
     
580.         {
     
581.                 if(u8TimerRf4ms>5)
     
582.                 {
     
583.        
     
584.                         pl1167_receive_data(u8RfRxBuffer,7);
     
585.                         if(bFlagRfRxGet)
     
586.                         {
     
587.                                 bFlagRfRxGet=FALSE;
     
588.                                 if (u8RfRxBuffer[6]=(u8RfRxBuffer[1]^u8RfRxBuffer[2]^u8RfRxBuffer[3]^u8RfRxBuffer[4]^u8RfRxBuffer[5]))
     
589.                                 {
     
590.                                         if ((u8RfRxBuffer[0]==0X06)&&(u8RfRxBuffer[1]==RF_SYNC))
     
591.                                         {
     
592.                                                 u8TimerRf4ms=0;
     
593.                                                 u8RfTxBuffer[5]=u8RfRxBuffer[4];        //send ack every cmd
     
594.                                                 switch (u8RfRxBuffer[4])
     
595.                                                 {
     
596.                                                 case RF_CMD_RC_OFF:
     
597.                                                         system_off_init();
     
598.                                                         send_rf_ack_start();
     
599.                                                         break;
     
600.                                                 case RF_CMD_RC_ON:
     
601.                                                         system_on_init();
     
602.                                                         send_rf_ack_start();
     
603.                                                         break;
     
604.                                                 case RF_CMD_RC_LOCK:
     
605.                                                         bFlagKeyLock=TRUE;
     
606.                                                         bFlagPwmDischarge=TRUE;
     
607.                                                         u8DischargeCount=1;
     
608.                                                         pwm1_set_period(23726);
     
609.                                                         pwm1_set_duty(0);
     
610.                                                         pwm2_set_duty(20904);
     
611.                                                         pwm3_set_duty(20904);                                                               
     
612.                                                         send_rf_ack_start();
     
613.                                                         break;
     
614.                                                 case RF_CMD_RC_UNLOCK:
     
615.                                                         bFlagKeyLock=FALSE;
     
616.                                                         u16Pwm1Duty=u16Pwm1DutySave;
     
617.                                                         send_rf_ack_start();
     
618.                                                         break;
     
619.                                                 case RF_CMD_RC_TIMER:
     
620.                                                         if (u8TimerMode>TIMER_MODE_50M)
     
621.                                                         {
     
622.                                                                 u8TimerMode=TIMER_MODE_10M;
     
623.                                                         }
     
624.                                                         else
     
625.                                                                 u8TimerMode+=10;
     
626.                                                         u8TimerSecondsCountDown=0;
     
627.                                                         switch (u8TimerMode)
     
628.                                                         {
     
629.                                                         case TIMER_MODE_10M:
     
630.                                                         default:
     
631.                                                                 u8TimerMinutesCountDown=10;
     
632.                                                                 break;
     
633.                                                         case TIMER_MODE_20M:
     
634.                                                                 u8TimerMinutesCountDown=20;
     
635.                                                                 break;
     
636.                                                         case TIMER_MODE_30M:
     
637.                                                                 u8TimerMinutesCountDown=30;
     
638.                                                                 break;
     
639.                                                         case TIMER_MODE_40M:
     
640.                                                                 u8TimerMinutesCountDown=40;
     
641.                                                                 break;
     
642.                                                         case TIMER_MODE_50M:
     
643.                                                                 u8TimerMinutesCountDown=50;
     
644.                                                                 break;
     
645.                                                         case TIMER_MODE_60M:
     
646.                                                                 u8TimerMinutesCountDown=60;
     
647.                                                                 break;
     
648. 
     
649.                                                         }
     
650.                                                         send_rf_ack_start();
     
651.                                                         break;
     
652.                                                 case RF_CMD_RC_MODE:
     
653.                                                         u8DeviceMode=u8RfRxBuffer[5];
     
654.                                                         bFlagPwmDischarge=TRUE;
     
655.                                                         u8DischargeCount=1;
     
656.                             //u8DischargeDuty=180;
     
657.                                                         pwm1_set_period(23726);
     
658.                                                         pwm1_set_duty(0);
     
659.                                                         pwm2_set_duty(20904);
     
660.                                                         pwm3_set_duty(20904);                       
     
661. //                                                        pwm1_set_period(200);
     
662. //                                                        pwm1_set_duty(0);
     
663. //                                                        pwm2_set_duty(u8DischargeDuty);
     
664. //                                                        pwm3_set_duty(u8DischargeDuty);
     
665.                                                         switch (u8DeviceMode)
     
666.                                                         {
     
667.                                                         default:
     
668.                                                         case DEVICE_MODE1:
     
669.                                                                 device_mode1_init();
     
670.                                                                 break;
     
671.                                                         case DEVICE_MODE2:
     
672.                                                                 device_mode2_init();
     
673.                                                                 break;
     
674.                                                         case DEVICE_MODE3:
     
675.                                                                 device_mode3_init();
     
676.                                                                 break;
     
677.                                                         case DEVICE_MODE4:
     
678.                                                                 device_mode4_init();
     
679.                                                                 break;
     
680.                                                         case DEVICE_MODE5:
     
681.                                                                 device_mode5_init();
     
682.                                                                 break;
     
683.                                                         case DEVICE_MODE6:
     
684.                                                                 device_mode6_init();
     
685.                                                                 break;
     
686.                                                         }
     
687.        
     
688.                             u16Pwm1Duty=u16Pwm1DutySet[u8IntensityLevel];
     
689.                                                         u16Pwm1DutySave=u16Pwm1Duty;
     
690.                                                         send_rf_ack_start();
     
691.                                                         break;
     
692.                                                 case RF_CMD_RC_INTENS_INC:
     
693.                                                         if (u8IntensityLevel<INTENS_MAX)
     
694.                                                         {
     
695.                                                                 u8IntensityLevel++;
     
696.                                                         }
     
697.                                                         else
     
698.                                                                 u8IntensityLevel=INTENS_MAX;
     
699.                                                         u16Pwm1Duty=u16Pwm1DutySet[u8IntensityLevel];
     
700.                                                         u16Pwm1DutySave=u16Pwm1Duty;
     
701.                                                         send_rf_ack_start();
     
702.                                                         break;
     
703.                                                 case RF_CMD_RC_INTENS_DEC:
     
704.                                                         if (u8IntensityLevel>INTENS_MIN)
     
705.                                                         {
     
706.                                                                 u8IntensityLevel--;
     
707.                                                         }
     
708.                                                         else
     
709.                                                                 u8IntensityLevel=INTENS_MIN;
     
710.                                                         u16Pwm1Duty=u16Pwm1DutySet[u8IntensityLevel];
     
711.                                                         u16Pwm1DutySave=u16Pwm1Duty;
     
712.                                                         send_rf_ack_start();
     
713.                                                         break;
     
714.                                                 }
     
715.                                         }
     
716.                                 }
     
717.                                 u8RfRxBuffer[0]=0;
     
718.                                 u8RfRxBuffer[1]=0;
     
719.                                 u8RfRxBuffer[2]=0;
     
720.                                 u8RfRxBuffer[3]=0;
     
721.                                 u8RfRxBuffer[4]=0;
     
722.                                 u8RfRxBuffer[5]=0;
     
723.                                 u8RfRxBuffer[6]=0;
     
724.                         }
     
725.                 }
     
726.         }
     
727. }
     
728. 
     
729. 
     
730. void
     
731. send_rf_key_mode()
     
732. {
     
733. 
     
734. }
     
735. void
     
736. send_rf_key_off()
     
737. {
     
738.     u8RfTxBuffer[5]=RF_CMD_DEVICE_OFF;
     
739.     send_rf_ack_start();
     
740. }
     
741. void
     
742. send_rf_key_on()
     
743. {
     
744. 
     
745. }
     
746. void
     
747. send_rf_key_pause()
     
748. {
     
749. 
     
750. }
     
751. void
     
752. send_rf_ack()
     
753. {
     
754.         u8RfTxBuffer[0]=0x06;
     
755.         u8RfTxBuffer[1]=RF_SYNC;
     
756.         u8RfTxBuffer[2]=RF_CMD_LENGTH6;
     
757.         u8RfTxBuffer[3]=MAINBOARD1;
     
758.         u8RfTxBuffer[4]=RF_CMD_DEVICE_ACK;
     
759.         //u8RfTxBuffer[5]=0x00;
     
760.         u8RfTxBuffer[6]=u8RfTxBuffer[1]^u8RfTxBuffer[2]^u8RfTxBuffer[3]^u8RfTxBuffer[4]^u8RfTxBuffer[5];
     
761.         pl1167_send_data(u8RfTxBuffer,7);
     
762. }
     
763. void
     
764. send_rf_key_inc()
     
765. {
     
766.         u8RfTxBuffer[0]=0x06;
     
767.         u8RfTxBuffer[1]=RF_SYNC;
     
768.         u8RfTxBuffer[2]=RF_CMD_LENGTH6;
     
769.         u8RfTxBuffer[3]=REMOTE_CONTROL;
     
770.         u8RfTxBuffer[4]=RF_CMD_RC_INTENS_INC;
     
771.         u8RfTxBuffer[5]=0X00;
     
772.         u8RfTxBuffer[6]=u8RfTxBuffer[1]^u8RfTxBuffer[2]^u8RfTxBuffer[3]^u8RfTxBuffer[4]^u8RfTxBuffer[5];
     
773.         pl1167_send_data(u8RfTxBuffer,7);
     
774. }
     
775. void
     
776. send_rf_ack_start()
     
777. {
     
778.         u8RfAckCount=RF_ACK_COUNT_MAX;
     
779.         send_rf_ack();
     
780. }
     
781. 
     
782. void
     
783. System_init()
     
784. {
     
785.         timer_reset();
     
786.         pl1167_init();
     
787.         bFlagDcPowerOn=false;
     
788. }
     
789. 
     
790. void
     
791. system_on_init()
     
792. {
     
793.     GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_SLOW);
     
794.     GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3), GPIO_MODE_OUT_PP_HIGH_SLOW);
     
795.     delay(10000);
     
796.     GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_SLOW);
     
797.         /*CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, ENABLE);
     
798.         TIM2_DeInit();
     
799.         //GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_FAST);
     
800.         //GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3), GPIO_MODE_OUT_PP_HIGH_FAST);
     
801.     //delay(20000);
     
802.         TIM2_TimeBaseInit(TIM2_PRESCALER_4, PWM1_PERIOD);
     
803.         TIM2_ARRPreloadConfig(ENABLE);
     
804.         TIM2_UpdateRequestConfig(TIM2_UPDATESOURCE_REGULAR);
     
805.         TIM2_OC1Init(TIM2_OCMODE_PWM1, TIM2_OUTPUTSTATE_ENABLE, 0x0000, TIM2_OCPOLARITY_HIGH);
     
806.         TIM2_OC1PreloadConfig(ENABLE);
     
807.         TIM2_OC2Init(TIM2_OCMODE_PWM1, TIM2_OUTPUTSTATE_ENABLE, 0x0000, TIM2_OCPOLARITY_HIGH);
     
808.         TIM2_OC2PreloadConfig(ENABLE);
     
809.         TIM2_OC3Init(TIM2_OCMODE_PWM1, TIM2_OUTPUTSTATE_ENABLE, 0x0000, TIM2_OCPOLARITY_HIGH);
     
810.         TIM2_OC3PreloadConfig(ENABLE);
     
811. 
     
812.         pwm1_set_duty(0);
     
813.         pwm2_set_duty(0);
     
814.         pwm3_set_duty(0);
     
815.         pwm1_start();
     
816.   */
     
817.   u8SystemMode=SYSTEM_ON;
     
818.         bFlagLed1=TRUE;
     
819.         //device_mode1_init();
     
820.         //u16Pwm1Duty=u16Pwm1DutySet[u8IntensityLevel];
     
821.   
     
822.         //pwm1_start();
     
823.         //pl1167_receive_enable();
     
824. 
     
825.         u8TimerMode=TIMER_MODE_20M;
     
826.         u8TimerMinutesCountDown=20;
     
827.         u8TimerSecondsCountDown=0;
     
828.         bFlagKeyLock=FALSE;
     
829. 
     
830.         u8RfAckCount=0;
     
831. }
     
832. 
     
833. void
     
834. system_off_init()
     
835. {
     
836.         u8SystemMode=SYSTEM_OFF;
     
837.         bFlagLed1=FALSE;
     
838. //        all_output_off();
     
839.         u8RfStatus=RF_IDLE;
     
840.     TIM2_DeInit();
     
841.     //u16Pwm1Duty=0;
     
842.     //pwm1_set_duty(u16Pwm1Duty);
     
843.     //pwm2_set_duty(0);
     
844.     //pwm3_set_duty(0);
     
845.     GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_SLOW);
     
846.     GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3), GPIO_MODE_OUT_PP_HIGH_SLOW);
     
847.     delay(50000);
     
848.     GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)(GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4), GPIO_MODE_OUT_PP_LOW_SLOW);
     
849.    
     
850. }
     
851. void
     
852. timer_reset()
     
853. {
     
854.         u8Timer2ms=0;
     
855.         u8Timer4ms=0;
     
856.         u8Timer1m=0;
     
857.         u8Timer1s=0;
     
858. }
     
859. void
     
860. timer_count_down_pro()
     
861. {
     
862.         if (bFlagTimer1s)
     
863.         {
     
864.                 bFlagTimer1s=FALSE;
     
865.                 if (u8TimerSecondsCountDown>0)
     
866.                 {
     
867.                         u8TimerSecondsCountDown--;
     
868.                 }
     
869.                 else
     
870.                 {
     
871.                         u8TimerSecondsCountDown=59;
     
872.                         if (u8TimerMinutesCountDown==0)
     
873.                         {
     
874.                                 system_off_init();
     
875.                                 u8TimerSecondsCountDown=0;
     
876.                         }
     
877.                         else
     
878.                                 u8TimerMinutesCountDown--;
     
879.                 }
     
880.         }
     
881. }
     
882. #pragma vector=15
     
883. __interrupt void timer2_interrupt(void)
     
884. {
     
885.         TIM2_ClearFlag(TIM2_FLAG_UPDATE);
     
886. 
     
887.         if (bFlagPwmDischarge)
     
888.         {
     
889.                 if (u8DischargeCount==0)
     
890.                 {
     
891.                         bFlagPwmDischarge=FALSE;
     
892. ……………………
     
893. 
     
894. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
PL1167Certify.rar (3.83 MB, 下载次数: 31)

2018-9-13 17:30 上传

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

---

作者: zwg0106    时间: 2019-5-30 15:12
正需要，thanks

---

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

Powered by Discuz! X3.1