前言
大家好,今天我们介绍一下经典控制理论中的 PID 控制算法,并着重讲解该算法的编码实现,为实现后续的倒立摆样例内容做准备。 众所周知,掌握了 PID ,就相当于进入了控制工程的大门,也能为更高阶的控制理论学习打下基础。 在很多的自动化控制领域。都会遇到 PID 控制算法,这种算法具有很好的控制模式,可以让系统具有很好的鲁棒性。
基本介绍
PID 深入理解
(1)闭环控制系统:讲解 PID 之前,我们先解释什么是闭环控制系统。简单说就是一个有输入有输出的系统,输入能影响输出。一般情况下,人们也称输出为反馈,因此也叫闭环反馈控制系统。比如恒温水池,输入就是加热功率,输出就是水温度;比如冷库,输入是空调功率,输出是内部温度。
(2)什么是 PID:英文分解开就是:比例(proportional)、积分(integral)、微分(derivative),其根据系统反馈,通过比例,积分和微分三个部分的计算,动态调整系统输入,确保被控量稳定在人们设定的目标值附近。PID 是目前最常见的应用于闭环反馈控制系统的算法,三个部分可以只用一个(P,I,D),也可以只用两个(PI,PD),也可以三个一起用(PID),非常灵活。
(3)PID 控制原理图与表达式:
上面的控制原理图与下面的数学表达式是相互对应的。
setpoint 为设定值,也叫目标值;output(t) 是系统反馈值,随时间变化;e(t) 是设定值与反馈值的差值,由于反馈总是作为被减数,因此也称为负反馈控制算法;Kp 是比例系数,Kp * e(t) 就是 PID 的比例部分;Ki 是积分系数,Ki 乘以 e(t) 对时间的积分,就是 PID 的积分部分;Kd 是微分系数,Kd 乘以 e(t) 对时间的微分,就是 PID 的微分部分。通常情况下,三个系数都是正数,但三个部分正负号并不一定相同,相互之间有抵消和补偿。三个部分之和,就是系统输入值 input(t)。整个控制系统的目标就是让差值 e(t) 稳定到 0。
(4)我们以恒温水池为例,讲解 PID 的三个部分:其中 input(t) 为加热功率,output(t) 为水池温度,setpoint 假设为 36 度, e(t) 为 setpoint 与当前温度的差值 。
比例部分:比例部分最直观,也比较容易理解,举例而言:假设当前水温为 20 度,差值 e 为 36 - 20 = 16 度,乘上比例系数 Kp ,得到加热功率,于是温度就会慢慢上涨;如果水温超过了设定温度,比如 40 度,差值 e 为 36 - 40 = -4 度,则停止加热,让热量耗散,温度就会慢慢下降。
微分部分:只有比例部分,我们可以想象出水池温度的变化通常会比较大,而且很难恒定,这样的水池不能算是恒温水池。解决办法是引入差值 e(t) 的微分,也就是 e(t) 对时间的导数。通过数学计算,可得导数为水池温度的斜率负数:
根据求导结果,我们分两种情况讨论微分部分对比例部分的作用:当差值 e(t) 扩大时:微分部分将与比例部分同正负号,对比例部分进行补偿,更好的抑制差值扩大;当差值 e(t) 缩小时:微分部分将与比例部分异号,对比例部分进行抵消,防止系统输出过冲。综合两种情况,可以认为微分部分提供了一种预测性的调控作用,通过考虑差值 e(t) 的未来走势,更精细地调整系统输入,从而让系统输出逐渐收敛到目标值。
积分部分:只有比例和微分部分,在某些场景下会失灵。举例而言,假如我们只使用 PD 算法。此时水池的室外温度非常低,热量散失非常快。当加热到某个温度的时候(比如 30 度),温度可能再也无法上涨。这种情况,称之为系统的稳态误差。我们分两部分解释原因:比例部分:由于差值 e(t) 不那么大了,比例部分会比较小,每次增加的热量正好被耗散掉,因此温度不会继续上升;微分部分:由于温度基本恒定,微分部分将约为零,也无法对比例部分进行补偿。解决办法是引入差值 e(t) 的积分,也就是 e(t) 乘以单位时间并不断累加,数学表达式如下:
假设温度停在了 30 度,不再上升,此时,积分部分会随着时间的推移而不断增加,相当于对比例部分进行补偿,从而增加加热功率,最终温度将继续上升。下面的动图比较形象地展示了三个参数对系统输出的影响:
(5)PID 为什么被称为启发式控制算法:
第一,PID 的三个参数并非基于严格的数学计算得到,而是靠工程师的直觉和经验。第二,PID 算法调参的目标是可用,只要实际效果不错就行,并不追求最优解。第三,PID 不依赖精确的数学模型,就能进行有效的控制。因此看起来更像是一种基于实践和实际效果的启发式方法,而不是一个理论上推导出来的控制策略。(6)介绍一种 PID 调参方法:Ziegler-Nichols(齐格勒-尼科尔斯)最终值振荡法第一,将微分系数 Kd 和积分系数 Kp 都设置为 0,只保留比例系数。第二,不断增加比例系数,直到达到无衰减的持续振荡,此时的比例系数称为 Ku ,此时的振荡周期为 Tu。第三,使用临界系数和振荡周期设置 PID 参数:
比例系数:Kp = 0.60 * Ku 积分系数:Ki = 2 * Kp / Tu 微分系数:Kd = Kp * Tu / 8
PID 编码实现
这部分我们主要参考 Arduino 的 PID 库 Arduino-PID-Library,分八步实现一个实际可用的 PID 算法库。接下来的每一步都需要大家认真的阅读,因为涉及到很多的细节。
特别提示:由于本节讲解 PID 的实现,我们将以 PID 作为第一视角,如果提到 input ,指的是 PID 算法输入,相当于上节中的系统输出 output(t),即恒温水池的温度;如果提到 ouput,指的是 PID 算法输出,相当于上节中的系统输入 input(t),即加热功率。
初始版本
代码实现 PID 算法,面临最大的困惑是如何实现积分和微分。正如上一节所说,积分可转化为差值 e(t) 乘以采样间隔并不断累加;微分可转换为求两次采样的差值 e(t) 的斜率。于是有了如下代码,请读者关注代码注释(可以直接拿去跑)。
#include <iostream>#include <chrono>#include <thread>
class PIDController {public:explicit PIDController() {InitTime();}
PIDController(double kp_para, double ki_para, double kd_para) : kp_(kp_para), ki_(ki_para), kd_(kd_para) {
InitTime();
}
void InitTime() {
last_time_ = GetMillis();
}
double Compute(double setpoint, double input) {
uint64_t now = GetMillis();
double time_change = static_cast<double>(now - last_time_);
double error = setpoint - input;
printf("error: %f\n", error);
err_sum_ += error * time_change;
double derivative = (error - last_error_) / time_change;
double output = kp_ * error + ki_ * err_sum_ + kd_ * derivative;
last_error_ = error;
last_time_ = now;
return output;
}
void set_tunings(double kp_para, double ki_para, double kd_para) {
kp_ = kp_para;
ki_ = ki_para;
kd_ = kd_para;
}
复制代码
private:double kp_;double ki_;double kd_;
double last_error_ = 0;
double err_sum_ = 0;
uint64_t last_time_ = 0;
uint64_t GetMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
复制代码
};
int main() {PIDController pid;pid.set_tunings(10, 0.01, 0.01);
double setpoint = 36;
double temperature = 20;
std::this_thread::sleep_for(std::chrono::seconds(1));
for (int i = 0; i < 100; ++i) {
double control_signal = pid.Compute(setpoint, temperature);
temperature += control_signal * 0.1;
temperature *= 0.99;
std::cout << "Temperature: " << temperature << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
return 0;
复制代码
}
固定采样间隔
初始版本的 PID 的采样间隔是由外部循环控制的,会导致两个问题:第一,无法获取一致的 PID 行为,因为外部有可能调用,也有可能不调用;第二,每次都要根据采样间隔计算微分和积分部分,这涉及到浮点运算。效率比较低。好的办法是固定采用间隔,两个问题都能解决,看下面的代码以及注释(可以直接拿去跑)。
#include <iostream>#include <chrono>#include <thread>
class PIDController {public:explicit PIDController() {InitTime();}
PIDController(double kp_para, double ki_para, double kd_para) : kp_(kp_para), ki_(ki_para), kd_(kd_para) {
InitTime();
}
void InitTime() {
last_time_ = GetMillis();
}
void set_tunings(double kp_para, double ki_para, double kd_para) {
double sample_time_in_sec = static_cast<double>(sample_time_) / 1000.0;
kp_ = kp_para;
// sum = ki * (error(0) * dt + error(1) * dt + ... + error(n) * dt) = (ki * dt) * (error(0) + error(1) + ... + error(n))
ki_ = ki_para * sample_time_in_sec;
// derivative = kd * (error(n) - error(n-1)) / dt = (kd / dt) * (error(n) - error(n-1))
kd_ = kd_para / sample_time_in_sec;
}
void set_sample_time(uint64_t new_sample_time) {
if (new_sample_time > 0) {
double ratio = static_cast<double>(new_sample_time) / static_cast<double>(sample_time_);
ki_ = ki_ * ratio;
kd_ = kd_ / ratio;
sample_time_ = new_sample_time;
}
}
double Compute(double setpoint, double input) {
uint64_t now = GetMillis();
uint64_t time_change = now - last_time_;
if (time_change < sample_time_) {
return last_output_;
}
double error = setpoint - input;
printf("error: %f\n", error);
err_sum_ += error;
double derivative = error - last_error_;
double output = kp_ * error + ki_ * err_sum_ + kd_ * derivative;
last_error_ = error;
last_time_ = now;
last_output_ = output;
return output;
}
复制代码
private:double kp_;double ki_;double kd_;
double last_error_ = 0.0;
double err_sum_ = 0.0;
uint64_t last_time_ = 0UL;
double last_output_ = 0.0;
uint64_t sample_time_ = 1000UL; // 1 second
uint64_t GetMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
复制代码
};
int main() {PIDController pid;pid.set_tunings(1, 0.2, 0.02);pid.set_sample_time(1000); // Set sample time to 1 second
double setpoint = 36;
double temperature = 20;
std::this_thread::sleep_for(std::chrono::seconds(1));
for (int i = 0; i < 1000; ++i) {
double control_signal = pid.Compute(setpoint, temperature);
temperature += control_signal * 0.1;
temperature *= 0.99;
std::cout << "Temperature: " << temperature << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
return 0;
复制代码
}
消除 spike
spike 的英文含义是尖刺,这里指的是当系统运行过程中,突然改变 setpoint 时, PID 的微分部分会因 setpoint 的突然切换而生成一个极大的导数,导致算法输出值 output 将产生一次急剧变化,这就是 spike。比如恒温水池的初始 setpoint 是 36 度,运行过程中,突然改为 50 度。相当于在一个采样周期内,差值 error 突然增加了 14 ,再除以采样周期,数值将会非常大,如下图所示。
解决办法是将 setpoint 从 PID 的微分部分请出去,理论依据是:差值 error 的导数也是算法输入(恒温水池的温度)的斜率负数:
代码实现如下:
#include <iostream>#include <chrono>#include <thread>
class PIDController {public:explicit PIDController() {InitTime();}PIDController(double kp_para, double ki_para, double kd_para) : kp_(kp_para), ki_(ki_para), kd_(kd_para) {InitTime();}
void InitTime() {
last_time_ = GetMillis();
}
void set_tunings(double kp_para, double ki_para, double kd_para) {
double sample_time_in_sec = static_cast<double>(sample_time_) / 1000.0;
kp_ = kp_para;
ki_ = ki_para * sample_time_in_sec;
kd_ = kd_para / sample_time_in_sec;
}
void set_sample_time(uint64_t new_sample_time) {
if (new_sample_time > 0) {
double ratio = static_cast<double>(new_sample_time) / static_cast<double>(sample_time_);
ki_ = ki_ * ratio;
kd_ = kd_ / ratio;
sample_time_ = new_sample_time;
}
}
double Compute(double setpoint, double input) {
uint64_t now = GetMillis();
uint64_t time_change = now - last_time_;
if (time_change < sample_time_) {
return last_output_;
}
double error = setpoint - input;
printf("error: %f\n", error);
err_sum_ += error;
double derivative = input - last_input_;
double output = kp_ * error + ki_ * err_sum_ - kd_ * derivative;
last_input_ = input;
last_time_ = now;
last_output_ = output;
return output;
}
复制代码
private:double kp_;double ki_;double kd_;
double last_input_ = 0.0;
double err_sum_ = 0.0;
uint64_t last_time_ = 0UL;
double last_output_ = 0.0;
uint64_t sample_time_ = 1000UL; // 1 second
uint64_t GetMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
复制代码
};
int main() {PIDController pid;pid.set_tunings(1, 0.2, 0.02);pid.set_sample_time(1000);
double setpoint = 36;
double temperature = 20;
std::this_thread::sleep_for(std::chrono::seconds(1));
for (int i = 0; i < 1000; ++i) {
double control_signal = pid.Compute(setpoint, temperature);
temperature += control_signal * 0.1;
temperature *= 0.99;
std::cout << "Temperature: " << temperature << std::endl;
if (i == 200) {
setpoint = 50;
std::cout << "Setpoint changed to 50" << std::endl;
}
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
return 0;
复制代码
}
动态改参
好的 PID 算法,允许在系统运行过程中,调整 PID 参数。问题的关键是,运行中途修改 PID 参数,如何保持算法输出仍然平稳,对系统状态不产生额外冲击。仔细分析 PID 的三个部分,当对应的参数改变时,影响最大的是积分部分,比例和微分两部分都只影响当前值,而积分部分将会更改历史值。
解决办法是放弃先计算积分和,最后乘以积分系数的做法,而是让积分系数参与每一次积分运算并累加起来:
如此一来,即使更新了积分参数,也只影响当前值,历史值由于被存储起来,因此不会改变,代码实现如下 。
#include <iostream>#include <chrono>#include <thread>
class PIDController {public:explicit PIDController() {InitTime();}PIDController(double kp_para, double ki_para, double kd_para) : kp_(kp_para), ki_(ki_para), kd_(kd_para) {InitTime();}
void InitTime() {
last_time_ = GetMillis();
}
void set_tunings(double kp_para, double ki_para, double kd_para) {
double sample_time_in_sec = static_cast<double>(sample_time_) / 1000.0;
kp_ = kp_para;
ki_ = ki_para * sample_time_in_sec;
kd_ = kd_para / sample_time_in_sec;
}
void set_sample_time(uint64_t new_sample_time) {
if (new_sample_time > 0) {
double ratio = static_cast<double>(new_sample_time) / static_cast<double>(sample_time_);
ki_ = ki_ * ratio;
kd_ = kd_ / ratio;
sample_time_ = new_sample_time;
}
}
double Compute(double setpoint, double input) {
uint64_t now = GetMillis();
uint64_t time_change = now - last_time_;
if (time_change < sample_time_) {
return last_output_;
}
double error = setpoint - input;
printf("error: %f\n", error);
err_item_sum_ += ki_ * error;
double derivative = input - last_input_;
double output = kp_ * error + err_item_sum_ - kd_ * derivative;
last_input_ = input;
last_time_ = now;
last_output_ = output;
return output;
}
复制代码
private:double kp_;double ki_;double kd_;
double last_input_ = 0.0;
double err_item_sum_ = 0.0;
uint64_t last_time_ = 0UL;
double last_output_ = 0.0;
uint64_t sample_time_ = 1000UL; // 1 second
uint64_t GetMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
复制代码
};
int main() {PIDController pid;pid.set_tunings(1, 0.2, 0.02);pid.set_sample_time(1000);
double setpoint = 36;
double temperature = 20;
std::this_thread::sleep_for(std::chrono::seconds(1));
for (int i = 0; i < 1000; ++i) {
double control_signal = pid.Compute(setpoint, temperature);
temperature += control_signal * 0.1;
temperature *= 0.99;
std::cout << "Temperature: " << temperature << std::endl;
if (i == 200) {
pid.set_tunings(1, 0.5, 0.02);
std::cout << "PID coefficients changed, 1, 0.2, 0.02 ->1, 0.5, 0.02" << std::endl;
}
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
return 0;
复制代码
}
设置算法输出限制
通常情况下,PID 算法输出是有一定限制的,比如恒温水池的加热功率不可能无限大,更不可能小于零。当 PID 的算法输出为负数时,实际是停止加热,也就是功率为零。因此需要给 PID 算法添加限制范围,代码实现如下。补充:为了看到输出限制的作用,这次我们把目标温度定为 90 度。
#include <iostream>#include <chrono>#include <thread>
class PIDController {public:explicit PIDController() {InitTime();}PIDController(double kp_para, double ki_para, double kd_para) : kp_(kp_para), ki_(ki_para), kd_(kd_para) {InitTime();}
void InitTime() {
last_time_ = GetMillis();
}
void set_tunings(double kp_para, double ki_para, double kd_para) {
double sample_time_in_sec = static_cast<double>(sample_time_) / 1000.0;
kp_ = kp_para;
ki_ = ki_para * sample_time_in_sec;
kd_ = kd_para / sample_time_in_sec;
}
void set_sample_time(uint64_t new_sample_time) {
if (new_sample_time > 0) {
double ratio = static_cast<double>(new_sample_time) / static_cast<double>(sample_time_);
ki_ = ki_ * ratio;
kd_ = kd_ / ratio;
sample_time_ = new_sample_time;
}
}
void set_output_limits(double min, double max) {
if (min > max) {
return;
}
out_min_ = min;
out_max_ = max;
SetLimits(last_output_);
SetLimits(err_item_sum_);
}
double Compute(double setpoint, double input) {
uint64_t now = GetMillis();
uint64_t time_change = now - last_time_;
if (time_change < sample_time_) {
return last_output_;
}
double error = setpoint - input;
printf("error: %f\n", error);
err_item_sum_ += ki_ * error;
SetLimits(err_item_sum_);
double derivative = input - last_input_;
double output = kp_ * error + err_item_sum_ - kd_ * derivative;
SetLimits(output);
last_input_ = input;
last_time_ = now;
last_output_ = output;
return output;
}
复制代码
private:double kp_;double ki_;double kd_;
double last_input_ = 0.0;
double last_output_ = 0.0;
double err_item_sum_ = 0.0;
double out_min_ = 0.0;
double out_max_ = 0.0;
uint64_t last_time_ = 0UL;
uint64_t sample_time_ = 1000UL; // 1 second
uint64_t GetMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
void SetLimits(double& val) {
if (val > out_max_) {
printf("val: %f > out_max_: %f\n", val, out_max_);
val = out_max_;
} else if (val < out_min_) {
printf("val: %f > out_min_: %f\n", val, out_min_);
val = out_min_;
} else {
; // Do nothing
}
}
复制代码
};
int main() {PIDController pid;pid.set_tunings(1, 0.5, 0.05);pid.set_sample_time(1000);pid.set_output_limits(0, 100);
double setpoint = 90;
double temperature = 20;
std::this_thread::sleep_for(std::chrono::seconds(1));
for (int i = 0; i < 1000; ++i) {
double control_signal = pid.Compute(setpoint, temperature);
temperature += control_signal * 0.1;
temperature *= 0.99;
std::cout << "Temperature: " << temperature << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
return 0;
复制代码
}
添加开关控制
好的 PID 算法应允许使用者动态启停,比如恒温水池运行过程中,由于某种原因,管理人员需要停掉自动控制,改为手动控制,操作结束后,重新启动自动控制。实现动态停止并不复杂,只要 PID 内部加一个开关标识,当关闭时,PID 算法内部不执行计算,外部直接使用人工操作值替代算法输出值进行控制。但问题的关键是,当从手动模式重新改为自动模式时,需要保证恒温水池温度不出现大的抖动,即 PID 算法能接续人类的控制状态,实现平滑过渡。解决办法是重新初始化:当从手动切换到自动时,将水池温度和人工操作值传给 PID ,更新 PID 内部的历史输入值和历史积分值。如此一来,当 PID 重新启动时,就能接续人类的控制结果,平滑启动,如图所示。
#include <iostream>#include <chrono>#include <thread>
enum PID_MODE: uint8_t {PID_MODE_MANUAL = 0,PID_MODE_AUTOMATIC = 1};
class PIDController {public:explicit PIDController() {InitTime();}
PIDController(double kp_para, double ki_para, double kd_para) : kp_(kp_para), ki_(ki_para), kd_(kd_para) {
InitTime();
}
void InitTime() {
last_time_ = GetMillis();
}
void set_tunings(double kp_para, double ki_para, double kd_para) {
double sample_time_in_sec = static_cast<double>(sample_time_) / 1000.0;
kp_ = kp_para;
ki_ = ki_para * sample_time_in_sec;
kd_ = kd_para / sample_time_in_sec;
}
void set_sample_time(uint64_t new_sample_time) {
if (new_sample_time > 0) {
double ratio = static_cast<double>(new_sample_time) / static_cast<double>(sample_time_);
ki_ = ki_ * ratio;
kd_ = kd_ / ratio;
sample_time_ = new_sample_time;
}
}
void set_output_limits(double min, double max) {
if (min > max) {
return;
}
out_min_ = min;
out_max_ = max;
SetLimits(last_output_);
SetLimits(err_item_sum_);
}
void InitInnaState(double input, double output) {
last_input_ = input;
err_item_sum_ = output;
SetLimits(err_item_sum_);
}
void set_auto_mode(PID_MODE mode, double input = 0.0, double output = 0.0) {
bool new_auto = (mode == PID_MODE_AUTOMATIC);
if (new_auto == true && in_auto_ == false) {
InitInnaState(input, output);
}
in_auto_ = new_auto;
std::cout << "PID mode: " << (in_auto_ ? "Automatic" : "Manual") << std::endl;
}
double Compute(double setpoint, double input) {
if (in_auto_ == false) {
return last_output_;
}
uint64_t now = GetMillis();
uint64_t time_change = now - last_time_;
if (time_change < sample_time_) {
return last_output_;
}
double error = setpoint - input;
printf("error: %f\n", error);
err_item_sum_ += ki_ * error;
SetLimits(err_item_sum_);
double derivative = input - last_input_;
double output = kp_ * error + err_item_sum_ - kd_ * derivative;
SetLimits(output);
last_input_ = input;
last_time_ = now;
last_output_ = output;
return output;
}
复制代码
private:double kp_;double ki_;double kd_;
double last_input_ = 0.0;
double last_output_ = 0.0;
double err_item_sum_ = 0.0;
double out_min_ = 0.0;
double out_max_ = 0.0;
uint64_t last_time_ = 0UL;
uint64_t sample_time_ = 1000UL; // 1 second
// PID 内部状态控制量:false 表示手动模式,true 表示自动模式
bool in_auto_ = false;
uint64_t GetMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
void SetLimits(double& val) {
if (val > out_max_) {
printf("val: %f > out_max_: %f\n", val, out_max_);
val = out_max_;
} else if (val < out_min_) {
val = out_min_;
} else {
; // Do nothing
}
}
复制代码
};
int main() {PIDController pid;pid.set_tunings(1, 0.2, 0.02);pid.set_sample_time(1000);pid.set_output_limits(0, 100);
double setpoint = 36.0;
double temperature = 20.0;
std::this_thread::sleep_for(std::chrono::seconds(1));
pid.set_auto_mode(PID_MODE_AUTOMATIC);
for (int i = 0; i < 1000; ++i) {
if (i == 200) {
pid.set_auto_mode(PID_MODE_MANUAL);
std::cout << "---->>> Switch to manual mode" << std::endl;
}
double control_signal = pid.Compute(setpoint, temperature);
if (i >= 200 && i < 250) {
control_signal = 3;
}
if (i >= 250 && i <= 300) {
control_signal = 4;
}
std::cout << "--> Control signal: " << control_signal << std::endl;
temperature += control_signal * 0.1;
temperature *= 0.99;
std::cout << "<-- Temperature: " << temperature << std::endl;
if (i == 300) {
pid.set_auto_mode(PID_MODE_AUTOMATIC, temperature, control_signal);
std::cout << "---->>> Switch back to automatic mode" << std::endl;
}
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
return 0;
复制代码
}
评论