PID算法温控C语言

1. PID调试步骤
没有一种控制算法比PID调节规律更有效、更方便的了。现在一些时髦点的调节器基本源自PID。甚至可以这样说：PID调节器是其它控制调节算法的妈。
为什么PID应用如此广泛、又长久不衰？

因为PID解决了自动控制理论所要解决的最基本问题，既系统的稳定性、快速性和准确性。调节PID的参数，可实现在系统稳定的前提下，兼顾系统的带载能力和抗扰能力，同时，在PID调节器中引入积分项，系统增加了一个零积点，使之成为一阶或一阶以上的系统，这样系统阶跃响应的稳态误差就为零。
由于自动控制系统被控对象的千差万别，PID的参数也必须随之变化，以满足系统的性能要求。这就给使用者带来相当的麻烦，特别是对初学者。下面简单介绍一下调试PID参数的一般步骤：
1．负反馈
自动控制理论也被称为负反馈控制理论。首先检查系统接线，确定系统的反馈为负反馈。例如电机调速系统，输入信号为正，要求电机正转时，反馈信号也为正（PID算法时，误差=输入-反馈），同时电机转速越高，反馈信号越大。其余系统同此方法。
2．PID调试一般原则
a.在输出不振荡时，增大比例增益P。
b.在输出不振荡时，减小积分时间常数Ti。
c.在输出不振荡时，增大微分时间常数Td。
3．一般步骤
a.确定比例增益P
确定比例增益P 时，首先去掉PID的积分项和微分项，一般是令Ti=0、Td=0（具体见PID的参数设定说明），使PID为纯比例调节。输入设定为系统允许的最大值的60%~70%，由0逐渐加大比例增益P，直至系统出现振荡；再反过来，从此时的比例增益P逐渐减小，直至系统振荡消失，记录此时的比例增益P，设定PID的比例增益P为当前值的60%~70%。比例增益P调试完成。
b.确定积分时间常数Ti
比例增益P确定后，设定一个较大的积分时间常数Ti的初值，然后逐渐减小Ti，直至系统出现振荡，之后在反过来，逐渐加大Ti，直至系统振荡消失。记录此时的Ti，设定PID的积分时间常数Ti为当前值的150%~180%。积分时间常数Ti调试完成。
c.确定积分时间常数Td
积分时间常数Td一般不用设定，为0即可。若要设定，与确定 P和Ti的方法相同，取不振荡时的30%。
d.系统空载、带载联调，再对PID参数进行微调，直至满足要求。

2.PID控制简介

