单片机控制算法
❶ 单片机pid算法控制步进电机的电路图和程序
//P1.1(T0):Count They Distance
//P0.4:Tx
//P0.5:Rx
#include <C8051F310.h> //SFR declarations
#include <stdio.h> //Standard I/O definition file
#include <math.h> //Math library file
#include <Intrins.h>
#include <absacc.h>
unsigned int j,i;
char a=0;
unsigned int t=0;
//sbit led=P0^2;
//P0.0(PWM0):给定左轮速度.
sbit vls=P0^4; //P0.4(GPIO):给定左轮方向.
sbit vlf=P0^6; //P0.6(T0) :反馈左轮速度.
sbit dlf=P1^0; //P1.0(GPIO):反馈左轮方向.
//P0.2(PWM0):给定右轮速度.
sbit vrs=P0^5; //P0.5(GPIO):给定右轮方向.
sbit vrf=P0^7; //P0.7(T0) :反馈右轮速度.
sbit drf=P1^1; //P1.1(GPIO):反馈右轮方向.
int ol; //左轮给定值
int len;
int len_1,len_2;
int lyn_1,lyn_2;
int vl1,vl2; //反馈左轮速度值(取样周期内的方波数)
int lfz; //运算后赋给PWM的值
int lyn,lynn;
int lun=0,lun_1=0; //偏差校正值 即校正PWM输出
int lunp,luni,lund; //PID 校正值
int or; //右轮给定值
int ren;
int ren_1,ren_2;
int ryn_1,ryn_2;
int vr1,vr2; //反馈右轮速度值(取样周期内的方波数)
int rfz; //运算后赋给PWM的值
int ryn,rynn;
int run=0,run_1=0; //偏差校正值 即校正PWM输出
int runp,runi,rund; //PID 校正值
float kp=2.0; //比例系数1.8
float kd=0.2; //微分系数0.4
float lki; //积分系数
void pio_init(void);
void sys_init(void);
void t01_init(void);
void TIME3_INT(void);
void PID(void);
void interrupt_init(void);
void delay(unsigned int x);
void pwm1_1(void);
void main(void)
{
PCA0MD &= ~0x40; //关闭
pio_init(); //P11为测距输入端
sys_init();
t01_init();
pwm1_1();
TIME3_INT();
interrupt_init();
vls=1;vrs=0;
while(1)
{
ol=50;
or=50;
delay(1000);
ol=100;
or=100;
delay(1000);
ol=-50;
or=50;
delay(1000);
}
}
void PID(void)
{
/****************左轮PID调节******************/
if(dlf==1)
{
lyn=(vl2*256+vl1); //dlf是左轮反馈方向，0表示向前 vl=TL0
}
else
{
lyn=-(vl2*256+vl1); //dlf=1表示是向后退，速度应该为负值
}
len=ol-lyn; //误差=给定速度-反馈速度(取样周期内的方波数)
if(abs(len)<8)//30
{
lki=1.4; //ki值的确定1.4
}
else
{
lki=0.05; //积分系数：如果 | 给定值-反馈值 | 太大
} //则就可以不引入积分，或者引入的很小0.05
lunp=kp*(len-len_1); //比例校正
luni=lki*len; //积分校正
lund=kd*(len-2*len_1+len_2); //微分校正
lun=lunp+luni+lund+lun_1; //总校正
/*************新旧数据更新*************************/
len_2=len_1;
len_1=len; //len:当前取样周期内出现的速度偏差;len_1:上次取样周期内出现的速度偏差
lun_1=lun; //lun:当前取样周期内得出的PWM校正值;lun_1:上次取样周期内得出的PWM校正值
/*************新旧数据更新*************************/
if(lun>255)
{
lun=255; //正速度
}
if(lun<-255)
{
lun=-255; //负速度
}
if(lun<0)
{
vls=1;
PCA0CPH0=-lun;
}
if(lun>=0)
{
vls=0;
PCA0CPH0=lun;
}
/****************右轮PID调节******************/
if(drf==0)
{
ryn=(vr2*256+vr1); //drf是右轮反馈方向，0表示向前 vl=TL0
}
else
{
ryn=-(vr2*256+vr1); //dlf=1表示是向后退，速度应该为负值
}
ren=or-ryn; //误差=给定速度-反馈速度(取样周期内的方波数)
if(abs(ren)<8)//30
{
lki=1.4; //ki值的确定1.4
}
else
{
lki=0.05; //积分系数：如果 | 给定值-反馈值 | 太大
} //则就可以不引入积分，或者引入的很小0.05
runp=kp*(ren-ren_1); //比例校正
runi=lki*ren; //积分校正
rund=kd*(ren-2*ren_1+ren_2); //微分校正
run=runp+runi+rund+run_1; //总校正
/*************新旧数据更新*************************/
ren_2=ren_1;
ren_1=ren; //len:当前取样周期内出现的速度偏差;len_1:上次取样周期内出现的速度偏差
run_1=run; //lun:当前取样周期内得出的PWM校正值;lun_1:上次取样周期内得出的PWM校正值
/*************新旧数据更新*************************/
if(run>255)
{
run=255; //正速度
}
if(run<-255)
{
run=-255; //负速度
}
if(run<0)
{
vrs=1;
PCA0CPH1=-run;
}
if(run>=0)
{
vrs=0;
PCA0CPH1=run;
}
//因为这里的PCA0CPH0越大，对应的电机速度越小，所以要255来减一下
}
void pio_init(void)
{
XBR0=0x00; //0000 0001
XBR1=0x72; //0111 0010 时能弱上拉 T0T1连接到脚口P06、P07 CEX0、CEX1连接到脚口P00、P01
P0MDIN=0xff; //模拟(0);数字(1) 1111 0011
P0MDOUT=0xc3;//开漏(0);推挽(1) 1111 1111
P0SKIP=0x3c; //0011 1100
P1MDIN=0xff; //1111 1111
P1MDOUT=0xfc;//
P1SKIP=0x00; //1111 1111
}
void sys_init(void) //12MHz
{
OSCICL=0x43;
OSCICN=0xc2;
CLKSEL=0x00;
}
void pwm1_1(void) //PWM的初始化
{
PCA0MD=0x08; //PCA时钟为12分频
PCA0CPL0=200; //左轮
PCA0CPM0=0x42; //设置左轮为8位PWM输出
PCA0CPH0=200;
PCA0CPL1=200; //平衡校正
PCA0CPM1=0x42; //设置为8位PWM输出
PCA0CPH1=200;
PCA0CN=0x40; //允许PCA工作
}
void t01_init(void)
{
TCON=0x50; //计数器1、2允许
TMOD=0x55; //定时器1、2采用16位计数功能
CKCON=0x00;
TH1=0x00; //用于采集左轮的速度
TL1=0x00;
TH0=0x00; //用于采集右轮的速度
TL0=0x00;
}
void TIME3_INT(void)
{
TMR3CN = 0x00; //定时器3为16位自动重载
CKCON &= ~0x40;
TMR3RLL = 0xff;
TMR3RLH = 0xd7;
TMR3L = 0xff;
TMR3H = 0xd7;
TMR3CN |= 0x04;
}
void T3_ISR() interrupt 14 //定时器3中断服务程序
{
//led=~led;
EA=0;
TCON &=~0x50; //关闭计数器0、1
vl1=TL0; //取左轮速度值
vl2=TH0;
vr1=TL1; //取右轮速度值
vr2=TH1;
TH1=0x00;
TL1=0x00;
TH0=0x00;
TL0=0x00;
PID(); //PID处理
TMR3CN &=~0x80; //清中断标志位
TCON |=0x50; //重新开计数器0、1
EA=1;
}
void interrupt_init(void)
{ IE=0x80;
IP=0x00;
EIE1|=0x80;
EIP1|=0x80;
}
void delay(unsigned int m) //延时程序
{
for(i=0;i<2000;i++)
{
for(j=0;j<m;j++){_nop_(); _nop_();}
}
}
❷ 单片机中的PID算法是什么意思啊，有什么用途呢谢谢！
pid就是比例积分微分算法
❸ pic单片机pid控制算法参数整定
我这有51的
#include <stdlib.h>
#include "global_varible.h"
/****************************************************************************
* 模块名: PID
* 描述: PID调节子程序
* 采用PID-PD算法。在偏差绝对值大于△e时，用PD算法，以改善动态品质。
* 当偏差绝对值小于△e时，用PID算法，提高稳定精度。
* PIDout=kp*e(t)+ki*[e(t)+e(t-1)+...+e(1)]+kd*[e(t)-e(t-1)]
*============================================================================
* 入口: 无
* 出口: 无
* 改变: PID_T_Run=加热时间控制
*****************************************************************************/
void PID_Math(void)
{
signed long ee1; //偏差一阶
//signed long ee2; //偏差二阶
signed long d_out; //积分输出
if(!Flag_PID_T_OK)
return;
Flag_PID_T_OK=0;
Temp_Set=3700; //温度控制设定值37.00度
PID_e0 = Temp_Set-Temp_Now; //本次偏差
ee1 = PID_e0-PID_e1; //计算一阶偏差
//ee2 = PID_e0-2*PID_e1+PID_e2; //计算二阶偏差
if(ee1 > 500) //一阶偏差的限制范围
ee1 = 500;
if(ee1 < -500)
ee1 = -500;
PID_e_SUM += PID_e0; //偏差之和
if(PID_e_SUM > 200) //积分最多累计的温差
PID_e_SUM = 200;
if(PID_e_SUM < -200)
PID_e_SUM = -200;
PID_Out = PID_kp*PID_e0+PID_kd*ee1; //计算PID比例和微分输出
if(abs(PID_e0) < 200) //如果温度相差小于1.5度则计入PID积分输出
{
if(abs(PID_e0) > 100) //如果温度相差大于1度时积分累计限制
{
if(PID_e_SUM > 100)
PID_e_SUM = 100;
if(PID_e_SUM < -100)
PID_e_SUM = -100;
}
d_out = PID_ki*PID_e_SUM; //积分输出
if(PID_e0 < -5) //当前温度高于设定温度0.5度时积分累计限制
{
if(PID_e_SUM > 150)
PID_e_SUM = 150;
if(PID_e_SUM > 0) //当前温度高于设定温度0.5度时削弱积分正输出
d_out >>= 1;
}
PID_Out += d_out; //PID比例,积分和微分输出
}
else
PID_e_SUM=0;
PID_Out/=100; //恢复被PID_Out系数放大的倍数
if(PID_Out > 200)
PID_Out=200;
if(PID_Out<0)
PID_Out=0;
if(PID_e0 > 300) //当前温度比设定温度低3度则全速加热
PID_Out=200;
if(PID_e0 < -20) //当前温度高于设定温度0.2度则关闭加热
PID_Out=0;
Hot_T_Run=PID_Out; //加热时间控制输出
PID_e2 = PID_e1; //保存上次偏差
PID_e1 = PID_e0; //保存当前偏差
}
////////////////////////////////////////////////////////////void PID_Math() end.
❹ 用单片机做PID算法控制问题
1.可以直接套用PID公式，无论增量还是绝对的。PID算法是根据误差来控制的算法，不依赖系统的模型，故不用算系统的传递函数。有的书提到传递函数，一般是用于理论建模仿真，从而直接用Matlab一类的仿真软件进行PID参数调试。得到的参数可以为实际应用提供一定参考价值。
2.PID参数整定有一套原则。首先要了解各个参数的作用。具体的整定方法，随便找本自控原理的书都会提到，我不太记得了，大致是有一个倍数关系。但实际操作，一般不会是用这个数，是需要根据系统的反应，改变各个参数来试的。尽信书不如无书啊~
另外，不同系统的参数肯定不一样。就算同一个系统，稍微有一些改变，可能最好的那组参数就会变化。因此衍生了很多先进PID算法，如神经PID、专家PID、模糊PID等等。
❺ 单片机是怎么用PID控制算法实现对电加热
那要看你计算出来的是什么了，如果直接是一个电流，那么直接用它来驱动加热炉就行，如果是一个误差值（理想值与真实值之差），那么就要先计算出要是电炉达到理想温度的电流值是多少，再用计算出的电流来驱动。希望能对你有帮助。
❻ stm32单片机能写复杂控制算法么
1.PID原理
1.1 P I D三个参数简单理解
1.2 P I D
1.3 PI PD PID适用系统
2.串级PID原理
3.PID代码
3.1 单级PID
3.1.1 初始化PID结构体
3.1.2 单级PID计算
3.1.3PID初始化
3.1.4 清空PID
3.2 串级PID
3.2.1 初始化串级PID结构体
3.2.2 串级PID计算
4.PID的使用
4.1 定义PID结构体并初始化
4.2 定义电机速度函数
4.3 在检测霍尔码盘时发送速度给电机
4.4 实验效果
1.PID原理
PID是什么，P，I，D的分别功能
你和PID调参大神之间，就差这篇文章！
1.1 P I D三个参数简单理解
P（比例）： 简单来说，P就是凉了加热水，热了加凉水。比目标值小，我就增加一点，比目标值大，我就减小一点。（现在）
P可能出现的问题： 1.P太小，达到目标值需要花费很长的时间，而且会有稳态误差。2.P太大，达到目标值时可能会一直震荡。
I（积分）： 将一段时间内的误差累积起来加到输出上，可以消除历史误差对当前实际曲线的影响，提高系统的稳定性。 （过去）
I可能出现的问题： 1.I太小，可以消除稳态误差，但太慢了，对于某些需要很快响应的系统，显然不能满足要求。2.I太大，累计误差占比过大，就会出现抖动现象，难以收敛。
D（微分）： 减小最大超调量。(下图中③就是最大超调量。) 可以有效减小震动的幅度。让曲线收敛更快 （未来）
D可能出现的问题： 1.D太小，作用小，时间长。2.D太大，为了减小超调量，补偿的过多，导致震荡很久。
在这里插入图片描述
1.2 P I D
先调P，逐渐增加P直到系统出现震荡，将当前值乘0.7就是较为合适的值。
再调I，将稳态误差逐渐降低。
后调D，将最大超调量降到最低。
1.3 PI PD PID适用系统
PI：响应速度要求不那么高的系统。
PD：大惯性系统。超调量太大。
PID：都可以。
网上将PID原理太多太多了，我的理解也都是参见上面的内容。认真看肯定有收获。
2.串级PID原理
【串级PID】浅谈串级PID作用及意义——快速理解串级PID结构优势
这里个人理解就是，单机PID就是稳定速度。而需要带位置和角度的就要用串级PID了。常用于平衡车，板球系统等。
而转速闭环称为串级PID的内环，位置 (角度) 闭环称为串级PID的外环。其实也很好理解，位移是速度的积分，只有速度慢慢稳定，位置才能确定。
3.PID代码
3.1 单级PID
3.1.1 初始化PID结构体
typedef struct _PID
{
float kp,ki,kd;
float error,lastError;//误差、上次误差
float integral,maxIntegral;//积分、积分限幅
float output,maxOutput;//输出、输出限幅
}PID;
1
2
3
4
5
6
7
1
2
3
4
5
6
7
3.1.2 单级PID计算
#define LIMIT(x,min,max) (x)=(((x)<=(min))?(min):(((x)>=(max))?(max):(x)))
//单级pid计算
void PID_SingleCalc(PID *pid,float reference,float feedback)
{
//更新数据
pid->lastError=pid->error;
pid->error=reference-feedback;
//计算微分
pid->output=(pid->error-pid->lastError)*pid->kd;
//计算比例
pid->output+=pid->error*pid->kp;
//计算积分
pid->integral+=pid->error*pid->ki;
LIMIT(pid->integral,-pid->maxIntegral,pid->maxIntegral);//积分限幅
pid->output+=pid->integral;
//输出限幅
LIMIT(pid->output,-pid->maxOutput,pid->maxOutput);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
3.1.3PID初始化
void PID_Init(PID *pid,float p,float i,float d,float maxI,float maxOut)
{
pid->kp=p;
pid->ki=i;
pid->kd=d;
pid->maxIntegral=maxI;
pid->maxOutput=maxOut;
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
3.1.4 清空PID
//清空一个pid的历史数据
void PID_Clear(PID *pid)
{
pid->error=0;
pid->lastError=0;
pid->integral=0;
pid->output=0;
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
3.2 串级PID
3.2.1 初始化串级PID结构体
typedef struct _CascadePID
{
PID inner;//内环
PID outer;//外环
float output;//串级输出，等于inner.output
}CascadePID;
1
2
3
4
5
6
1
2
3
4
5
6
3.2.2 串级PID计算
//串级pid计算
void PID_CascadeCalc(CascadePID *pid,float angleRef,float angleFdb,float speedFdb)
{
PID_SingleCalc(&pid->outer,angleRef,angleFdb);//计算外环(角度环)
PID_SingleCalc(&pid->inner,pid->outer.output,speedFdb);//计算内环(速度环)
pid->output=pid->inner.output;
}
1
2
3
4
5
6
7
1
2
3
4
5
6
7
4.PID的使用
STM32应用(九)编码器及其测速原理、L298N电机驱动控制编码器电机
在这篇博客的配置下，只需要修改部分代码。以单级PID为例子。
4.1 定义PID结构体并初始化
PID pid;
void Motor_Init(void)
{
PID_Init(&pid,10,0,0,1000,1000);
HAL_TIM_Encoder_Start(&htim1, TIM_CHANNEL_ALL); //开启编码器定时器
__HAL_TIM_ENABLE_IT(&htim1,TIM_IT_UPDATE); //开启编码器定时器更新中断,防溢出处理
HAL_TIM_Base_Start_IT(&htim6); //开启10ms定时器中断
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); //开启PWM
__HAL_TIM_SET_COUNTER(&htim1, 10000); //编码器定时器初始值设定为10000
motor.loopNum = 0; //防溢出
}
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
4.2 定义电机速度函数
void Motor_Send()
{
float output = 0;
PID_SingleCalc(&pid, motor.targetSpeed, motor.speed);
output = pid.output;
if(output > 0) //正转
{
__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, (uint32_t)output);
IN1(1);
IN2(0);
}
else //反转
{
__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, (uint32_t)(-output));
IN1(0);
IN2(1);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
4.3 在检测霍尔码盘时发送速度给电机
if(htim->Instance==htim6.Instance) //10ms中断
{
int16_t pluse = COUNTERNUM - RELOADVALUE/2;
motor.totalAngle = pluse + motor.loopNum * RELOADVALUE/2;
motor.speed = (float)(motor.totalAngle - motor.lastAngle)/(4*13*RR)*6000; //进行速度计算,根据前文所说的,4倍频,编码器13位,减速比30,再乘以6000即为每分钟输出轴多少转
motor.lastAngle = motor.totalAngle; //更新转过的圈数
Motor_Send();//发送速度
}
❼ 8位单片机PID控制PWM的算法如何实现，C语言计算
PID控制在8位单片机中仍然有广泛的应用，比如温度控制，利用比例、积分、微分补偿来做恒温补偿控制，当然由于有这些数学处理，用C语言相对方便一些，以下是一个具体的实例。
#include<reg51.h>
#include<intrins.h>
#include<math.h>
#include<string.h>
struct PID {
unsigned int SetPoint; // 设定目标 Desired Value
unsigned int Proportion; // 比例常数 Proportional Const
unsigned int Integral; // 积分常数 Integral Const
unsigned int Derivative; // 微分常数 Derivative Const
unsigned int LastError; // Error[-1]
unsigned int PrevError; // Error[-2]
unsigned int SumError; // Sums of Errors
};
struct PID spid; // PID Control Structure
unsigned int rout; // PID Response (Output)
unsigned int rin; // PID Feedback (Input)
sbit data1=P1^0;
sbit clk=P1^1;
sbit plus=P2^0;
sbit subs=P2^1;
sbit stop=P2^2;
sbit output=P3^4;
sbit DQ=P3^3;
unsigned char flag,flag_1=0;
unsigned char high_time,low_time,count=0;//占空比调节参数
unsigned char set_temper=35;
unsigned char temper;
unsigned char i;
unsigned char j=0;
unsigned int s;
/***********************************************************
延时子程序,延时时间以12M晶振为准,延时时间为30us×time
***********************************************************/
void delay(unsigned char time)
{
unsigned char m,n;
for(n=0;n<time;n++)
for(m=0;m<2;m++){}
}
/***********************************************************
写一位数据子程序
***********************************************************/
void write_bit(unsigned char bitval)
{
EA=0;
DQ=0; /*拉低DQ以开始一个写时序*/
if(bitval==1)
{
_nop_();
DQ=1; /*如要写1，则将总线置高*/
}
delay(5); /*延时90us供DA18B20采样*/
DQ=1; /*释放DQ总线*/
_nop_();
_nop_();
EA=1;
}
/***********************************************************
写一字节数据子程序
***********************************************************/
void write_byte(unsigned char val)
{
unsigned char i;
unsigned char temp;
EA=0;
TR0=0;
for(i=0;i<8;i++) /*写一字节数据，一次写一位*/
{
temp=val>>i; /*移位操作，将本次要写的位移到最低位*/
temp=temp&1;
write_bit(temp); /*向总线写该位*/
}
delay(7); /*延时120us后*/
// TR0=1;
EA=1;
}
/***********************************************************
读一位数据子程序
***********************************************************/
unsigned char read_bit()
{
unsigned char i,value_bit;
EA=0;
DQ=0; /*拉低DQ，开始读时序*/
_nop_();
_nop_();
DQ=1; /*释放总线*/
for(i=0;i<2;i++){}
value_bit=DQ;
EA=1;
return(value_bit);
}
/***********************************************************
读一字节数据子程序
***********************************************************/
unsigned char read_byte()
{
unsigned char i,value=0;
EA=0;
for(i=0;i<8;i++)
{
if(read_bit()) /*读一字节数据，一个时序中读一次，并作移位处理*/
value|=0x01<<i;
delay(4); /*延时80us以完成此次都时序，之后再读下一数据*/
}
EA=1;
return(value);
}
/***********************************************************
复位子程序
***********************************************************/
unsigned char reset()
{
unsigned char presence;
EA=0;
DQ=0; /*拉低DQ总线开始复位*/
delay(30); /*保持低电平480us*/
DQ=1; /*释放总线*/
delay(3);
presence=DQ; /*获取应答信号*/
delay(28); /*延时以完成整个时序*/
EA=1;
return(presence); /*返回应答信号，有芯片应答返回0,无芯片则返回1*/
}
/***********************************************************
获取温度子程序
***********************************************************/
void get_temper()
{
unsigned char i,j;
do
{
i=reset(); /*复位*/
} while(i!=0); /*1为无反馈信号*/
i=0xcc; /*发送设备定位命令*/
write_byte(i);
i=0x44; /*发送开始转换命令*/
write_byte(i);
delay(180); /*延时*/
do
{
i=reset(); /*复位*/
} while(i!=0);
i=0xcc; /*设备定位*/
write_byte(i);
i=0xbe; /*读出缓冲区内容*/
write_byte(i);
j=read_byte();
i=read_byte();
i=(i<<4)&0x7f;
s=(unsigned int)(j&0x0f); //得到小数部分
s=(s*100)/16;
j=j>>4;
temper=i|j; /*获取的温度放在temper中*/
}
/*====================================================================================================
Initialize PID Structure
=====================================================================================================*/
void PIDInit (struct PID *pp)
{
memset ( pp,0,sizeof(struct PID)); //全部初始化为0
}
/*====================================================================================================
PID计算部分
=====================================================================================================*/
unsigned int PIDCalc( struct PID *pp, unsigned int NextPoint )
{
unsigned int dError,Error;
Error = pp->SetPoint - NextPoint; // 偏差
pp->SumError += Error; // 积分
dError = pp->LastError - pp->PrevError; // 当前微分
pp->PrevError = pp->LastError;
pp->LastError = Error;
return (pp->Proportion * Error // 比例项
+ pp->Integral * pp->SumError // 积分项
+ pp->Derivative * dError); // 微分项
}
/***********************************************************
温度比较处理子程序
***********************************************************/
void compare_temper()
{
unsigned char i;
if(set_temper>temper) //是否设置的温度大于实际温度
{
if(set_temper-temper>1) //设置的温度比实际的温度是否是大于1度
{
high_time=100; //如果是，则全速加热
low_time=0;
}
else //如果是在1度范围内，则运行PID计算
{
for(i=0;i<10;i++)
{
get_temper(); //获取温度
rin = s; // Read Input
rout = PIDCalc ( &spid,rin ); // Perform PID Interation
}
if (high_time<=100)
high_time=(unsigned char)(rout/800);
else
high_time=100;
low_time= (100-high_time);
}
}
else if(set_temper<=temper)
{
if(temper-set_temper>0)
{
high_time=0;
low_time=100;
}
else
{
for(i=0;i<10;i++)
{
get_temper();
rin = s; // Read Input
rout = PIDCalc ( &spid,rin ); // Perform PID Interation
}
if (high_time<100)
high_time=(unsigned char)(rout/10000);
else
high_time=0;
low_time= (100-high_time);
}
}
// else
// {}
}
/*****************************************************
T0中断服务子程序，用于控制电平的翻转 ,40us*100=4ms周期
******************************************************/
void serve_T0() interrupt 1 using 1
{
if(++count<=(high_time))
output=1;
else if(count<=100)
{
output=0;
}
else
count=0;
TH0=0x2f;
TL0=0xe0;
}
/*****************************************************
串行口中断服务程序，用于上位机通讯
******************************************************/
void serve_sio() interrupt 4 using 2
{
/* EA=0;
RI=0;
i=SBUF;
if(i==2)
{
while(RI==0){}
RI=0;
set_temper=SBUF;
SBUF=0x02;
while(TI==0){}
TI=0;
}
else if(i==3)
{
TI=0;
SBUF=temper;
while(TI==0){}
TI=0;
}
EA=1; */
}
void disp_1(unsigned char disp_num1[6])
{
unsigned char n,a,m;
for(n=0;n<6;n++)
{
// k=disp_num1[n];
for(a=0;a<8;a++)
{
clk=0;
m=(disp_num1[n]&1);
disp_num1[n]=disp_num1[n]>>1;
if(m==1)
data1=1;
else
data1=0;
_nop_();
clk=1;
_nop_();
}
}
}
/*****************************************************
显示子程序
功能：将占空比温度转化为单个字符，显示占空比和测得到的温度
******************************************************/
void display()
{
unsigned char code number[]={0xfc,0x60,0xda,0xf2,0x66,0xb6,0xbe,0xe0,0xfe,0xf6};
unsigned char disp_num[6];
unsigned int k,k1;
k=high_time;
k=k%1000;
k1=k/100;
if(k1==0)
disp_num[0]=0;
else
disp_num[0]=0x60;
k=k%100;
disp_num[1]=number[k/10];
disp_num[2]=number[k%10];
k=temper;
k=k%100;
disp_num[3]=number[k/10];
disp_num[4]=number[k%10]+1;
disp_num[5]=number[s/10];
disp_1(disp_num);
}
/***********************************************************
主程序
***********************************************************/
void main()
{
unsigned char z;
unsigned char a,b,flag_2=1,count1=0;
unsigned char phil[]={2,0xce,0x6e,0x60,0x1c,2};
TMOD=0x21;
TH0=0x2f;
TL0=0x40;
SCON=0x50;
PCON=0x00;
TH1=0xfd;
TL1=0xfd;
PS=1;
EA=1;
EX1=0;
ET0=1;
ES=1;
TR0=1;
TR1=1;
high_time=50;
low_time=50;
PIDInit ( &spid ); // Initialize Structure
spid.Proportion = 10; // Set PID Coefficients 比例常数 Proportional Const
spid.Integral = 8; //积分常数 Integral Const
spid.Derivative =6; //微分常数 Derivative Const
spid.SetPoint = 100; // Set PID Setpoint 设定目标 Desired Value
while(1)
{
if(plus==0)
{
EA=0;
for(a=0;a<5;a++)
for(b=0;b<102;b++){}
if(plus==0)
{
set_temper++;
flag=0;
}
}
else if(subs==0)
{
for(a=0;a<5;a++)
for(b=0;a<102;b++){}
if(subs==0)
{
set_temper--;
flag=0;
}
}
else if(stop==0)
{
for(a=0;a<5;a++)
for(b=0;b<102;b++){}
if(stop==0)
{
flag=0;
break;
}
EA=1;
}
get_temper();
b=temper;
if(flag_2==1)
a=b;
if((abs(a-b))>5)
temper=a;
else
temper=b;
a=temper;
flag_2=0;
if(++count1>30)
{
display();
count1=0;
}
compare_temper();
}
TR0=0;
z=1;
while(1)
{
EA=0;
if(stop==0)
{
for(a=0;a<5;a++)
for(b=0;b<102;b++){}
if(stop==0)
disp_1(phil);
// break;
}
EA=1;
}
}