PID算法温控C语言
PID控制算法的C语言实现(完整版)
PID控制算法的C语言实现(完整版) 在现代工业生产中，为了实现对生产过程的精确控制，我们需要采用一种能够根据实际需求自动调整参数的控制算法。
PID(Proportional-Integral-Derivative)控制算法就是这样一种广泛应用于工业控制系统的算法。
本文将详细介绍PID控制算法的C语言实现，包括算法的基本原理、实现方法以及注意事项。
我们来了解一下PID控制算法的基本原理。
PID控制器由三个部分组成：比例(P)、积分(I)和微分(D)。
这三个部分分别对误差信号进行处理，然后将处理后的信号相加得到控制输出。
具体来说，比例部分根据误差信号的大小产生相应的控制作用；积分部分对误差信号进行累积，以消除系统的静差；微分部分对误差信号的变化趋势进行预测，以便及时调整控制策略。
通过这三个部分的综合作用，PID控制器能够实现对生产过程的精确控制。
接下来，我们来看一下如何用C语言实现PID控制算法。
我们需要定义一些变量来存储所需的参数和状态信息。
例如，我们需要定义比例系数Kp、积分系数Ki、微分系数Kd以及误差信号e等。
我们还需要定义一些变量来存储上一次的误差信号和积分项等。
这些变量的定义如下：```cdouble Kp, Ki, Kd; // 比例、积分、微分系数double e; // 当前误差信号double de; // 当前误差信号的导数double last_e; // 上一次的误差信号double integral; // 积分项有了这些变量之后，我们就可以开始实现PID控制器的计算过程了。
PID控制器的计算过程主要包括以下几个步骤：1. 计算误差信号：当前误差信号等于期望值与实际值之差。
2. 计算比例项：比例项等于当前误差信号乘以比例系数Kp;3. 计算积分项：积分项等于当前误差信号乘以积分系数Ki加上累积误差信号乘以积分系数Ki;4. 计算微分项：微分项等于当前误差信号的导数乘以微分系数Kd;5. 计算控制输出：控制输出等于比例项、积分项和微分项之和。
C语言实现PID算法
C语言实现PID算法#include <stdio.h>struct _pid {int pv; /*integer that contains the process value*/int sp; /*integer that contains the set point*/float integral;float pgain;float igain;float dgain;int deadband;int last_error;};struct _pid warm,*pid;int process_point, set_point,dead_band;float p_gain, i_gain, d_gain, integral_val,new_integ;;/*------------------------------------------------------------------------pid_initDESCRIPTION This function initializes the pointers in the _pid structure to the process variable and the setpoint. *pv and *sp areinteger pointers.------------------------------------------------------------------------*/void pid_init(struct _pid *warm, int process_point, int set_point){struct _pid *pid;pid = warm;pid->pv = process_point;pid->sp = set_point;}/*------------------------------------------------------------------------pid_tuneDESCRIPTION Sets the proportional gain (p_gain), integral gain (i_gain), derivitive gain (d_gain), and the dead band (dead_band) ofa pid control structure _pid.------------------------------------------------------------------------*/void pid_tune(struct _pid *pid, float p_gain, float i_gain, float d_gain, int dead_band) {pid->pgain = p_gain;pid->igain = i_gain;pid->dgain = d_gain;pid->deadband = dead_band;pid->integral= integral_val;pid->last_error=0;}/*------------------------------------------------------------------------pid_setintegDESCRIPTION Set a new value for the integral term of the pid equation.This is useful for setting the initial output of thepid controller at start up.------------------------------------------------------------------------*/void pid_setinteg(struct _pid *pid,float new_integ){pid->integral = new_integ;pid->last_error = 0;}/*------------------------------------------------------------------------pid_bumplessDESCRIPTION Bumpless transfer algorithim. When suddenly changing setpoints, or when restarting the PID equation after anextended pause, the derivative of the equation can causea bump in the controller output. This function will helpsmooth out that bump. The process value in *pv shouldbe the updated just before this function is used.------------------------------------------------------------------------*/void pid_bumpless(struct _pid *pid){pid->last_error = (pid->sp)-(pid->pv);}/*------------------------------------------------------------------------pid_calcDESCRIPTION Performs PID calculations for the _pid structure *a. This function uses the positio nal form of the pid equation, and incorporates an integral windup prevention algorithim. Rectangu lar integration is used, so this function must be repeated on a consistent time basis for accurate con trol.RETURN V ALUE The new output value for the pid loop.USAGE #include "control.h"*/float pid_calc(struct _pid *pid){int err;float pterm, dterm, result, ferror;err = (pid->sp) - (pid->pv);if (abs(err) > pid->deadband){ferror = (float) err; /*do integer to float conversion only once*/pterm = pid->pgain * ferror;if (pterm > 100 || pterm < -100){pid->integral = 0.0;}else{pid->integral += pid->igain * ferror;if (pid->integral > 100.0){pid->integral = 100.0;}else if (pid->integral < 0.0) pid->integral = 0.0;}dterm = ((float)(err - pid->last_error)) * pid->dgain;result = pterm + pid->integral + dterm;}else result = pid->integral;pid->last_error = err;return (result);}void main(void)float display_value;int count=0;pid = &warm;// printf("Enter the values of Process point, Set point, P gain, I gain, D gain \n");// scanf("%d%d%f%f%f", &process_point, &set_point, &p_gain, &i_gain, &d_gain);process_point = 30;set_point = 40;p_gain = (float)(5.2);i_gain = (float)(0.77);d_gain = (float)(0.18);dead_band = 2;integral_val =(float)(0.01);printf("The values of Process point, Set point, P gain, I gain, D gain \n");printf(" %6d %6d %4f %4f %4f\n", process_point, set_point, p_gain, i_gain, d_gain); printf("Enter the values of Process point\n");while(count<=20){scanf("%d",&process_point);pid_init(&warm, process_point, set_point);pid_tune(&warm, p_gain,i_gain,d_gain,dead_band);pid_setinteg(&warm,0.0); //pid_setinteg(&warm,30.0);//Get input value for process pointpid_bumpless(&warm);// how to display outputdisplay_value = pid_calc(&warm);printf("%f\n", display_value);//printf("\n%f%f%f%f",warm.pv,warm.sp,warm.igain,warm.dgain);count++;}}PID算法/******************************************************************** *********************************** PID控制算法 PID Control Algorithm* 在仿真和实验中，航向预估控制方法和与之对比的常规控制方法的控制器均采用增量PID算法，* 且两者的比例、积分和微分系数一样.增量PID算法如式(7)所示：* ΔU = U(k)-U(k-1) =Kp*[e(k)-e(k-1)]+Ki*e(k)+Kd*[e(k)-2*e(k-1)+e(k-2)]* 其中：Kp、Ki、Kd分别为比例、积分和微分放大系数，u(k)表示第k个采样时刻的控制量,e(k)表示第k个采样时刻的航向输入偏差.********************************************************************* **********************************/void PID_Calc(int PID_EK){long deltaU,tmp;deltaU = (long)u_dbPIDKp.IntData*(PID_EK-PID_EK_1); // 增量计算deltaU +=(long)u_dbPIDKi.IntData*PID_EK;tmp = (long)PID_EK-(2*PID_EK_1)+PID_EK_2;deltaU +=tmp* u_dbPIDKd.IntData;PID_UK = PID_UK_1+deltaU; // 结果if(PID_UK>4095000) PID_UK = 4095000;else if(PID_UK<0) PID_UK=0;PID_UK_1 = PID_UK; // 保存新的K-1次输出值PID_EK_2 = PID_EK_1; // 保存新的K-1次输入值PID_EK_1 = PID_EK;}PID是比例，积分，微分的缩写，Uo(N)=P*E(N)+I*[E(N)+E(N-1)+...+E(0)]+D*[E(N)-E(N-1)]E-误差P--改变P 可提高响应速度，减小静态误差，但太大会增大超调量和稳定时间。
恒温控制算法 c语言版
恒温控制算法c语言版全文共四篇示例，供读者参考第一篇示例：恒温控制算法是一种用于调节系统温度的智能控制算法。
该算法通过采集环境温度数据，并根据设定的目标温度进行计算，实现自动调节系统的输出控制信号，从而维持系统温度稳定在设定值附近。
在工业生产、实验室研究和家用电器等领域都广泛应用了恒温控制算法，以确保系统稳定性和高效性。
C语言是一种通用的编程语言，具有良好的可移植性和高效性。
在实际应用中，恒温控制算法通常会在嵌入式系统或工控系统中实现，而使用C语言编写程序是一种常见的选择。
下面我们将介绍一种基于C 语言的恒温控制算法实现方式。
我们需要定义一些基本的变量和常数。
我们需要设置目标温度值、温度传感器读取间隔、控制信号输出范围等。
接下来，我们将使用C语言编写一个基本的恒温控制算法框架，示例如下：```c#include <stdio.h>#include <stdlib.h>// 定义温度传感器读取间隔，单位为秒#define SENSOR_INTERVAL 1// 定义目标温度值#define TARGET_TEMPERATURE 25// 定义控制信号输出范围#define OUTPUT_MIN 0#define OUTPUT_MAX 100while(1) {// 读取温度传感器数据currentTemperature = readTemperatureSensor();// 计算控制信号outputSignal =calculateControlSignal(currentTemperature);// 等待传感器读取间隔delay(SENSOR_INTERVAL);}return 0;}int calculateControlSignal(int temperature) {// 根据当前温度和目标温度计算控制信号int error = TARGET_TEMPERATURE - temperature;int controlSignal = OUTPUT_MAX * error / TARGET_TEMPERATURE;return controlSignal;}void outputControlSignal(int signal) {// 输出控制信号，此处可与系统的执行机构进行通信实现控制printf("Control signal: %d\n", signal);}void delay(int seconds) {// 延时函数，单位为秒sleep(seconds);}```上述代码实现了一个简单的基于C语言的恒温控制算法。
C语言PID电炉温度控制系统
摘要：自动控制系统在各个领域尤其是工业领域中有着及其广泛的使用，温度控制是控制系统中最为常见的控制类型之一。
随着单片机技术的飞速发展，通过单片机对被控对象进行控制日益成为今后自动控制领域的一个重要发展方向。
关键词：电炉温度控制系统设计一、前言自动控制系统在各个领域尤其是工业领域中有着及其广泛的使用，温度控制是控制系统中最为常见的控制类型之一。
随着单片机技术的飞速发展，通过单片机对被控对象进行控制日益成为今后自动控制领域的一个重要发展方向。
本设计要求用单片机设计一个电炉温度控制系统。
二、电炉温度控制系统的特性温控系统主要由温度传感器、温度调节仪、执行装置、被控对象四个部分组成，其系统结构图如图1所示。
被控制对象是大容量、大惯性的电热炉温度对象，是典型的多阶容积迟后特性，在工程上往往近似为包含有纯滞后的二阶容积迟后；由于被控对象电容量大，通常采用可控硅作调节器的执行器，其具体的电路图如图2所示。
执行器的特性：电炉的温度调节是通过调节剂(供电能源)的断续作用，改变电炉丝闭合时间Tb和断开时间Tk的比值α,α=Tb/Tk。
调节加热炉的温度，在工业上是通过在设定周期范围内，将电路接通几个周波，然后断开几个周波，改变晶闸管在设定周期内通断时间的比例，来调节负载两端交流平均电压即负载功率，这就是通常所说的调功器或周波控制器；调功器是在电源电压过零时触发晶闸管导通的，所以负载上得到的是完整的正弦波，调节的只是设定周期Tc内导通的电压周波。
如图3所示，设周期Tc内导通的周期的波数为n，每个周波的周期为T，则调功器的输出功率为P=n×T×Pn/Tc，Pn为设定周期Tc内电压全通过时装置的输出功率。
三、电炉的电加热原理当电流在导体中流过时，因为任何导体均存在电阻，电能即在导体中形成损耗，转换为热能，按焦耳楞次定律：Q＝0．2412 Rt Q—热能，卡；I一电流，安9R一电阻，欧姆，t一时间，秒。
按上式推算，当1千瓦小时的电能，全部转换为热能时Q＝(0．24×1000×36000)／1 000=864千卡。
pid控制算法c语言
PID控制算法C语言1. 引言控制算法是自动控制系统中的核心部分，用于实现系统的稳定性和性能优化。
PID 控制算法是最常用的控制算法之一，广泛应用于工业自动化、机器人控制、电子设备等领域。
本文将详细介绍PID控制算法的原理和在C语言中的实现。
2. PID控制算法原理PID控制算法是基于误差的反馈控制算法，通过对系统的误差进行测量和调整，实现对系统的控制。
PID控制算法由比例控制、积分控制和微分控制三部分组成。
2.1 比例控制（P控制）比例控制是根据误差的大小，按比例调整控制量。
比例控制的公式为：u(t) = Kp * e(t)其中，u(t)为控制量，Kp为比例系数，e(t)为误差。
比例控制的特点是响应速度快，但存在超调和稳态误差的问题。
2.2 积分控制（I控制）积分控制是根据误差的累积值，按比例调整控制量。
积分控制的公式为：u(t) = Ki * ∫e(t) dt其中，Ki为积分系数，e(t)为误差，∫表示对误差的积分。
积分控制的特点是能够消除稳态误差，但存在响应速度慢和超调的问题。
2.3 微分控制（D控制）微分控制是根据误差的变化率，按比例调整控制量。
微分控制的公式为：u(t) = Kd * de(t)/dt其中，Kd为微分系数，de(t)/dt为误差的导数，表示误差的变化率。
微分控制的特点是能够抑制超调和提高系统的稳定性，但对噪声敏感。
2.4 PID控制PID控制算法是将比例控制、积分控制和微分控制三部分综合起来，通过调整各个部分的权重系数，实现对系统的控制。
PID控制的公式为：u(t) = Kp * e(t) + Ki * ∫e(t) dt + Kd * de(t)/dt其中，Kp、Ki和Kd分别为比例系数、积分系数和微分系数。
PID控制算法的优点是能够快速响应、消除稳态误差和抑制超调，但需要根据具体应用进行参数调整。
3. PID控制算法在C语言中的实现PID控制算法可以通过C语言进行实现，以下是PID控制算法的C语言代码示例：#include <stdio.h>// PID控制参数float Kp = 0.5; // 比例系数float Ki = 0.2; // 积分系数float Kd = 0.1; // 微分系数// PID控制器float PIDController(float target, float current){static float integral = 0; // 积分项static float previous_error = 0; // 上一次误差// 计算误差float error = target - current;// 计算比例项float proportional = Kp * error;// 计算积分项integral += Ki * error;// 计算微分项float derivative = Kd * (error - previous_error);// 更新上一次误差previous_error = error;// 计算控制量float control = proportional + integral + derivative;return control;}int main(){float target = 10; // 目标值float current = 0; // 当前值// 模拟系统运行for (int i = 0; i < 100; i++){float control = PIDController(target, current);// 更新当前值current += control;printf("Iteration: %d, Control: %.2f, Current: %.2f\n", i, control, cu rrent);}return 0;}以上代码是一个简单的PID控制器实现，通过不断计算控制量，实现对系统的控制。
pid控制算法c语言
pid控制算法c语言PID控制算法是一种常用的控制算法，它可以通过对系统的反馈信号进行处理，实现对系统的控制。
在工业自动化、机器人控制、航空航天等领域都有广泛的应用。
本文将介绍PID控制算法的基本原理和C 语言实现方法。
一、PID控制算法的基本原理PID控制算法是由比例控制、积分控制和微分控制三个部分组成的。
其中，比例控制部分根据系统的误差信号进行控制，积分控制部分根据误差信号的积分值进行控制，微分控制部分根据误差信号的微分值进行控制。
三个部分的输出信号相加，得到最终的控制信号。
比例控制部分的输出信号为：P(t) = Kp * e(t)其中，Kp为比例系数，e(t)为误差信号。
积分控制部分的输出信号为：I(t) = Ki * ∫e(t)dt其中，Ki为积分系数，∫e(t)dt为误差信号的积分值。
微分控制部分的输出信号为：D(t) = Kd * de(t)/dt其中，Kd为微分系数，de(t)/dt为误差信号的微分值。
最终的控制信号为：U(t) = P(t) + I(t) + D(t)二、C语言实现方法PID控制算法的C语言实现方法如下：1. 定义PID控制器的结构体typedef struct{float Kp; //比例系数float Ki; //积分系数float Kd; //微分系数float e; //误差信号float e_last; //上一次误差信号float integral; //误差信号的积分值}PID;2. 初始化PID控制器void PID_Init(PID *pid, float Kp, float Ki, float Kd){pid->Kp = Kp;pid->Ki = Ki;pid->Kd = Kd;pid->e = 0;pid->e_last = 0;pid->integral = 0;}3. 计算PID控制器的输出信号float PID_Calculate(PID *pid, float target, float feedback) {float output;pid->e = target - feedback; //计算误差信号pid->integral += pid->e; //计算误差信号的积分值output = pid->Kp * pid->e + pid->Ki * pid->integral + pid->Kd * (pid->e - pid->e_last); //计算控制信号pid->e_last = pid->e; //保存上一次误差信号return output;}4. 调用PID控制器int main(){PID pid;float target = 50; //目标值float feedback = 0; //反馈值float output;PID_Init(&pid, 0.1, 0.01, 0.01); //初始化PID控制器while(1){feedback = get_feedback(); //获取反馈值output = PID_Calculate(&pid, target, feedback); //计算控制信号set_output(output); //设置输出信号}return 0;}以上是PID控制算法的C语言实现方法，可以根据实际情况进行调整和优化。
PID算法
PID算法PID算法是一种常用的控制算法，应用广泛于各种自动化系统中。
它可以实现对被控对象的精确控制，具有稳定性好、鲁棒性强等优点。
PID 算法是通过不断调整控制器的输出信号，使得被控对象的实际输出与期望输出之间的误差最小化的过程。
PID算法是由比例环节(proportional)，积分环节(integral)和微分环节(derivative)组成的。
比例环节根据误差的大小来调整控制器的输出信号，积分环节用于积累误差并使其最小化，微分环节根据误差的变化率来调整控制器的输出。
通过调节这三个环节的参数，可以实现对被控对象的精确控制。
在C语言中实现PID算法的一般步骤如下：1.定义全局变量和常量：定义一些全局变量来储存PID算法中的参数和中间结果，定义一些常量来设置PID算法的参数。
```cdouble Kp = 1.0; // 比例系数double Ki = 0.5; // 积分系数double Kd = 0.2; // 微分系数double error = 0.0; // 误差double integral = 0.0; // 积分项double derivative = 0.0; // 微分项double last_error = 0.0; // 上一次误差2.编写PID算法函数：编写一个函数来计算PID算法的输出信号。
```cdouble pid_algorithm(double input, double setpoint, double dt)//计算误差error = setpoint - input;//计算积分项integral += error * dt;//计算微分项derivative = (error - last_error) / dt;//计算PID输出double output = Kp * error + Ki * integral + Kd * derivative;//更新上一次误差last_error = error;return output;```3.在主函数中调用PID算法函数：在主函数中调用PID算法函数来实现对被控对象的控制。
最全PID控制算法的C语言实现
最全PID控制算法的C语言实现PID控制算法是一种在控制系统中常用的反馈控制算法，用于根据实际测量值来调节输出来实现对系统状态的控制。
PID算法包含三个控制参数：比例常数（Kp）、积分常数（Ki）和微分常数（Kd）。
这三个参数分别调节了比例控制、积分控制和微分控制的比例，用于实现不同的控制效果。
下面是一个最全的PID控制算法的C语言实现示例：```c#include <stdio.h>//定义PID控制算法的参数float Kp = 1.0; // 比例常数float Ki = 0.5; // 积分常数float Kd = 0.2; // 微分常数//定义全局变量用于记录控制过程中的误差与累积误差float error = 0.0;float lastError = 0.0;float integral = 0.0;//定义PID控制函数float pidControl(float target, float current, float dt)//计算误差error = target - current;//计算累积误差integral += error * dt;//计算微分误差float derivative = (error - lastError) / dt;//计算PID输出float output = Kp * error + Ki * integral + Kd * derivative; //更新上一次误差lastError = error;return output;int mai//模拟控制过程float target = 100.0; // 目标值float current = 0.0; // 当前值float dt = 0.1; // 控制周期for(int i = 0; i < 100; i++)//调用PID控制函数float output = pidControl(target, current, dt);//更新当前值，模拟实际过程中的测量误差current += output * dt + 0.2;printf("Target: %.2f, Current: %.2f, Output: %.2f\n", target, current, output);}return 0;```上述代码通过定义全局变量来记录控制过程中的误差与累积误差，并在PID控制函数中进行计算和更新。
模糊PID控制温控系统设计C语言程序代码
模糊PID控制温控系统设计C语言程序代码请注意，由于1200字的限制，下面的代码只是模糊PID控制温控系统的一个简单示例。
如果您需要更详细和完整的代码，请提供更多的细节和规格要求。
```c#include <stdio.h>//PID参数float kp = 0.5; // 比例系数float ki = 0.2; // 积分系数float kd = 0.1; // 微分系数//PID变量float integral = 0; // 积分累计float previous_error = 0; // 上一次的误差//温度传感器读取函数，返回当前温度float read_temperatur//实现温度传感器读取的代码逻辑//返回当前温度值//控制器输出函数，将控制信号发送给执行机构void control_output(float control_signal)//实现将控制信号发送给执行机构的代码逻辑int mai//设置设定温度float setpoint = 25.0;//主循环while (1)//获取当前温度float current_temperature = read_temperature(;//计算误差float error = setpoint - current_temperature;//计算PID控制信号float p_term = kp * error;integral += ki * error;float d_term = kd * (error - previous_error);float control_signal = p_term + integral + d_term; //更新上一次的误差previous_error = error;//输出控制信号control_output(control_signal);}return 0;```上述代码中，我们首先定义了PID参数和变量，以及温度传感器读取函数和控制器输出函数。
PID控制算法的C语言实现精修订
PID控制算法的C语言实现精修订一、算法的实现步骤1.初始化PID参数：设定比例系数Kp、积分系数Ki和微分系数Kd的初值。
一般情况下，可以根据系统的特性进行经验调整。
2.设置控制目标：设定系统需要达到的目标值。
3.读取当前系统的测量值：使用传感器或其他设备获取当前系统的实际测量值。
4.计算系统误差：将目标值减去实际测量值，得到系统的误差。
5.计算PID控制量：将控制量设为比例项、积分项和微分项的和。
比例项为误差乘以比例系数Kp，积分项为误差的累积乘以积分系数Ki，微分项为误差变化率乘以微分系数Kd。
6.更新PID参数：根据实际情况，可调整PID参数的值。
一般情况下，可以使用经验调整方法，如试探法或模拟法。
7.输出控制量：将PID控制量作为输出，在系统中执行相应的控制操作，如调节电机的转速或改变阀门的开度。
8.循环执行以上步骤，直到系统达到控制目标或终止算法。
二、参数调整方法1.经验调整法：根据系统的特性和控制要求，选择合适的PID参数初值，通过实验或仿真来逐步调整参数，使系统达到最佳控制效果。
2. Ziegler-Nichols法则：利用开环试验的响应特性，通过确定系统的临界增益和周期，计算出PID参数。
该方法相对简单，但对系统的稳定性要求较高。
3.自整定法：利用系统的模型参数，结合在线参数调整技术，通过试错调整来获取最佳PID参数。
方法复杂度较高，但能够适应系统动态性变化较大的情况。
4.基于优化算法的自适应调整法：利用遗传算法、粒子群算法等优化算法，通过迭代计算获得最佳PID参数。
该方法不需要系统模型，但需要大量的计算和优化算法的实现。
三、实际应用案例假设有一个加热器，需要将温度控制在一个设定值范围内。
可以使用PID控制算法实现温度的稳定控制。
1.初始化PID参数：设定比例系数Kp=1，积分系数Ki=0.5和微分系数Kd=0.22.设置控制目标：设定温度控制的目标范围为35℃到40℃。
3.读取当前系统的温度值：使用温度传感器读取当前系统的实际温度值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//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