目前工业自动化水平已成为衡量各行各业现代化水平的一个重要标志。同时，控制理论的发展也经历了古典控制理论、现代控制理论和智能控制理论三个阶段。智能控制的典型实例是模糊全自动洗衣机等。自动控制系统可分为开环控制系统和闭环控制系统。一个控制系统包括控制器、传感器、变送器、执行机构、输入输出接口。控制器的输出经过输出接口、执行机构，加到被控系统上；控制系统的被控量，经过传感器，变送器，通过输入接口送到控制器。不同的控制系统，其传感器、变送器、执行机构是不一样的。比如压力控制系统要采用压力传感器。电加热控制系统的传感器是温度传感器。目前，PID控制及其控制器或智能PID控制器（仪表）已经很多，产品已在工程实际中得到了广泛的应用，有各种各样的PID控制器产品，各大公司均开发了具有PID参数自整定功能的智能调节器(intelligent regulator)，其中PID控制器参数的自动调整是通过智能化调整或自校正、自适应算法来实现。有利用PID控制实现的压力、温度、流量、液位控制器，能实现PID控制功能的可编程控制器(PLC)，还有可实现PID控制的PC系统等等。 可编程控制器(PLC) 是利用其闭环控制模块来实现PID控制，而可编程控制器(PLC)可以直接与ControlNet相连，如Rockwell的PLC-5等。还有可以实现PID控制功能的控制器，如Rockwell 的Logix产品系列，它可以直接与ControlNet相连，利用网络来实现其远程控制功能。
1、开环控制系统
开环控制系统(open-loop control system)是指被控对象的输出(被控制量)对控制器(controller)的输出没有影响。在这种控制系统中，不依赖将被控量反送回来以形成任何闭环回路。
2、闭环控制系统
闭环控制系统(closed-loop control system)的特点是系统被控对象的输出(被控制量)会反送回来影响控制器的输出，形成一个或多个闭环。闭环控制系统有正反馈和负反馈，若反馈信号与系统给定值信号相反，则称为负反馈( Negative Feedback)，若极性相同，则称为正反馈，一般闭环控制系统均采用负反馈，又称负反馈控制系统。闭环控制系统的例子很多。比如人就是一个具有负反馈的闭环控制系统，眼睛便是传感器，充当反馈，人体系统能通过不断的修正最后作出各种正确的动作。如果没有眼睛，就没有了反馈回路，也就成了一个开环控制系统。另例，当一台真正的全自动洗衣机具有能连续检查衣物是否洗净，并在洗净之后能自动切断电源，它就是一个闭环控制系统。
3、阶跃响应
阶跃响应是指将一个阶跃输入（step function）加到系统上时，系统的输出。稳态误差是指系统的响应进入稳态后，系统的期望输出与实际输出之差。控制系统的性能可以用稳、准、快三个字来描述。稳是指系统的稳定性(stability)，一个系统要能正常工作，首先必须是稳定的，从阶跃响应上看应该是收敛的；准是指控制系统的准确性、控制精度，通常用稳态误差来(Steady-state error)描述，它表示系统输出稳态值与期望值之差；快是指控制系统响应的快速性，通常用上升时间来定量描述。
4、PID控制的原理和特点
在工程实际中，应用最为广泛的调节器控制规律为比例、积分、微分控制，简称PID控制，又称PID调节。PID控制器问世至今已有近70年历史，它以其结构简单、稳定性好、工作可靠、调整方便而成为工业控制的主要技术之一。当被控对象的结构和参数不能完全掌握，或得不到精确的数学模型时，控制理论的其它技术难以采用时，系统控制器的结构和参数必须依靠经验和现场调试来确定，这时应用PID控制技术最为方便。即当我们不完全了解一个系统和被控对象，或不能通过有效的测量手段来获得系统参数时，最适合用PID控制技术。PID控制，实际中也有PI和PD控制。PID控制器就是根据系统的误差，利用比例、积分、微分计算出控制量进行控制的。
比例（P）控制
比例控制是一种最简单的控制方式。其控制器的输出与输入误差信号成比例关系。当仅有比例控制时系统输出存在稳态误差（Steady-state error）。
积分（I）控制
在积分控制中，控制器的输出与输入误差信号的积分成正比关系。对一个自动控制系统，如果在进入稳态后存在稳态误差，则称这个控制系统是有稳态误差的或简称有差系统（System with Steady-state Error）。为了消除稳态误差，在控制器中必须引入“积分项”。积分项对误差取决于时间的积分，随着时间的增加，积分项会增大。这样，即便误差很小，积分项也会随着时间的增加而加大，它推动控制器的输出增大使稳态误差进一步减小，直到等于零。因此，比例+积分(PI)控制器，可以使系统在进入稳态后无稳态误差。
微分（D）控制
在微分控制中，控制器的输出与输入误差信号的微分（即误差的变化率）成正比关系。 自动控制系统在克服误差的调节过程中可能会出现振荡甚至失稳。其原因是由于存在有较大惯性组件（环节）或有滞后(delay)组件，具有抑制误差的作用，其变化总是落后于误差的变化。解决的办法是使抑制误差的作用的变化“超前”，即在误差接近零时，抑制误差的作用就应该是零。这就是说，在控制器中仅引入“比例”项往往是不够的，比例项的作用仅是放大误差的幅值，而目前需要增加的是“微分项”，它能预测误差变化的趋势，这样，具有比例+微分的控制器，就能够提前使抑制误差的控制作用等于零，甚至为负值，从而避免了被控量的严重超调。所以对有较大惯性或滞后的被控对象，比例+微分(PD)控制器能改善系统在调节过程中的动态特性。
5、PID控制器的参数整定
PID控制器的参数整定是控制系统设计的核心内容。它是根据被控过程的特性确定PID控制器的比例系数、积分时间和微分时间的大小。PID控制器参数整定的方法很多，概括起来有两大类：一是理论计算整定法。它主要是依据系统的数学模型，经过理论计算确定控制器参数。这种方法所得到的计算数据未必可以直接用，还必须通过工程实际进行调整和修改。二是工程整定方法，它主要依赖工程经验，直接在控制系统的试验中进行，且方法简单、易于掌握，在工程实际中被广泛采用。PID控制器参数的工程整定方法，主要有临界比例法、反应曲线法和衰减法。三种方法各有其特点，其共同点都是通过试验，然后按照工程经验公式对控制器参数进行整定。但无论采用哪一种方法所得到的控制器参数，都需要在实际运行中进行最后调整与完善。现在一般采用的是临界比例法。利用该方法进行 PID控制器参数的整定步骤如下：(1)首先预选择一个足够短的采样周期让系统工作；(2)仅加入比例控制环节，直到系统对输入的阶跃响应出现临界振荡，记下这时的比例放大系数和临界振荡周期；(3)在一定的控制度下通过公式计算得到PID控制器的参数。

