PID调节的C语言及MATLAB实现方法

最新推荐文章于 2025-03-16 15:43:37 发布
最新推荐文章于 2025-03-16 15:43:37 发布
阅读量2.3k 收藏 22
点赞数 1
分类专栏： 嵌入式C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aoyousihaiqiuqihuang/article/details/119980723
版权

PID控制 C语言 模拟控制系统 系统反馈 离散化处理
关键词由CSDN通过智能技术生成

在模拟控制系统中，控制器最常用的控制规律就是PID控制，控制系统的原理框图如图所示：

 在实现PID控制的过程中，关键的部分除了PID三个参数之外，就是system和系统反馈了，需要能够拿到系统当前的输出，才能够形成一个闭环的反馈控制系统，而system就是系统本身的特性，表征系统自身的输入与输出之间的关系，从而能够将PID控制器的输出叠加到系统输出上。将连续系统进行离散化处理，就能得到PID在离散系统中的表达。

C语言中构建PID控制器如下：

typedef struct {
	/* Controller gains */
	float Kp;
	float Ki;
	float Kd;
	/* Output limits */
	float limMin;
	float limMax;
	/* Integrator limits */
	float limMinInt;
	float limMaxInt;
	/* Sample time (in seconds) */
	float T;
	/* Controller "memory" */
	float integrator;
	float prevError;			/* Required for integrator */
	float differentiator;
	float prevMeasurement;		/* Required for differentiator */
	/* Controller output */
	float out;
} PIDController;

初始化PID控制器：

void PIDController_Init(PIDController *pid) {

	/* Clear controller variables */
	pid->integrator = 0.0f;
	pid->prevError  = 0.0f;

	pid->differentiator  = 0.0f;
	pid->prevMeasurement = 0.0f;

	pid->out = 0.0f;
}

控制方法的实现：


float PIDController_Update(PIDController *pid, float setpoint, float measurement) {

	/*Error signal*/
    float error = setpoint - measurement;

	/*Integral*/
	pid->integrator = pid->integrator + 0.5f *(error + pid->prevError);

	/* Anti-wind-up via integrator clamping */
    if (pid->integrator > pid->limMaxInt) {

        pid->integrator = pid->limMaxInt;

    } else if (pid->integrator < pid->limMinInt) {

        pid->integrator = pid->limMinInt;

    }

	/* Derivative (band-limited differentiator)*/
	pid->differentiator = (error - pid->prevError);	/* Note: derivative on measurement, therefore minus sign in front of equation! */

	/*Compute output and apply limits*/
    pid->out = (pid->Kp) * error + (pid->Ki)* (pid->integrator) + (pid->Kd) * (pid->differentiator);

    if (pid->out > pid->limMax) {

        pid->out = pid->limMax;

    } else if (pid->out < pid->limMin) {

        pid->out = pid->limMin;

    }

	/* Store error and measurement for later use */
    pid->prevError       = error;
    pid->prevMeasurement = measurement;

	/* Return controller output */
    return pid->out;
}

一个简单的测试demo：

#define PID_KP  0.9f
#define PID_KI  0.5f
#define PID_KD  0.0f

#define PID_LIM_MIN -10.0f
#define PID_LIM_MAX  10.0f

#define PID_LIM_MIN_INT -5.0f
#define PID_LIM_MAX_INT  5.0f

#define SAMPLE_TIME_S 0.1f

/* Maximum runtime of simulation */
#define SIMULATION_TIME_MAX 50.0f

/* Simulated dynamical system (first order) */
float TestSystem_Update(float inp);

int main()
{
    /* Initialise PID controller */
    PIDController pid = { PID_KP, PID_KI, PID_KD,
                          PID_LIM_MIN, PID_LIM_MAX,
			  PID_LIM_MIN_INT, PID_LIM_MAX_INT,
                          SAMPLE_TIME_S };

    PIDController_Init(&pid);

    /* Simulate response using test system */
    float setpoint = 2.0f;

    printf("Time (s)\tsetpoint\tsystem output\r\n");
    for (float t = 0.0f; t <= SIMULATION_TIME_MAX; t += SAMPLE_TIME_S) {

        /* Get measurement from system */
        float measurement = TestSystem_Update(pid.out);

        /* Compute new control signal */
        PIDController_Update(&pid, setpoint, measurement);

        printf("%f\t%f\t%f\r\n", t, setpoint, measurement);

    }
    return 0;
}

float TestSystem_Update(float inp) {

    float output;
     output = (1.0f + inp);
    return output;
}

测试结果如下：

