单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

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

一个MS83f系列单片机的多功能程序(自适应模糊PID算法)

[复制链接]
跳转到指定楼层
楼主
liuguonianhua 发表于 2019-2-14 20:12 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  这个程序NB在哪儿呢,在用了自适应模糊PID算法,不过主函数中我把整个结构去除了,因为做的项目属于公司的,但是保留了所有功能函数,可以直接使用功能。另外要说一句,最好用14引脚的同款芯片来实现功能,因为复用编程器引脚会经常在写入程序时报错。

单片机源程序:
  1. /*                ----------------
  2. *  VDD----------|1(VDD)   (GND)8|------------GND
  3. *  RED--------- |2(RA6)   (PA0)7|------------GREEN
  4. *  PWM3--------|3(PC3)   (PA1)6|------------AD2
  5. *  AD6-----------|4(PC2)   (PC4)5|------------PWM4
  6. *                 ----------------
  7. */
  8. /*程序说明:ADC转换,通过ADC测量实现灯的转变,通过ADC测量,对输出mcu引脚频率以及占空比进行控制,从而达到控制输出电流电压*/
  9. /*timer0 用的是1:256分频,timer0增1周期为32us,中断一次耗时32us*255=8.16ms*/
  10. /*自设的pwm~pa6采用系统时钟的80分频,即一个pwm周期为0.125us*80=10us,由软件方法实现设定,PA6的震动频率是80的整倍数,占空比自调(必须由中断计时)*/
  11. /*为降低定时器中断产生的难度,暂时将pwm周期设置为20us,由__delay_us()函数来完成。*/
  12. /* 注意:本程序所有的占空比是小数表示,不是用百分数表示*/
  13. #include "syscfg.h"
  14. #include "MS83Fxx02.h"
  15. #include<stdio.h>


  16. #define _XTAL_FREQ                 32000000  //内部晶振频率为16M
  17. //时钟周期与机器周期为1:1,2T模式下,2个机器周期为一个指令周期,当前系统指令周期为0.125us,



  18. //******************************
  19. #define red_on     PA6=0;
  20. #define red_off    PA6=1;
  21. #define green_on   PA0=0;
  22. #define green_off  PA0=1;
  23. //*****************************//
  24. #define shutled {red_off;green_off;} //所有的灯熄灭
  25. #define openled {red_on;green_on;} //所有灯打开
  26. #define TMR0_VALUE_INIT       5;//1个timer0中断是(255-5)*0.125us*256=8ms,1250个timer0中断是1s
  27. #define delay_num  500;   //大量延时用的默认毫秒值
  28. unsigned int interrupt_time=0;          //timer0中断次数
  29. float adc_avg_num=0, VCC=0.0;     //ADC转换出来的数值

  30. /*-------------------模糊自适应pid-------------------*/
  31. #define IS_Kp 1
  32. #define IS_Ki 2
  33. #define IS_Kd 3

  34. #define NL   -3
  35. #define NM   -2
  36. #define NS         -1
  37. #define ZE         0
  38. #define PS         1
  39. #define PM         2
  40. #define PL         3



  41. static const float fuzzyRuleKp[7][7]={
  42.         PL,        PL,        PM,        PM,        PS,        PS,        ZE,
  43.         PL,        PL,        PM,        PM,        PS,        ZE,        ZE,
  44.         PM,        PM,        PM,        PS,        ZE,        NS,        NM,
  45.         PM,        PS,        PS,        ZE,        NS,        NM,        NM,
  46.         PS,        PS,        ZE,        NS,        NS,        NM,        NM,
  47.         ZE,        ZE,        NS,        NM,        NM,        NM,        NL,
  48.         ZE,        NS,        NS,        NM,        NM,        NL,        NL
  49. };

  50. static const float fuzzyRuleKi[7][7]={
  51.         NL,        NL,        NL,        NM,        NM,        ZE,        ZE,
  52.         NL,        NL,        NM,        NM,        NS,        ZE,        ZE,
  53.         NM,        NM,        NS,        NS,        ZE,        PS,        PS,
  54.         NM,        NS,        NS,        ZE,        PS,        PS,        PM,
  55.         NS,        NS,        ZE,        PS,        PS,        PM,        PM,
  56.         ZE,        ZE,        PS,        PM,        PM,        PL,        PL,
  57.         ZE,        ZE,        PS,        PM,        PL,        PL,        PL
  58. };

  59. static const float fuzzyRuleKd[7][7]={
  60.         PS,        PS,        ZE,        ZE,        ZE,        PL,        PL,
  61.         NS,        NS,        NS,        NS,        ZE,        NS,        PM,
  62.         NL,        NL,        NM,        NS,        ZE,        PS,        PM,
  63.         NL,        NM,        NM,        NS,        ZE,        PS,        PM,

  64.         NL,        NM,        NS,        NS,        ZE,        PS,        PS,
  65.         NM,        NS,        NS,        NS,        ZE,        PS,        PS,
  66.         PS,        ZE,        ZE,        ZE,        ZE,        PL,        PL
  67. };

  68. typedef struct{
  69.         float Kp;
  70.         float Ki;
  71.         float Kd;
  72. }PID;

  73. PID fuzzy(float e,float ec);//e 误差,ec误差变化率
  74. float speed_pid(float s_tar,float s_cur);//在目标值会多次改变的情况下,建议在函数内部初始pid参数而不是作为形参

  75. /*-------------------------------模糊自适应pid结束---------------------------------*/



  76. void Delay_xms(unsigned int);//不精准的毫秒延时
  77. void Delay_xus(unsigned int);//不精准的微妙延时
  78. void colck_init(void);//所有时钟初始化
  79. void interrupt_init(void);//中断模块初始化
  80. void io_init(void);//所有io初始化
  81. void adc_init(void);//adc模块初始化
  82. void pwm_colck_init(void);//pwm初始化,IO端口将在set_pwm中设置,本函数主要初始化的是相关时钟配置
  83. void shutdown_pwmall(void);//关闭所有PWM,同时使P1C和P1B引脚状态固定pc4=1;pc3=0;
  84. unsigned int start_tran_adc(void);//官方给定的ADC程序
  85. unsigned int start_tran_adc2(void);//专门用来测量电流值大小
  86. unsigned int start_tran_adc_vcc(void);//用来测量VCC电压
  87. void set_pwm_frequence(unsigned int, float);//设置PA6端口周期和占空比,调用_delay_us()函数完成,如果用定时器中断,则基准频率可以最高提升到8M,
  88. void set_duty(float duty);//占空比操作封装
  89. void set_cycle(unsigned int cycle);//周期操作封装
  90. void set_pwm1(float duty,unsigned int cycle);//系统pc3引脚的pwm设置,//PWM周期 Tpwm=(PR2+1)*4*Tsys*预分频
  91. void set_pwm2(float duty,unsigned int cycle);//系统pc4引脚的pwm设置
  92. void set_half_bridge(float duty,unsigned int cycle);//系统pc3,pc3组成的半桥pwm设置
  93. void controlpwm_calc(float expecte_volate,float expecte_current);//输入预期电流电压,该程序自动调控,设置占空比和频率
  94. void controlpwm_fruzy_pid(float expecte_voltage,float expecte_current);//自适应模糊PID控制算法




  95. float avg_adc_value(unsigned int frequency);//平均多次采样数据,采样次数由frequency 确定
  96. void act_led(float);//根据adc转化的值处理灯闪烁状态
  97. void breathe_led(unsigned int,float);//呼吸灯程序


  98. void system_check(void);//系统闪灯自检

  99. /*********************************************main*****************************************************************************/

  100. int main()
  101. {

  102.     colck_init();
  103.         interrupt_init();
  104.     io_init();
  105.     adc_init();

  106. system_check();

  107. INTCON=0B10000000;




  108.   // while(ADC_time>1250)//1250*8ms=10秒,每10秒启动一次检测
  109.         while (1)
  110.         {

  111.                     {
  112.                 VCC=12*start_tran_adc_vcc()/1023;
  113.                 act_led(VCC);
  114.                   interrupt_time=0;

  115.                    }



  116.         }

  117. }
  118. /*********************************************************************************************************************/







  119. void colck_init(void)//中心频率16M,2T模式,看门狗禁用,定时器0中断
  120. {
  121.     //UCFG0
  122. ////////关键数据//////////////
  123.     OPTION=0B00000111;//time0定时器,PORTA上拉使能,下降沿中断,内部时钟,预分频器给timer0使用,timer0 256分频
  124.     OSCCON=0B11110101;//低频,256Khz,timer0每一指令周期加1,16M系统时钟focs
  125.     WDTCON=0B00010110;//看门狗时钟源32khz,65565分频,溢出周期为32khz/65535,软件关闭看门狗(sbit<0>)
  126.     ADCON1=0B01010000;//ADC选择内部时钟16分频(ADC采样频率为16M/16=1M)

  127. ////////关键数据//////////////*


  128.     //T1CON=0B10000101;//time1定时器,高电平有效,1:1分频,内部时钟
  129.     //T2CON&=0B11111000;//time2定时器关闭
  130.     /*全局中断及time1中断在此设置*/




  131. }

  132. void interrupt_init(void)//关闭比较器中断,禁止ADC中断
  133. {
  134.         INTCON=0B10100000;//全局中断使能,TIMER0中断使能
  135.         PIE1 = 0b00000000;
  136.         PIE2 = 0b00000000;
  137.         PIR1 = 0b00000000;
  138.         PIR2 = 0b00000000;
  139.         IOCA=0B00000000;
  140. }



  141. void io_init(void)
  142. {
  143.      //GPIO 设置为输出时,弱上拉会自动关断,此点可作为测试关键点
  144.     CMCON0=0B00000111;//关闭PA6引脚的比较模式
  145.     MSCKCON=0B00000000;



  146.      TRISA=0B00000000;//全部porta引脚配置为输出
  147.       TRISC=0B00000100;//除PC2配置为AN6输入外,其他全部配置为输出
  148.       PORTA=0B00000000;//初始化porta端口,全部低电平
  149.       PORTC=0B00000000;//初始化portc端口,全部低电平
  150.       ANSEL=0B01000000;//除AN6通道为模拟输入外,其他全部设置为数字IO

  151.        WPUA=0B00000000;//全部弱上拉使能
  152.        WPUC=0B00000000;//全部允许弱上拉
  153.         WPD=0B00000000;//pc2,PA4,PC1,PC3都设置为下拉
  154. }




  155. void adc_init(void)
  156. {
  157.    // ADCON0=0B10111000;//右对齐,内部2v参考电压,AN6模拟通道,转换完成,禁止ADC开始(sbit<0>)
  158.     ADCON0=0B11011000;//参考3v,sbit<6:5> 10 3v,01 2v,00 VCC
  159.     ADCON1=0B01100000;//ADC采样时间初始化,初始化为系统时钟的64分频
  160.         //ADCON0=0B10111100;//1/4VDD an7
  161. }






  162. float avg_adc_value(unsigned int frequency)//平均多次转换结果,使转换结果更稳定
  163. {

  164.         float temp=0,Value_tmp=0,Value_min=1000000,Value_max=-100000;
  165.         if(0==frequency){frequency=1;}
  166.         else if(frequency<10)
  167.     {
  168.         for(int T=0;T<frequency;T++)
  169.          {
  170.         temp=(6*(start_tran_adc())/1023);//3V参考电压
  171.         Value_tmp+=temp;
  172.          }
  173.         Value_tmp=(Value_tmp/frequency);
  174.     }

  175.     else
  176.         {for(int T=0;T<frequency;T++)
  177.          {
  178.         temp=(6*(start_tran_adc())/1023);
  179.         Value_tmp+=temp;
  180.         if(temp>Value_max) {Value_max=temp;}
  181.         if(temp<Value_min) {Value_min=temp;}
  182.          }
  183.         Value_tmp=Value_tmp-(Value_max+Value_min);

  184.         Value_tmp=(Value_tmp/(frequency-2));
  185.         }
  186. return Value_tmp;
  187. }




  188. void act_led(float tmp)//根据adc转换的平均结果控制闪灯
  189. {


  190.     if(tmp>=4.16)//大于4.16v充满,绿灯常亮
  191.     {
  192.         red_off;
  193.         green_on;
  194.     }
  195.   else if(tmp>4.0&&tmp<4.08)//3.0v~4.08v补足充电,绿灯闪
  196.     {
  197.         red_off;
  198.         green_on;__delay_ms(200);green_off;__delay_ms(200);


  199.     }
  200.   else if(tmp=4.0){breathe_led();}
  201.     else if(tmp>=3.0&&tmp<4.0)//3.0v~4.0v快充阶段,红绿灯交替闪
  202.     {
  203.          red_off;green_on;
  204.        __delay_ms(100);
  205.          red_on;green_off;
  206.        __delay_ms(100);


  207.     }
  208.    else if(tmp>=0.5&&tmp<3.0)//预充阶段,红灯闪烁
  209.     {
  210.             green_off;
  211.             red_on;__delay_ms(200);
  212.             red_off;__delay_ms(200);
  213.     }
  214.    else //故障,红灯常亮
  215.     {
  216.         green_off;
  217.         red_on;

  218.     }

  219. }




  220. void interrupt ISR(void){
  221.         if(T0IE&&T0IF){
  222.                 T0IF=0;
  223.                 TMR0=TMR0_VALUE_INIT;//赋初值
  224.                 interrupt_time++;//系统指令周期0.125us*256分频* TMR0是8位256=0.125*256*256=8.192ms
  225.         }
  226. }
  227. /////////////////////////////////////////////


  228. void set_pwm_frequence(unsigned int circle,float Duty)//分辨率1us,输入单位100us
  229. {

  230.     PA6=1;
  231.     Delay_xus(circle*Duty*100);
  232.     PA6=0;
  233.     Delay_xus(circle*(1-Duty)*100);

  234. }

  235. void breathe_led(unsigned int freqs,float dutys)
  236. {
  237.     freqs=100000/freqs;
  238.     green_on;red_off;
  239.     Delay_xus((freqs*dutys));
  240.     green_off;red_on;
  241.     Delay_xus((freqs*(1-dutys)));

  242. }




  243. ///////////////////////////////////////////////breathe of led test  function ///////////





  244. void Delay_xms(unsigned int integerA){

  245.         for(unsigned int i=0;i<integerA;i++){
  246.                 __delay_ms(1);
  247.         }
  248. }

  249. void Delay_xus(unsigned int integerB){

  250.         for (unsigned int x=0;x<integerB;x++){
  251.                 __delay_us(1);
  252.         }
  253. }



  254. PID fuzzy(float e,float ec)//e 误差,ec误差变化率
  255. {

  256.      float etemp,ectemp;
  257.      float eLefttemp,ecLefttemp;
  258.      float eRighttemp ,ecRighttemp;

  259.      int eLeftIndex,ecLeftIndex;
  260.      int eRightIndex,ecRightIndex;
  261.      PID      fuzzy_PID;
  262.      etemp = e > 3.0 ? 0.0 : (e < - 3.0 ? 0.0 : (e >= 0.0 ? (e >= 2.0 ? 2.5: (e >= 1.0 ? 1.5 : 0.5)) : (e >= -1.0 ? -0.5 : (e >= -2.0 ? -1.5 : (e >= -3.0 ? -2.5 : 0.0) ))));

  263.      eLeftIndex = (int)e;
  264.      eRightIndex = eLeftIndex;
  265.      eLeftIndex = (int)((etemp-0.5) + 3);        //[-3,3] -> [0,6]
  266.      eRightIndex = (int)((etemp+0.5) + 3);

  267.      eLefttemp =etemp == 0.0 ? 0.0:((etemp+0.5)-e);
  268.      eRighttemp=etemp == 0.0 ? 0.0:( e-(etemp-0.5));

  269.      ectemp = ec > 3.0 ? 0.0 : (ec < - 3.0 ? 0.0 : (ec >= 0.0 ? (ec >= 2.0 ? 2.5: (ec >= 1.0 ? 1.5 : 0.5)) : (ec >= -1.0 ? -0.5 : (ec >= -2.0 ? -1.5 : (ec >= -3.0 ? -2.5 : 0.0) ))));

  270.      ecLeftIndex = (int)((ectemp-0.5) + 3);        //[-3,3] -> [0,6]
  271.      ecRightIndex = (int)((ectemp+0.5) + 3);

  272.      ecLefttemp =ectemp == 0.0 ? 0.0:((ectemp+0.5)-ec);
  273.      ecRighttemp=ectemp == 0.0 ? 0.0:( ec-(ectemp-0.5));

  274. ///////*************************************反模糊*************************************//////




  275.         fuzzy_PID.Kp = (eLefttemp * ecLefttemp *  fuzzyRuleKp[ecLeftIndex][eLeftIndex]
  276.                                         + eLefttemp * ecRighttemp * fuzzyRuleKp[ecRightIndex][eLeftIndex]
  277.                                         + eRighttemp * ecLefttemp * fuzzyRuleKp[ecLeftIndex][eRightIndex]
  278.                                         + eRighttemp * ecRighttemp * fuzzyRuleKp[ecRightIndex][eRightIndex]);

  279.         fuzzy_PID.Ki =   (eLefttemp * ecLefttemp * fuzzyRuleKi[ecLeftIndex][eLeftIndex]
  280.                                         + eLefttemp * ecRighttemp * fuzzyRuleKi[ecRightIndex][eLeftIndex]
  281.                                         + eRighttemp * ecLefttemp * fuzzyRuleKi[ecLeftIndex][eRightIndex]
  282.                                         + eRighttemp * ecRighttemp * fuzzyRuleKi[ecRightIndex][eRightIndex]);

  283.         fuzzy_PID.Kd = (eLefttemp * ecLefttemp *    fuzzyRuleKd[ecLeftIndex][eLeftIndex]
  284.                                         + eLefttemp * ecRighttemp * fuzzyRuleKd[ecRightIndex][eLeftIndex]
  285.                                         + eRighttemp * ecLefttemp * fuzzyRuleKd[ecLeftIndex][eRightIndex]
  286.                                         + eRighttemp * ecRighttemp * fuzzyRuleKd[ecRightIndex][eRightIndex]);
  287. return fuzzy_PID;

  288. }


  289. float speed_pid(float s_tar,float s_cur)//在目标值会多次改变的情况下,建议在函数内部初始pid参数而不是作为形参
  290. {
  291.         float tar = 0,cur = 0;      //目标值 , 实际值
  292.         tar=s_tar;s_cur=cur;
  293.     static PID pid= {1, 0, 0};      //赋予初值kp,ki,kd
  294.         static float sumE = 0;                   //累加偏差
  295.         static float lastE = 0;

  296.         PID OUT = {0, 0, 0};
  297.         float e = -1,ec = -2.6;



  298.         e = tar - cur;             //目标值 - 实际值
  299.         ec = e - lastE;            //误差变化率
  300.         sumE += e;
  301.         lastE = e;
  302.         OUT = fuzzy(e, ec);      //模糊控制调整  kp,ki,kd

  303.         return (pid.Kp+OUT.Kp)*e + (pid.Kd+OUT.Kd)*ec + (pid.Ki+OUT.Ki)*sumE;
  304. }
  305. /////////////////////////////
  306. void pwm_colck_init(void)
  307. {
  308.     TMR2IF = 0;  //中断标志位清零
  309.         T2CON = 0B00000100;//timer2预分频比<1,0> 00 1:1  与系统时钟1:1

  310. }
  311. void shutdown_pwmall(void)
  312. {
  313.     ECCPAS=0B00000001;
  314. }
  315. unsigned int start_tran_adc(void)
  316. {
  317.             unsigned int TempADCBuffer=0;
  318.             TRISC=0B00000100;//除PC2配置为AN6输入外,其他全部配置为输出
  319.         ANSEL=0B01000000;//配置an6信号为模拟信号
  320.         ADCON0 = 0b11011001;                        //右对齐,ADC使能,AN6通道,3V参考电压
  321.         __delay_us(20);
  322.         GO_DONE=1;   //开始转换
  323.         while(GO_DONE==1) ;        //等待转换完成
  324.         TempADCBuffer = ADRESH;
  325.         TempADCBuffer = (TempADCBuffer<<8)|ADRESL;
  326.         asm("nop");
  327.         ADON = 0;
  328.       ANSEL=0B00000000;//关闭模拟输入an6
  329.       TRISC=0B00000000;//关闭AN6,防止影响另一路adc
  330.         return(TempADCBuffer);
  331. }

  332. unsigned int start_tran_adc2(void)
  333. {
  334.             unsigned int TempADCBuffer=0;
  335.             TRISA=0B00000010;//除PA1配置为AN1输入外,其他全部配置为输出
  336.         ANSEL=0B00000010;


  337.         ADCON0= 0b10100101;                        //右对齐,ADC使能,选择AN1通道,2V参考电压,AN1通道,pa1口
  338.         __delay_us(20);
  339.         GO_DONE=1;   //开始转换
  340.         while(GO_DONE==1) ;        //等待转换完成
  341.         TempADCBuffer = ADRESH;
  342.         TempADCBuffer = (TempADCBuffer<<8)|ADRESL;
  343.         asm("nop");
  344.         ADON = 0;
  345.       ANSEL=0B00000000;//关闭模拟输入an1
  346.       TRISA=0B00000000;//关闭AN1,防止影响另一路adc
  347.         return(TempADCBuffer);
  348. }
  349. unsigned int start_tran_adc_vcc(void)
  350. {
  351.     unsigned int TempADCBuffer=0;
  352.             TRISA=0B00000000;//全部配置为输出
  353.         ANSEL=0B10000000;//配置an7信号为模拟信号
  354.         //ADCON0= 0b10111101;                        //右对齐,ADC使能,采集内部1/4VCC通道信号,2V参考
  355.         ADCON0= 0b11011101;  //3v参考
  356.         __delay_us(20);
  357.         GO_DONE=1;   //开始转换
  358.         while(GO_DONE==1) ;        //等待转换完成
  359.         TempADCBuffer = ADRESH;
  360.         TempADCBuffer = (TempADCBuffer<<8)|ADRESL;
  361.         asm("nop");
  362.         ADON = 0;
  363.       ANSEL=0B00000000;//关闭模拟输入an1
  364.       TRISA=0B00000000;//关闭AN1,防止影响另一路adc
  365.         return(TempADCBuffer);
  366. }
  367. void set_duty(float duty)
  368. {
  369.      unsigned int t_duty=0;
  370.         /********************************占空比操作******************************/
  371.         t_duty=duty*(4*(PR2+1));//占空比是10位,高8位放在CCR1L,低2位被放在CCP1CON 的DC1B<1:0>中,所以为了封装进行了以下一系列操作
  372.         CCPR1L=t_duty>>2;
  373.         t_duty=t_duty-CCPR1L;
  374.         t_duty=t_duty<<4;
  375.         CCP1CON=t_duty|CCP1CON;
  376.         /********************************占空比操作完毕******************************/

  377. }
  378. void set_cycle(unsigned int cycle)
  379. { unsigned int timer2_prescaler=0;

  380.     /********************************PWM周期操作******************************/
  381.     timer2_prescaler=T2CON;
  382.     timer2_prescaler&=0b01111000;
  383.     timer2_prescaler=timer2_prescaler>>3;
  384.         PR2 = (cycle*4/timer2_prescaler-1);
  385.         /********************************PWM周期操作完毕******************************/
  386. }
  387. void set_pwm1(float duty,unsigned int cycle)  //Tpwm=(PR2+1)*4*Tsys*预分频 ,pwm周期cycle单位是1us
  388. {



  389.     TRISC3 = 1;


  390.     set_duty(duty);set_cycle(cycle);
  391.     CCP1CON|=0B00001101;
  392.         CCP1CON&=0b00111101; //PWM模式,单输出,P1C高电平有效,P1B低电平有效
  393.         TMR2IF = 0;
  394.         T2CON = 0B00000100;
  395.         while(TMR2IF==0)  ;
  396.         TRISC3 = 0;
  397. }

  398. void set_pwm2(float duty,unsigned int cycle)  //Tpwm=(PR2+1)*4*Tsys*预分频 ,pwm周期cycle单位是1us
  399. {



  400.     TRISC4 = 1;

  401.     set_duty(duty);set_cycle(cycle);
  402.     CCP1CON|=0B00001101;
  403.         CCP1CON&=0b00111101; //PWM模式,单输出,P1C高电平有效,P1B低电平有效
  404.         TMR2IF = 0;
  405.         T2CON = 0B00000100;
  406.         while(TMR2IF==0)  ;
  407.         TRISC4= 0;
  408. }

  409. void set_half_bridge(float duty,unsigned int cycle)
  410. {

  411.     TRISC4 = 1;TRISC3=1;
  412.     set_duty(duty);set_cycle(cycle);

  413.     CCP1CON|=0B00001101;
  414.         CCP1CON&=0b00111101; //PWM模式,单输出,P1C高电平有效,P1B低电平有效
  415.         TMR2IF = 0;
  416.         T2CON = 0B00000100;
  417.         while(TMR2IF==0)  ;
  418.         TRISC4= 0;TRISC3=0;
  419. }

  420. /*以下程序为控制算法*///控制算法1
  421. void controlpwm_calc(float expecte_voltage,float expecte_current)//根据公式计算的算法1
  422. {
  423.     float duty_temp=0.0 , cycle_temp=0.0;
  424.     VCC=8*start_tran_adc_vcc()*1023;//10bit adc,2V参考电压,采集1/4 vcc电压
  425.     duty_temp=expecte_voltage/VCC;
  426.     cycle_temp=1.2*expecte_current/(VCC*(1-duty_temp));

  427.     set_half_bridge(duty_temp,cycle_temp);

  428. }
  429. void controlpwm_fruzy_pid(float expecte_voltage,float expecte_current)//模糊自适应pid
  430. {
  431.     float duty_temp=0.0 ,pid_temp=0.0, s_cur=0,s_vol=0;
  432.     unsigned int cycle_temp=0;
  433.     VCC=8*start_tran_adc_vcc()/1023;
  434.     s_vol=9*start_tran_adc()/1023;
  435.     s_cur=4*start_tran_adc2()/5115;
  436.     pid_temp=speed_pid(expecte_voltage,s_vol);
  437.   duty_temp=pid_temp/VCC;//s_vol 是调整输出电压的数据
  438.   cycle_temp=1.2*VCC*speed_pid( expecte_current,s_cur)/(1-duty_temp);//s_cur 是调整电流的数据,由另一路ADC完成
  439.   set_half_bridge(duty_temp,cycle_temp);
  440. }

  441. void system_check(void)
  442. {

  443. for(char i=0;i<3;i++)
  444. {
  445.   red_on;green_on;Delay_xms(i*100);
  446.   green_off;red_off;Delay_xms((4-i)*100);
  447. }

  448. }
复制代码

评分

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

查看全部评分

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

使用道具 举报

沙发
ljl76 发表于 2019-3-14 14:31 | 只看该作者
楼主,你这个自适应模糊PID算法能适应所有PID方面的应用吗?譬如:温度控制,电机控制,气压控制等。谢谢!
回复

使用道具 举报

板凳
qiu4466 发表于 2019-3-25 13:55 | 只看该作者
支持一下楼主,不错的资料
回复

使用道具 举报

地板
 楼主| liuguonianhua 发表于 2019-4-10 11:23 | 只看该作者
ljl76 发表于 2019-3-14 14:31
楼主,你这个自适应模糊PID算法能适应所有PID方面的应用吗?譬如:温度控制,电机控制,气压控制等。谢谢!

是的,但是实际的项目还需要根据硬件来调整代码,PID这部分你可以把他当成一个函数用,已经封装的很好了。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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