3.PID控制器参数的工程整定,各种调节系统中PID参数经验数据以下可参照：

温度T: P=20~60%,T=180~600s,D=3-180s

压力P: P=30~70%,T=24~180s,

液位L: P=20~80%,T=60~300s,

流量L: P=40~100%,T=6~60s。

4. PID常用口诀：

参数整定找最佳，从小到大顺序查

先是比例后积分，最后再把微分加

曲线振荡很频繁，比例度盘要放大

曲线漂浮绕大湾，比例度盘往小扳

曲线偏离回复慢，积分时间往下降

曲线波动周期长，积分时间再加长

曲线振荡频率快，先把微分降下来

动差大来波动慢。微分时间应加长

理想曲线两个波，前高后低4比1

一看二调多分析，调节质量不会低
参考资料：http://www.yuanqijian.com/bbs/htmled_topic.php?topi_id=64489

#include
#include
#include
#include
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 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< 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));
}
/*====================================================================================================
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->SumEror // 积分项
+ pp->Derivative * dError); // 微分项
}
/***********************************************************
温度比较处理子程序
***********************************************************/
compare_temper()
{
unsigned char i;
if(set_temper>temper)
{
if(set_temper-temper>1)
{
high_time=100;
low_time=0;
}
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/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);
}
/***********************************************************
主程序
***********************************************************/
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
spid.Integral = 8;
spid.Derivative =6;
spid.SetPoint = 100; // Set PID Setpoint
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;
}
}

//PID算法温控C语言
#include
#include
#include
#include
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;nfor(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<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));
}
/*====================================================================================================
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); // 微分项
}
/***********************************************************
温度比较处理子程序
***********************************************************/
compare_temper()
{
unsigned char i;
if(set_temper>temper)
{
if(set_temper-temper>1)
{
high_time=100;
low_time=0;
}
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/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);
}
/***********************************************************
主程序
***********************************************************/
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
spid.Integral = 8;
spid.Derivative =6;
spid.SetPoint = 100; // Set PID Setpoint
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;
}
}
//DS18b20 子程序
#include
sbit DQ=P2^1; //定义端口

typedef unsigned char byte;
typedef unsigned int word;
//延时
void delay(word useconds)
{
for(;useconds>0;useconds--);
}
//复位
byte ow_reset(void)
{
byte presence;
DQ=0; //DQ低电平
delay(29); //480us
DQ=1; //DQ高电平
delay(3); //等待
presence=DQ; //presence信号
delay(25);
return(presence);
} //0允许，1禁止
//从1-wire 总线上读取一个字节
byte read_byte(viod)
{
byte i;
byte value=0;
for (i=8;i>0;i--)
{
value>>=1;
DQ=0;
DQ=1;
delay(1);

if(DQ)value|=0x80;
delay(6);
}
return(value);
}

//向1-wire总线上写一个字节
void write_byte(char val)
{
byte i;
for (i=8;i>0;i--) //一次写一个字节
{
DQ=0;
DQ=val&0x01;
delay(5);
DQ=1;
val=val/2;
}
delay(5);
}
//读取温度