Time (s)        setpoint        system output
0.000000        2.000000        1.000000
0.100000        2.000000        2.150000
0.200000        2.000000        1.327500
0.300000        2.000000        2.198375
0.400000        2.000000        1.533118
0.500000        2.000000        2.198976
0.600000        2.000000        1.666681
0.700000        2.000000        2.179332
0.800000        2.000000        1.756443
0.900000        2.000000        2.153100
1.000000        2.000000        1.818723
1.100000        2.000000        2.126706
1.200000        2.000000        1.863164
1.300000        2.000000        2.102885
1.400000        2.000000        1.895624
1.500000        2.000000        2.082531
1.600000        2.000000        1.919776
1.700000        2.000000        2.065679
1.800000        2.000000        1.938002
1.900000        2.000000        2.051991
2.000000        2.000000        1.951903
2.100000        2.000000        2.041009
2.200000        2.000000        1.962585
2.300000        2.000000        2.032268
2.400000        2.000000        1.970840
2.500000        2.000000        2.025348
2.600000        2.000000        1.977244
2.700000        2.000000        2.019890
2.799999        2.000000        1.982225
2.899999        2.000000        2.015594
2.999999        2.000000        1.986107
3.099999        2.000000        2.012220
3.199999        2.000000        1.989137
3.299999        2.000000        2.009573
3.399999        2.000000        1.991503
3.499999        2.000000        2.007497
3.599999        2.000000        1.993352
3.699999        2.000000        2.005870
3.799999        2.000000        1.994798
3.899998        2.000000        2.004596
3.999998        2.000000        1.995930
4.099998        2.000000        2.003598
4.199998        2.000000        1.996815
4.299998        2.000000        2.002816
4.399998        2.000000        1.997507
4.499998        2.000000        2.002204
4.599998        2.000000        1.998049
4.699998        2.000000        2.001726
4.799998        2.000000        1.998473
4.899998        2.000000        2.001351
4.999998        2.000000        1.998805
5.099998        2.000000        2.001057
5.199997        2.000000        1.999065
5.299997        2.000000        2.000827
5.399997        2.000000        1.999268
5.499997        2.000000        2.000648
5.599997        2.000000        1.999427
5.699997        2.000000        2.000507
5.799997        2.000000        1.999552
5.899997        2.000000        2.000397
5.999997        2.000000        1.999649
6.099997        2.000000        2.000310
6.199996        2.000000        1.999725
6.299996        2.000000        2.000243
6.399996        2.000000        1.999785
6.499996        2.000000        2.000190
6.599996        2.000000        1.999832
6.699996        2.000000        2.000149
6.799996        2.000000        1.999868
6.899996        2.000000        2.000116
6.999996        2.000000        1.999897
7.099996        2.000000        2.000091
7.199996        2.000000        1.999919
7.299995        2.000000        2.000071
7.399995        2.000000        1.999937
7.499995        2.000000        2.000056
7.599995        2.000000        1.999951
7.699995        2.000000        2.000044
7.799995        2.000000        1.999961
7.899995        2.000000        2.000034
7.999995        2.000000        1.999970
8.099995        2.000000        2.000027
8.199995        2.000000        1.999976
8.299995        2.000000        2.000021
8.399996        2.000000        1.999981
8.499996        2.000000        2.000016
8.599997        2.000000        1.999986
8.699997        2.000000        2.000013
8.799997        2.000000        1.999989
8.899998        2.000000        2.000010
8.999998        2.000000        1.999991
9.099998        2.000000        2.000008
9.199999        2.000000        1.999993
9.299999        2.000000        2.000006
9.400000        2.000000        1.999995
9.500000        2.000000        2.000005
9.600000        2.000000        1.999996
9.700001        2.000000        2.000004
9.800001        2.000000        1.999997
9.900002        2.000000        2.000003
10.000002       2.000000        1.999998
10.100002       2.000000        2.000002
10.200003       2.000000        1.999998
10.300003       2.000000        2.000002
10.400003       2.000000        1.999999
10.500004       2.000000        2.000001
10.600004       2.000000        1.999999
10.700005       2.000000        2.000001
10.800005       2.000000        1.999999
10.900005       2.000000        2.000001
11.000006       2.000000        1.999999
11.100006       2.000000        2.000000
11.200006       2.000000        2.000000
11.300007       2.000000        2.000000
11.400007       2.000000        2.000000
11.500008       2.000000        2.000000
11.600008       2.000000        2.000000
11.700008       2.000000        2.000000
11.800009       2.000000        2.000000
11.900009       2.000000        2.000000
12.000010       2.000000        2.000000
12.100010       2.000000        2.000000
12.200010       2.000000        2.000000
12.300011       2.000000        2.000000
12.400011       2.000000        2.000000

经过一段时间后，系统达到了理想的输出。接下来，在matlab中建立上面的模型：

给定了一个较大的微分系数，系统在经过了一段时间的振荡之后到达了稳定 

 同样的条件下，去掉微分项，结果如下：

