设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › PL1167SPI通讯固定频率发信号STM8程序源码(RF认证用)
返回列表 发新帖
查看: 2004|回复: 1
打印 上一主题 下一主题
收起左侧

PL1167SPI通讯固定频率发信号STM8程序源码(RF认证用)

[复制链接]
跳转到指定楼层
楼主
ID:386004 发表于 2018-9-13 10:11 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
代码用于客户产品的PL1167 RF认证用，SPI通讯PL1167，固定频率一直发一个信号。供参考
MCU：STM8S103
IDE : IAR FOR STM8


单片机源程序如下:
  1. #include "PL1167Certify.h"

  3. u8 u8DeviceMode;
  4. bool bFlagTimer100us,bFlagTimer4ms,bFlagTimer1s,bFlagTimer4ms1,bFlagAcOn,bFlagBtOffTimerOk,bFlagUartTxOn,bFlagSppCmdSend;

  6. u8 u8IntensityLevel;

  8. bool bFlagKeyPauseChk,bFlagKeyProcess,bFlagKeyLock;
  9. extern bool bFlagKeyPress;
  10. extern u8 u8KeyValue,u8KeyStatus;
  11. u8 u8KeyValueBuffer;

  13. extern bool bFlagDcPowerOn;

  15. bool bFlagRfRxGet;
  16. bool bFlagLed1,bFlagLed2,bFlagLed3,bFlagLed4,bFlagLed5,bFlagLed6,bFlagLedStatus;
  17. u8 u8LedFlashCount;

  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. };

  30. //u16 u16IntensLevelDuty[20]={

  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;

  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;

  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;

  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. }

  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();

  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();

  174. }
  175. void
  176. device_mode6_init()
  177. {
  178.         u8DeviceMode=DEVICE_MODE6;
  179.     u8IntensityLevel=INTENS_MIN;
  180.     u8PwmCyclePhase=1;
  181.         mode6_phase1_init();
  182. }

  184. void
  185. discharge_pro(void)
  186. {

  188. }

  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;

  218.                         //rfTxBufferFill();
  219.                         break;
  220.                 default:
  221.                         break;
  222.                        
  223.                 }
  224.         }
  225. }

  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();

  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.     }

  295. }
  296. void
  297. led_flag_clear()
  298. {
  299.         bFlagLed1=FALSE;
  300. }


  303. void
  304. mode_phase_inc(u8 u8PhaseMax)
  305. {       
  306.         u8PwmCyclePhase++;
  307.         if (u8PwmCyclePhase>u8PhaseMax)
  308.         {
  309.                 u8PwmCyclePhase=1;
  310.         }
  311. }

  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;

  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;

  328.         u8PwmCycleMidRepeat=1;
  329.         u8PwmCycleMidRepeatMax=MODE1_PWM_CYCLE_MID_REPEAT_MAX;
  330.         u16PwmCycleMidCount=1;
  331.         u16PwmCycleMidCountMax=MODE1_PWM_CYCLE_MID_MAX;

  333.         //clear flag for phase end/cycle end
  334.         bFlagPwmPhaseEnd=FALSE;
  335.         bFlagPwmCycleEnd=FALSE;
  336. }

  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;

  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;

  352.         u8PwmCycleMidRepeat=1;
  353.         u8PwmCycleMidRepeatMax=MODE2_PWM_CYCLE_MID_REPEAT_MAX;
  354.         u16PwmCycleMidCount=1;
  355.         u16PwmCycleMidCountMax=MODE2_PWM_CYCLE_MID_MAX;

  357.         //clear flag for phase end/cycle end
  358.         bFlagPwmPhaseEnd=FALSE;
  359.         bFlagPwmCycleEnd=FALSE;

  361. }
  362. void mode2_phase5_init()
  363. {
  364.         u8PwmCyclePhase=5;

  366.         u8PwmCycleLittleCount=0;
  367.         u8PwmCycleLittleCountBuffer=202;
  368.         u8PwmCycleLittleCountEnd=202;
  369.     bFlagPwmCycleInc=TRUE;
  370.         u8PwmCycleLittleCountOffset=0;

  372.         u8PwmOnCycleLittleCountEnd=202;
  373.         u8PwmOnCycleLittleCount=202;
  374.         bFlagPwmOnCycleInc=FALSE;
  375.         u8PwmOnCycleLittleCountOffset=0;

  377.         u8PwmCycleMidRepeat=1;
  378.         u8PwmCycleMidRepeatMax=1;
  379.     u16PwmCycleMidCountMax=1;
  380.     u16PwmCycleMidCount=1;

  382.         //clear flag for phase end/cycle end
  383.         bFlagPwmPhaseEnd=FALSE;
  384.         bFlagPwmCycleEnd=FALSE;

  386. }

  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;

  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;

  402.         u8PwmCycleMidRepeat=1;
  403.         u8PwmCycleMidRepeatMax=MODE3_PWM_CYCLE_MID_REPEAT_MAX;
  404.         u16PwmCycleMidCount=1;
  405.         u16PwmCycleMidCountMax=MODE3_PWM_CYCLE_MID_MAX;

  407.         //clear flag for phase end/cycle end
  408.         bFlagPwmPhaseEnd=FALSE;
  409.         bFlagPwmCycleEnd=FALSE;

  411. }
  412. void mode3_phase3_init()
  413. {
  414.         u8PwmCyclePhase=3;
  415.         u16PwmOffCycle=MODE3_PWM_OFF_CYCLE_LITTLE_MAX;
  416. }

  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;

  447.         u8PwmOnCycleLittleCountEnd=82;
  448.         u8PwmOnCycleLittleCount=82;
  449.         bFlagPwmOnCycleInc=TRUE;
  450.         u8PwmOnCycleLittleCountOffset=0;

  452.         u8PwmCycleMidRepeat=1;
  453.         u8PwmCycleMidRepeatMax=1;
  454.     u16PwmCycleMidCountMax=1;
  455.     u16PwmCycleMidCount=1;

  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();

  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;

  472.         u8PwmOnCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
  473.         u8PwmOnCycleLittleCount=5;
  474.         bFlagPwmOnCycleInc=TRUE;
  475.         u8PwmOnCycleLittleCountOffset=3;

  477.         u8PwmCycleMidRepeat=1;
  478.         u8PwmCycleMidRepeatMax=1;
  479.     u16PwmCycleMidCountMax=40;
  480.     u16PwmCycleMidCount=1;

  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;

  500.         u8PwmOnCycleLittleCountEnd=PWM_PRO1_CYCLE_LITTLE_END+2;
  501.         u8PwmOnCycleLittleCount=4;
  502.         bFlagPwmOnCycleInc=TRUE;
  503.         u8PwmOnCycleLittleCountOffset=2;

  505.         u8PwmCycleMidRepeat=1;
  506.         u8PwmCycleMidRepeatMax=1;
  507.     u16PwmCycleMidCountMax=81;
  508.     u16PwmCycleMidCount=1;

  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;

  523.         u8PwmOnCycleLittleCountEnd=4;
  524.         u8PwmOnCycleLittleCount=PWM_PRO1_CYCLE_LITTLE_END+2;
  525.         bFlagPwmOnCycleInc=FALSE;
  526.         u8PwmOnCycleLittleCountOffset=2;

  528.         u8PwmCycleMidRepeat=1;
  529.         u8PwmCycleMidRepeatMax=1;
  530.     u16PwmCycleMidCountMax=19;
  531.     u16PwmCycleMidCount=1;

  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;

  551.         u8PwmOnCycleLittleCountEnd=202;
  552.         u8PwmOnCycleLittleCount=202;
  553.         bFlagPwmOnCycleInc=FALSE;
  554.         u8PwmOnCycleLittleCountOffset=0;

  556.         u8PwmCycleMidRepeat=1;
  557.         u8PwmCycleMidRepeatMax=1;
  558.     u16PwmCycleMidCountMax=1;
  559.     u16PwmCycleMidCount=1;

  561.         //clear flag for phase end/cycle end
  562.         bFlagPwmPhaseEnd=FALSE;
  563.         bFlagPwmCycleEnd=FALSE;
  564. }

  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;

  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. }


  730. void
  731. send_rf_key_mode()
  732. {

  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. {

  745. }
  746. void
  747. send_rf_key_pause()
  748. {

  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. }

  782. void
  783. System_init()
  784. {
  785.         timer_reset();
  786.         pl1167_init();
  787.         bFlagDcPowerOn=false;
  788. }

  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);

  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();

  825.         u8TimerMode=TIMER_MODE_20M;
  826.         u8TimerMinutesCountDown=20;
  827.         u8TimerSecondsCountDown=0;
  828.         bFlagKeyLock=FALSE;

  830.         u8RfAckCount=0;
  831. }

  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);

  887.         if (bFlagPwmDischarge)
  888.         {
  889.                 if (u8DischargeCount==0)
  890.                 {
  891.                         bFlagPwmDischarge=FALSE;
  892. ……………………

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

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


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:551093 发表于 2019-5-30 15:12 | 只看该作者
正需要，thanks
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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