char Read_Temperature(void)
{
union{
byte c[2];
int x;
}temp;

ow_reset();
write_byte(0xcc);
write_byte(0xBE);
temp.c[1]=read_byte();
temp.c[0]=read_byte();
ow_reset();
write_byte(0xCC);
write_byte(0x44);
return temp.x/2;
}

//pid算法温控c语言2008-08-17
18:58
#include
#include
#include
#include
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;nfor(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<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));
}
/*====================================================================================================
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);
//
微分项
}
/***********************************************************
温度比较处理子程序
***********************************************************/
compare_temper()
{
unsigned
char
i;
if(set_temper>temper)
{
if(set_temper-temper>1)
{
high_time=100;
low_time=0;
}
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/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);
}
/***********************************************************
主程序
***********************************************************/
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
spid.integral
=
8;
spid.derivative
=6;
spid.setpoint
=
100;
//
set
pid
setpoint
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;
}
}
//ds18b20
子程序
#include

sbit
dq=p2^1;
//定义端口
typedef
unsigned
char
byte;
typedef
unsigned
int
word;
//延时
void
delay(word
useconds)
{
for(;useconds>0;useconds--);
}
//复位
byte
ow_reset(void)
{
byte
presence;
dq=0;
//dq低电平
delay(29);
//480us
dq=1;
//dq高电平
delay(3);
//等待
presence=dq;
//presence信号
delay(25);
return(presence);
}
//0允许，1禁止
//从1-wire
总线上读取一个字节
byte
read_byte(viod)
{
byte
i;
byte
value=0;
for
(i=8;i>0;i--)
{
value>>=1;
dq=0;
dq=1;
delay(1);
if(dq)value|=0x80;
delay(6);
}
return(value);
}
//向1-wire总线上写一个字节
void
write_byte(char
val)
{
byte
i;
for
(i=8;i>0;i--)
//一次写一个字节
{
dq=0;
dq=val&0x01;
delay(5);
dq=1;
val=val/2;
}
delay(5);
}
//读取温度
char
read_temperature(void)
{
union{
byte
c[2];
int
x;
}temp;
ow_reset();
write_byte(0xcc);
write_byte(0xbe);
temp.c[1]=read_byte();
temp.c[0]=read_byte();
ow_reset();
write_byte(0xcc);
write_byte(0x44);
return
temp.x/2;
}

//PID算法温控C语言
#include
#include
#include
#include
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;nfor(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<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));
}
/*====================================================================================================
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);
//
微分项
}
/***********************************************************
温度比较处理子程序
***********************************************************/
compare_temper()
{
unsigned
char
i;
if(set_temper>temper)
{
if(set_temper-temper>1)
{
high_time=100;
low_time=0;
}
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/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);
}
/***********************************************************
主程序
***********************************************************/
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
spid.Integral
=
8;
spid.Derivative
=6;
spid.SetPoint
=
100;
//
Set
PID
Setpoint
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;
}
}
//DS18b20
子程序
#include

sbit
DQ=P2^1;
//定义端口
typedef
unsigned
char
byte;
typedef
unsigned
int
word;
//延时
void
delay(word
useconds)
{
for(;useconds>0;useconds--);
}
//复位
byte
ow_reset(void)
{
byte
presence;
DQ=0;
//DQ低电平
delay(29);
//480us
DQ=1;
//DQ高电平
delay(3);
//等待
presence=DQ;
//presence信号
delay(25);
return(presence);
}
//0允许，1禁止
//从1-wire
总线上读取一个字节
byte
read_byte(viod)
{
byte
i;
byte
value=0;
for
(i=8;i>0;i--)
{
value>>=1;
DQ=0;
DQ=1;
delay(1);
if(DQ)value|=0x80;
delay(6);
}
return(value);
}
//向1-wire总线上写一个字节
void
write_byte(char
val)
{
byte
i;
for
(i=8;i>0;i--)
//一次写一个字节
{
DQ=0;
DQ=val&0x01;
delay(5);
DQ=1;
val=val/2;
}
delay(5);
}
//读取温度
char
Read_Temperature(void)
{
union{
byte
c[2];
int
x;
}temp;
ow_reset();
write_byte(0xcc);
write_byte(0xBE);
temp.c[1]=read_byte();
temp.c[0]=read_byte();
ow_reset();
write_byte(0xCC);
write_byte(0x44);
return
temp.x/2;
}