本文中，系统输出与PID控制器输出是一个非常简单的线性关系，在PID控制的实际应用中通常需要系统特性的一个数学表达，将PID的输出叠加到系统输出中。

reference：

https://github.com/pms67/PID

 

PID调节C语言解析
彼时思默的博客
03-15 4516
前言 老师布置了个任务,用编程实现PID调节,鉴于我们专业都学过C语言和VB,于是我就想拿Kotlin练练手. 上网搜索一番别人怎么用C实现的,找到个比较详细的,但是展示了太多数据,我这里整理一下基础知识. 简要解析 参考资料,来自这里 通过误差信号控制被控量，而控制器本身就是比例、积分、微分三个环节的加和。这里我们规定（在t时刻）： - 输入量为rin(t); - 输出量为...
c语言中离散化,PID控制器的离散化推导及其C语言实现
weixin_32553639的博客
05-19 1931
一、理论下图是采用了PID控制器的闭环控制策略。 PID控制器的传递函数： 上式中，Y是控制器的输出，U是控制器的输入。有时候，在Matlab仿真中已经调好了Kp和Ki、Kd参数，但是离散化后，系数和离散时间有关。因此需要重新计算系数。方法一、用公式替代s算子用Trapezoid(Tustin)方法离散化PID控制器。另外更多的传递函数离散化方法请浏览：https://blog.csdn.net/...
离散控制Matlab代码-LIBPIDv1:PID控制器算法在C程序中的实现
05-23
离散控制Matlab代码PID控制器算法 该库受MIT许可的约束，因此允许将其用于商业用途，修改，分发和私人使用，而不承担任何担保和责任。 PID控制器算法是用C编程语言开发的，以简化其在嵌入式系统中的实现。 因此，该算法可以导入到其IDE支持C编程（C-99）的任何嵌入式系统项目中。 该库为离散PID控制器提供了带导数过滤器和防缠绕方案，可通过Matlab simulink对其进行调整。 simulink提供积分和微分滤波器类型的选择，默认情况下两者均设置为正向欧拉（S到Z映射）。 此外，控制器的实际应用在输入和输出信号的大小上有限制。 例如，如果使用微控制器的ADC转换器读取设定值，则最大输入值可能是1023或255（3.3伏或5.0伏）。 在控制器的实际应用中，PWM用于生成控制信号，但是该信号的强度不足以驱动设备（例如电动机）。 因此，使用容量受限的放大器或驱动器来生成足以驱动设备的控制信号。 驾驶员约束也限制了可能非常大的控制工作量，因此，输出执行器极限在程序中被软编码。 为进一步推动该项目，在以下方面得到了高度评​​价：1.开发自动调谐功能2.将算法转换为C ++以支持Ar
掌握PID控制：模拟软件的全面介绍
最新发布
weixin_42181686的博客
03-16 1021
在自动化控制领域中，PID控制器是最为广泛使用的控制策略之一，其名称源于其三大组成部分：比例（P）、积分（I）和微分（D）。PID控制器通过这三个环节对系统的输出进行调整，以达到期望的控制效果。PID控制器适用于各种工业应用，例如温度控制、速度控制、压力控制等。因其结构简单、适应性强和可靠性高的特点，在石油、化工、冶金、机械、电力、轻工、环保等行业的自动化控制系统中，都可以看到PID控制器的身影。
PID控制算法的C语言实现
热门推荐
沐 白
11-27 13万+
PID控制算法的C语言实现一 PID算法原理    最近两天在考虑一般控制算法的C语言实现问题，发现网络上尚没有一套完整的比较体系的讲解。于是总结了几天，整理一套思路分享给大家。    在工业应用中PID及其衍生算法是应用最广泛的算法之一，是当之无愧的万能算法，如果能够熟练掌握PID算法的设计与实现过程，对于一般的研发人员来讲，应该是足够应对一般研发问题了，而难能可贵的是，在我所接触的控制算法
改进式PID控制以及C语言实现过程
Zodiac_V的专栏
03-31 6280
改进式PID控制          如果是在低速模式下，标准的PID基本可以满足控制要求，但随着速度的提升，PID算法要进一步修改和完善才能达到控制要求。因此需要对PID算式进行适当的改进，从而提高控制质量。          积分项的改进          积分项的作用：消除稳态误差，提高控制系统的精度。 积分项存在的问题：偏差较大时，积分的滞后作用会影响系统的响应速度，引起较大的超调及
Matlab PID控制 C语言代码片段
qq_29796781的博客
05-10 3137
clc; clear N = 100; x = linspace(-3*pi,3*pi,N); % 目标值 % target_val = 20*ones(1,N); target_val = 5*sin(x); % 当前值 current_val =2; % PID 临时变量 integral = 0; last_err = 0; % PID 增益参数 Kp = 0.2; Ki = 0.1; Kd...
matlab编写pid控制器,最近用MATLAB写了一个PID控制器，想把它生成c代码，
weixin_36158843的博客
03-17 653
function Y=PD_Control() %#ok %#codegen%Fuzzy Tunning PI Control%clear all;%close all;a=newfis('fuzzpid');a=addvar(a,'input','e',[-6,6]); %Parameter ea=addmf(a,'input',1,'NB','zm...
PID算法C语言及MATLAB程序
03-10
**PID算法** PID（比例-积分-微分）算法是一种广泛应用...无论是MATLAB仿真还是C语言实现，理解PID的基本原理及其与模糊逻辑的融合都是至关重要的。这有助于优化控制系统的性能，确保其在实际应用中的稳定性和准确性。
C语言与MATLAB实现PID模糊控制程序
当讨论PID算法的C语言及MATLAB程序时，通常指的是使用这两种编程语言实现PID控制逻辑的代码。在C语言中编写PID算法，允许开发者将其嵌入到微控制器或其他设备中，实现实时或接近实时的控制。MATLAB则提供了一个更为...
掌握模糊自适应PID控制器及C语言、Matlab实现
在C语言中，我们可以通过结构化编程方法来编写模糊自适应PID控制器的算法，而MATLAB则提供了更加高级的数学运算和矩阵处理功能，允许用户快速地构建模糊逻辑系统和PID控制器。 - **C语言版本**：适用于嵌入式系统和...
PID算法C语言与Matlab仿真教程及源代码
文档中应该详细描述了PID算法的工作原理、C语言和Matlab程序的设计思路、程序结构以及使用方法等。 对于编程人员来说，该资源可以用于学习如何在C语言中实现PID算法，以及如何利用Matlab进行控制系统的设计和仿真。...
PID:用C语言编写的PID控制器实现
04-14
PID 用C编写的PID控制器实现 关于“测量导数”的注释：由于有效地进入微分器的“误差信号”不取决于设定点：e [n] = 0-测量，因此（e [n]-e [n-1 ]）=（0-测量）-（0-prevMeasurement）= -Kd *（测量-prevMeasurement）。 （请注意，负号与误差导数相比！）我已经在代码中包括了负号，因此增益将具有正常的作用。
PID 的C程序
10-18
压缩包里有PID的C程序和头文件，用来控制驱动电机的转速
【C语言实现PID控制器】
六月悉茗的博客
06-13 3725
/ PID控制器参数// 比例增益// 积分增益// 微分增益// PID控制器状态// 误差的积分// 上一次的误差。
pid控制C语言实现
他山之石 可以攻玉
08-27 2463
/* 积分分离的pid控制算法c语言实现 系统所用时间是原来时间的一半 系统的快速性得到了提高 */ #include<stdio.h> #include<stdlib.h> struct _pid{ float SetSpeed; //定义设定值 //24V 1100-1900 float ActualSpeed; //定义实际值 float err; //定义偏差值 float err_last; //定义上一个偏差值 float.
c语言使用面向对象封装思想，实现PID控制器
wei
07-31 2008
面向对象编程是一种抽象。其特质之一为封装。 我们在编程的时候，常讲的模块化编程，而如何去将其模块化，就是我们在设计时的对程序的一种抽象。如果有重构的经验的同学，应该更能体会，某一天发现自己的以前的某个功能模块不满足需求，或者耦合太严重，那么就会有种重写的冲动。当然希望大家会喜欢这种感觉，因为在这个过程中，所锻炼的自己的抽象能力，以及那种把控，设计数据结构，接口是追求代码的极致。 使用c的struct写c++的class 接下来会以写一个PID控制器模块，使用封装的思想，如何用c的struct模仿c++的c
PID控制器的离散化推导及其C语言实现
迷宫中的我
09-30 2万+
一、理论 下图是采用了PID控制器的闭环控制策略。 PID控制器的传递函数： 上式中，Y是控制器的输出，U是控制器的输入。 有时候，在Matlab仿真中已经调好了Kp和Ki、Kd参数，但是离散化后，系数和离散时间有关。因此需要重新计算系数。 方法一、用公式替代s算子 用Trapezoid(Tustin)方法离散化PID控制器。另外更多的传递函数离散化方法请浏览：https://...
matlab控制算法C语言,PID算法Matlab仿真程序和C程序
weixin_39638801的博客
05-19 484
《PID算法Matlab仿真程序和C程序》由会员分享，可在线阅读，更多相关《PID算法Matlab仿真程序和C程序(6页珍藏版)》请在人人文库网上搜索。1、增量式PID控制算法Matlab仿真程序设一被控对象G(s)=50/(0.125s2+7s),用增量式PID控制算法编写仿真程序(输入分别为单位阶跃、正弦信号，采样时间为1ms，控制器输出限幅：-5,5,仿真曲线包括系统输出及误差曲线，并加上注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值