比较典型的PID算法控制程序源代码

合集下载

单片机模糊控制pid 源代码

单片机模糊控制pid 源代码1. 单片机模糊控制PID的基本原理单片机模糊控制PID是一种基于模糊控制理论和PID控制理论相结合的控制方法。

其基本原理是通过模糊控制算法对系统进行模糊化处理，将输入和输出都转化为模糊量，然后再利用PID控制算法对模糊量进行处理，最终得到控制量，从而实现对系统的控制。

2. 单片机模糊控制PID的源代码实现单片机模糊控制PID的源代码实现需要先进行模糊化处理，然后再进行PID控制计算。

下面是一个基于C语言的单片机模糊控制PID的源代码示例：```#include <stdio.h>#include <stdlib.h>#include <math.h>//模糊化处理函数float fuzzy(float error){float fuzzy_error = 0;if(error < -10)fuzzy_error = -1;else if(error >= -10 && error < -5)fuzzy_error = (error + 10) / 5;else if(error >= -5 && error <= 5)fuzzy_error = 0;else if(error > 5 && error <= 10)fuzzy_error = (error - 5) / 5;else if(error > 10)fuzzy_error = 1;return fuzzy_error;}//PID控制函数float PID(float error, float last_error, float sum_error) {float kp = 0.5;float ki = 0.1;float kd = 0.2;float p = kp * error;float i = ki * sum_error;float d = kd * (error - last_error);return p + i + d;}int main(){float error = 0;float last_error = 0;float sum_error = 0;float control = 0;for(int i = 0; i < 100; i++){error = 10 - i;float fuzzy_error = fuzzy(error);sum_error += error;control = PID(fuzzy_error, last_error, sum_error);last_error = error;printf("control: %f\n", control);}return 0;}```3. 单片机模糊控制PID的应用场景单片机模糊控制PID可以应用于各种需要精确控制的场景，例如温度控制、机器人控制、电机控制等。

经典控制PID控制器-C语言代码实现

经典控制PID控制器-C语言代码的实现// 1.定义PID变量结构体struct _pid{float SetValue; //定义设定值float ActualValue; //定义实际值float err; //定义偏差值float err_last; //定义上一个偏差值float Kp,Ki,Kd; //定义比例、积分、微分系数float ActuatorCtrlValue; //控制执行器变量float integral; //定义积分值float Umax; //定义实际值的上限float Umin; //定义实际值得下限float errDisIntegralVar; //定义接触积分环节的偏差限值float ControlOutValue;//定义控制输出}pid;//2. PID算法实现float PID_realize(float SetVar,float ActualVar,float UHigLim,float ULowLim,float ErrDisIntegralLim){int index;pid.SetValue=SetVar;pid.ActualValue=ActualVar;pid.Umax=UHigLim;pid.Umin=ULowLim;pid.err=pid.ActualValue-pid.SetValue;pid.errDisIntegralVar=ErrDisIntegralLim;//积分饱和处理if (pid.ActualValue>pid.Umax){if (abs(pid.err)>pid.errDisIntegralVar){index=1;if (pid.err>0){pid.integral+=1.3*pid.err;}}else{index=1;if (pid.err>0){ pid.integral+=1.2*pid.err;}}}else if(pid.ActualValue<pid.Umin){if (abs(pid.err)>pid.errDisIntegralVar){index=1;if (pid.err<0){pid.integral+=1.3*pid.err;}}else{index=1;if (pid.err<0){pid.integral+=1.2*pid.err;}}}else{if (abs(pid.err)>pid.errDisIntegralVar){index=1;pid.integral+=1.1*pid.err;}else{index=1;pid.integral+=pid.err;}}pid.ControlOutValue=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pi d.err_last);pid.err_last=pid.err;return pid.ControlOutValue;}。

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. 计算控制输出：控制输出等于比例项、积分项和微分项之和。

PID算法（源代码+调试方法）

PID算法（源代码+调试方法）3。

PID代码//定义变量float Kp; //PI调节的比例常数float Ti; //PI调节的积分常数float T; //采样周期float Ki;float ek; //偏差e[k]float ek1; //偏差e[k-1]float ek2; //偏差e[k-2]float uk; //u[k]signed int uk1; //对u[k]四舍五入取整signed int adjust; //调节器输出调整量//变量初始化Kp="4";Ti="0"。

005;T="0".001;// Ki="KpT/Ti"=0.8，微分系数Kd=KpTd/T=0.8,Td=0.0002,根据实验调得的结果确定这些参数ek="0";ek1=0;ek2=0;uk="0";uk1=0;adjust="0";int piadjust(float ek) //PI调节算法if( gabs(ek)<0.1 ){adjust="0";}else{uk="Kp"*(ek-ek1)+Ki*ek; //计算控制增量ek1=ek;uk1=(signed int)uk;if(uk>0){if(uk-uk1>=0.5){uk1=uk1+1;}}if(uk<0){if(uk1-uk>=0.5){uk1=uk1-1;}}adjust="uk1";}return adjust;下面是在AD中断程序中调用的代码。

else //退出软启动后，PID调节,20ms调节一次{EvaRegs.CMPR3=EvaRegs.CMPR3+piadjust(ek);//误差较小PID调节稳住if(EvaRegs.CMPR3>=890){EvaRegs.CMPR3=890; //限制PWM占空比}}。

PID算法程序范文

PID算法程序范文PID控制器是一种常用的反馈控制算法，用于实时地调整控制系统的输出，以使得被控对象的输出尽可能接近设定值。

PID控制器由比例项（P）、积分项（I）和微分项（D）组成，通过对这三个项的调节，可以实现对被控对象的精确控制。

下面是一个简单的PID算法程序的示例，使用C语言编写：```c#include <stdio.h>//定义PID参数#define KP 0.5 // 比例增益#define KI 0.2 // 积分增益#define KD 0.1 // 微分增益//定义全局变量int error = 0; // 当前误差int last_error = 0; // 上一次误差int integral = 0; // 积分项int derivative = 0; // 微分项int output = 0; // 控制器输出//定义被控对象模拟函数int simulate_plant(int control_input)static int actual_output = 0; // 被控对象的输出actual_output += control_input; // 模拟被控对象的响应return actual_output;//PID算法函数int pid_algorithm(int setpoint, int actual_output)error = setpoint - actual_output; // 计算当前误差//计算比例项int proportional = KP * error;//计算积分项integral = integral + error;int integral_term = KI * integral;//计算微分项derivative = error - last_error;int derivative_term = KD * derivative;//计算PID控制器的输出output = proportional + integral_term + derivative_term; //更新上一次误差供下一次计算使用last_error = error;return output;int mai//设置目标值和初始被控对象输出值int setpoint = 50;int actual_output = 0;//模拟实时控制过程，循环100次for (int i = 0; i < 100; ++i)//调用PID算法计算控制器输出int control_input = pid_algorithm(setpoint, actual_output);//更新被控对象的输出actual_output = simulate_plant(control_input);//输出当前相关变量值供调试printf("Error: %d, Control Input: %d, Actual Output: %d\n", error, control_input, actual_output);}return 0;```上述代码中，`KP`、`KI`和`KD`分别表示比例增益、积分增益和微分增益，根据实际控制系统的需求进行调节。

stm32f407调速称的pid运算范例程序

stm32f407调速称的pid运算范例程序以下是一个基于STM32F407芯片的PID调速控制器的示例程序：```c#include "stm32f4xx.h"// PID参数#define KP 1.0f#define KI 0.05f#define KD 0.01f// 电机速度测量值static volatile uint16_t actual_speed = 0;// PID控制器输出static volatile int16_t pid_output = 0;// 目标速度static const uint16_t target_speed = 1000;// PID控制器计算void pid_compute(void){static int16_t last_error = 0;static int32_t integral = 0;uint16_t error = target_speed - actual_speed;// 比例项int32_t proportional = KP * error;// 积分项integral += error;int32_t integral_term = KI * integral;// 微分项int32_t derivative = KD * (error - last_error);last_error = error;// PID输出pid_output = proportional + integral_term + derivative; }// 电机速度测量回调函数void EXTI0_IRQHandler(void){if(EXTI_GetITStatus(EXTI_Line0) != RESET){// 进行电机速度测量，更新actual_speed值actual_speed = 读取测量速度的函数();EXTI_ClearITPendingBit(EXTI_Line0);}}// PWM输出控制函数void pwm_output(int16_t pwm_value){if(pwm_value > 0){// 正转TIM1->CCR1 = pwm_value;GPIO_WriteBit(GPIOA, GPIO_Pin_0, Bit_RESET);GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);}else if(pwm_value < 0){// 反转TIM1->CCR1 = -pwm_value;GPIO_WriteBit(GPIOA, GPIO_Pin_0, Bit_SET);GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_RESET);}else{// 停止TIM1->CCR1 = 0;GPIO_WriteBit(GPIOA, GPIO_Pin_0, Bit_RESET);GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_RESET);}}// 主程序int main(void){// 初始化PWM输出引脚GPIO_InitTypeDef GPIO_InitStructure;GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOA, &GPIO_InitStructure);// 初始化外部中断EXTI_InitTypeDef EXTI_InitStructure;EXTI_InitStructure.EXTI_Line = EXTI_Line0;EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; EXTI_InitStructure.EXTI_LineCmd = ENABLE;EXTI_Init(&EXTI_InitStructure);// 初始化PID计时器TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;TIM_TimeBaseStructure.TIM_Period = 0xFFFF; // 最大值 TIM_TimeBaseStructure.TIM_Prescaler = 0; // 不分频TIM_TimeBaseStructure.TIM_ClockDivision = 0;TIM_TimeBaseStructure.TIM_CounterMode =TIM_CounterMode_Up;TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);// 启动PID计时器TIM_Cmd(TIM2, ENABLE);while(1){// 进行一次PID计算pid_compute();// 控制PWM输出pwm_output(pid_output);}}```请注意，此示例代码仅为演示目的，您需要根据实际情况进行适当修改和调整。

pid示例代码

pid示例代码PID控制是一种经典的反馈控制算法，通过示例代码，对其进行详细说明。

下面是一个简单的PID控制器的Python示例代码：class PIDController:def __init__(self, Kp, Ki, Kd):self.Kp = Kpself.Ki = Kiself.Kd = Kdself.clear()def clear(self):self.setpoint = 0.0self.error_sum = 0.0st_error = 0.0def update(self, measured_value, dt):error = self.setpoint - measured_value# Proportional termP = self.Kp * error# Integral termself.error_sum += error * dtI = self.Ki * self.error_sum# Derivative termderivative = (error - st_error) / dtD = self.Kd * derivative# Calculate the outputoutput = P + I + D# Save the current error for the next iterationst_error = errorreturn output接下来详细解释这段代码的各个部分：1.__init__(self, Kp, Ki, Kd)：初始化方法，用于设置PID控制器的比例系数Kp、积分系数Ki和微分系数Kd。

2.clear(self)：清除方法，将PID控制器的设置点（setpoint）、累积误差（error_sum）和上一次误差（last_error）重置为初始值。

3.update(self, measured_value, dt)：更新方法，用于根据当前测量值和时间间隔来计算PID控制器的输出。

pid算法温度控制c语言程序

pid算法温度控制c语言程序PID算法是一种常用的温度控制算法，广泛应用于各种温度控制系统中。

在C语言中，我们可以通过编写程序来实现PID算法的温度控制功能。

我们需要了解PID算法的基本原理。

PID算法是通过对系统的反馈信号进行不断调整，使得系统的输出达到期望值。

PID算法由三个部分组成：比例控制、积分控制和微分控制。

比例控制根据反馈信号与期望值的差异来调整输出；积分控制根据反馈信号与期望值的累积差异来调整输出；微分控制根据反馈信号的变化率来调整输出。

在C语言中，我们可以使用变量来表示系统的输入、输出和期望值。

以下是一个简单的示例代码：```c#include <stdio.h>// 定义PID参数float Kp = 1.0; // 比例系数float Ki = 0.5; // 积分系数float Kd = 0.2; // 微分系数// 定义系统变量float setpoint = 25.0; // 期望值float input = 0.0; // 输入值float output = 0.0; // 输出值// 定义误差变量float error = 0.0; // 当前误差float last_error = 0.0; // 上一次误差float integral = 0.0; // 累积误差// PID算法函数float pid_algorithm(float setpoint, float input) {// 计算误差error = setpoint - input;// 计算比例控制float proportional = Kp * error;// 计算积分控制integral += error;float integral_control = Ki * integral;// 计算微分控制float derivative = Kd * (error - last_error); // 计算输出output = proportional + integral_control + derivative;// 更新误差last_error = error;return output;}int main(){// 模拟温度传感器的输入input = 23.5;// 调用PID算法函数output = pid_algorithm(setpoint, input);// 打印输出结果printf("Output: %.2f\n", output);return 0;}```在上述代码中，我们首先定义了PID算法的参数和系统变量。

PID控制算法的C语言实现

PID控制算法的C语言实现PID控制算法是一种经典的控制算法，用于调节系统输出和期望值之间的差异，以达到控制系统稳定的目的。

该算法由比例（P）、积分（I）、微分（D）三个部分组成，通过调节这三个部分的权重系数，可以实现对系统的精准控制。

以下是PID控制算法的C语言实现示例代码。

```c#include <stdio.h>//定义PID控制参数结构体typedef structdouble Kp; // 比例系数double Ki; // 积分系数double Kd; // 微分系数double setpoint; // 期望值double integral; // 积分项double prev_error; // 前一次误差}PID;//初始化PID控制器void PID_init(PID* pid, double Kp, double Ki, double Kd, double setpoint)pid->Kp = Kp;pid->Ki = Ki;pid->Kd = Kd;pid->setpoint = setpoint;pid->integral = 0;pid->prev_error = 0;//更新PID控制器的输出值double PID_update(PID* pid, double input, double dt)//计算误差double error = pid->setpoint - input;//比例项double p_term = pid->Kp * error;//积分项pid->integral += pid->Ki * error * dt;//微分项double d_term = pid->Kd * (error - pid->prev_error) / dt; //更新前一次误差pid->prev_error = error;//计算总输出值double output = p_term + pid->integral + d_term;return output;int mai//初始化PID控制器PID pid;PID_init(&pid, 0.5, 0.2, 0.1, 10.0); // 设置Kp=0.5, Ki=0.2, Kd=0.1, setpoint=10.0//模拟系统输入double input = 5.0;//模拟系统运行for (int i = 0; i < 100; i++)//计算PID控制器输出double output = PID_update(&pid, input, 1.0); // 假设采样时间为1.0s//更新系统输入input += output;printf("Output: %lf\n", output);}return 0;```以上代码中，我们定义了一个`PID`结构体，用于存储PID控制器的参数和状态。

自整定pid控制算法c代码

自整定PID控制算法是一种能够自动调整PID控制器的参数以优化其性能的方法。

下面是一个简单的自整定PID控制算法的C代码示例：double output = pid->kp * error + pid->ki * pid->integral + pid->kd * derivative;// 更新误差和积分项pid->last_error = error;// 自整定PID参数// 这里使用一个简单的自整定规则：当误差较大时，增加比例系数；当误差较小时，减小比例系数if (fabs(error) > 1.0) {pid->kp += 0.1;} else if (fabs(error) < 0.1) {pid->kp -= 0.01;}return output;}int main() {// 初始化PID控制器PIDController pid = {1.0, 0.0, 0.1, 0.0, 0.0};// 模拟控制过程double setpoint = 10.0; // 设定值double actual_value = 0.0; // 实际值double dt = 0.1; // 控制周期在这个示例中，我们定义了一个PIDController结构体来表示PID控制器，并实现了一个self_tuning_pid函数来进行自整定PID控制。

在self_tuning_pid函数中，我们首先计算误差和误差变化率，然后计算PID输出，并更新误差和积分项。

接着，我们使用一个简单的自整定规则来根据误差大小调整比例系数。

最后，我们返回PID输出作为控制量。

在main函数中，我们初始化了一个PID控制器，并使用一个循环来模拟控制过程。

在每个控制周期中，我们调用self_tuning_pid函数计算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源程序[1]

//Get input value for process point pid_bumpless(&warm);
// how to display output display_value = pid_calc(&warm); printf("%f\n", display_value);
更多资料下载：
DESCRIPTION Sets the proportional gain (p_gain), integral gain (i_gain), derivitive gain (d_gain), and the dead band (dead_band) of a pid control structure _pid. ------------------------------------------------------------------------*/
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);
DESCRIPTION This function initializes the pointers in the _pid structure to the process variable and the setpoint. *pv and *sp are integer pointers. ------------------------------------------------------------------------*/ void pid_init(struct _pid *warm, int process_point, int set_point) { struct _pid *pid;

PID控制算法C源码

PID控制算法C源码感觉代码不错，以后肯定会⽤到，侵删#include <reg52.h>#include <string.h> //C语⾔中memset函数头⽂件#define unsigned int uinttypedef struct PID {double SetPoint; // 设定⽬标Desired valuedouble Proportion; // ⽐例常数Proportional Constdouble Integral; // 积分常数Integral Constdouble Derivative; // 微分常数Derivative Constdouble LastError; // Error[-1]double PrevError; // Error[-2]double SumError; // Sums of Errors}PID;/*====================================================================================================PID计算部分 =====================================================================================================*/double PIDCalc( PID *pp, double NextPoint ){double dError, Error;Error = pp->SetPoint - NextPoint; // 偏差pp->SumError += Error; // 积分dError = Error - pp->LastError; // 当前微分pp->PrevError = pp->LastError;pp->LastError = Error;return (pp->Proportion * Error // ⽐例项+ pp->Integral * pp->SumError // 积分项+ pp->Derivative * dError // 微分项);}/*==================================================================================================== Initialize PID Structure PID参数初始化 ============= ========================================================================================*/ void PIDInit (PID *pp){memset ( pp,0,sizeof(PID));}/*==================================================================================================== Main Program 主程序 =====================================================================================================*/ double sensor (void) // Dummy Sensor Function{return100.0;} //void actuator(double rDelta) // Dummy Actuator Function //{}void main(void) {PID sPID; // PID Control Structuredouble rOut; // PID Response (Output)double rIn; // PID Feedback (Input)PIDInit ( &sPID ); // Initialize StructuresPID.Proportion = 0.5; // Set PID CoefficientssPID.Integral = 0.5;sPID.Derivative = 0.0;sPID.SetPoint = 100.0; // Set PID Setpointfor (;;) { //Mock Up of PID ProcessingrIn = sensor (); // Read InputrOut = PIDCalc ( &sPID,rIn ); // Perform PID Interation//actuator ( rOut ); // Effect Needed Changes}}。

三环控制pid算法代码

三环控制pid算法代码pythonimport timeclass PIDController:def __init__(self, kp, ki, kd, setpoint, sample_time): self.kp = kpself.ki = kiself.kd = kdself.setpoint = setpointself.sample_time = sample_timest_time = time.time()st_error = 0self.integral = 0def compute(self, feedback):current_time = time.time()elapsed_time = current_time - st_timeerror = self.setpoint - feedbackdelta_error = error - st_errorself.integral += error * elapsed_timederivative = delta_error / elapsed_timeoutput = self.kp * error + self.ki * self.integral + self.kd * derivativest_time = current_timest_error = errorreturn output# 用法示例if __name__ == "__main__":# 设置PID参数kp = 0.5ki = 0.2kd = 0.1# 设置设定值和采样时间setpoint = 50.0sample_time = 0.01# 创建PID控制器对象pid_controller = PIDController(kp, ki, kd, setpoint, sample_time)# 模拟反馈值feedback = 0.0# 模拟控制循环for i in range(1000):# 计算PID输出output = pid_pute(feedback)# 模拟执行控制信号，更新反馈值feedback += output# 打印输出结果print("Iteration:", i, "Output:", output, "Feedback:", feedback)# 等待采样时间time.sleep(sample_time)这段代码实现了一个简单的PID控制器类`PIDController`，其中`kp`、`ki`、`kd`分别是比例、积分和微分系数，`setpoint`是设定值，`sample_time`是采样时间。

PID控制算法的C语言实现完整版精编版

PID控制算法的C语言实现完整版精编版以下是PID控制算法的C语言实现完整版代码。

```#include <stdio.h>#include <stdlib.h>//定义PID参数#define KP 0.5#define KI 0.2#define KD 0.1//PID结构体typedef structfloat setpoint; // 设定值float error; // 误差float integral; // 积分float derivative; // 微分float prev_error; // 上一次误差float output; // 输出}PID;//初始化PIDvoid initializePID(PID *pid, float setpoint)pid->setpoint = setpoint;pid->error = 0;pid->integral = 0;pid->derivative = 0;pid->prev_error = 0;pid->output = 0;//更新PIDfloat updatePID(PID *pid, float input, float dt)//计算误差pid->error = pid->setpoint - input;//计算积分pid->integral += pid->error * dt;//计算微分pid->derivative = (pid->error - pid->prev_error) / dt;//计算输出pid->output = KP * pid->error + KI * pid->integral + KD * pid->derivative;//保存当前误差作为上一次误差pid->prev_error = pid->error;return pid->output;int mai//创建PID对象PID pid;//初始化PIDinitializePID(&pid, 50);//模拟控制过程for (int step = 0; step < 100; step++)//模拟获取输入值float input = input_value(step); // 自定义获取输入值的函数，根据实际应用进行修改//更新PID并获取输出float output = updatePID(&pid, input, 0.1); // 假设采样时间间隔为0.1秒//输出控制信号printf("Step: %d, Output: %.2f\n", step, output);}return 0;```上述代码实现了一个简单的PID控制算法。

温度控制的PID算法的C语言程序

基于PID算法的温度控制系统89C51单片机，通过键盘输入预设值，与DS18B20测得的实际值做比较，然后驱动制冷或加热电路。

用keil C语言来实现PID的控制。

//PID算法温控C语言2008-08-17 18:58#include<reg51.h>#include<intrins.h>#include<math.h>#include<string.h>struct PID {unsigned int SetPoint; // 设定目标Desired Valueunsigned int Proportion; // 比例常数Proportional Constunsigned int Integral; // 积分常数Integral Constunsigned int Derivative; // 微分常数Derivative Constunsigned int LastError; // Error[-1]unsigned int PrevError; // Error[-2]unsigned int SumError; // Sums of Errors};struct PID spid; // PID Control Structureunsigned 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));}/*============================================================================= =======================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); // 微分项}/***********************************************************温度比较处理子程序***********************************************************/pare_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 Inputrout = PIDCalc ( &spid,rin ); // Perform PID Interation}if (high_time<=100)high_time=(unsigned char)(rout/800);elsehigh_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 Inputrout = PIDCalc ( &spid,rin ); // Perform PID Interation}if (high_time<100)high_time=(unsigned char)(rout/10000);elsehigh_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;}elsecount=0;TH0=0x2f;}/***************************************************** 串行口中断服务程序，用于上位机通讯******************************************************/ 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_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;elsedisp_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;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;elsetemper=b;a=temper;flag_2=0;if(++count1>30) {display();count1=0;}pare_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 <REG52.H>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); //480usDQ=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算法PID算法是本程序中的核心部分。

PID源代码

电机PID控制算法// 闭环控制算法// 功能：// 输入：*p PID控制结构体// 输出：电机控制输出值——PWM波脉冲宽度int count=0;unsigned int speed_PID_Calc( struct PID *p ){int ek;int tmpValue = p->ControlValue;int deltaValue = 0;ek = p->Reference - p->FeedBack; // 本次误差 = 参考值 - 反馈值//将PID公式离散化后，采用增量式PID控制,更新电机控制输出值// 遇限削弱积分法，如果进入饱和区，并且积分增加，则不进行积分运算，尽快离开饱和。

// 增量的范围(0~10)*(1+10+10)*256=53760）线性转换为（0~550），移位数, 在4~7之间为好if ( ( p->ControlValue >=550 && ek>0 ) || ( p->ControlValue <= 0 && ek<0 ))//进入饱和区则不再进行积分运算deltaValue = ((int)( p->Ka * ((ek - p->ek_1) + p->Kc * ( (ek - p->ek_1)- (p->ek_1 - p->ek_2) ))))>>5 ;else//不在饱和区，则按正常离散的PID公式计算deltaValue = ((int)( p->Ka * ((ek - p->ek_1) + p->Kb * ek + p->Kc * ( (ek - p->ek_1) - (p->ek_1 - p->ek_2) ))))>>5 ;// 更新前两次误差p->ek_2 = p->ek_1;p->ek_1 = ek;tmpValue = p->ControlValue + deltaValue;// 返回值if ( tmpValue >= 551 )return 550;elseif ( tmpValue <= 0 )return 1;else return tmpValue;}主要原理是上面的，如果需要和实际应用结合起来，那就依据所留I/O口进行适当的修改参数。

(1)位置式PID控制算法代码

(1)位置式PID控制算法代码#include "math.h"struct PID_Data{struct{float uc; //输入命令值float y; //实际测量值float u; //实际控制器输出值float v; //控制器输出的一个比较值}Signals;struct{float P; //比例控制器输出值float I; //积分器输出值float D; //微分器输出值float yold; //y[(k-1)t]的值float Si; //积分分离算法时误差的判断点}States;struct{float K; //比例增益float Ti; //积分时间常数float Td; //微分时间常数float N; //最大位分增益float ulow; //控制器输出最小值float uhigh; //控制器输出最大值float T; //采样周期float Ki,ar,bd,ad; //中间变量}Par;}pid_data;//PID初始化子函数void PID_Init(struct PID_Data * data){data->States.I = 0;data->States.D = 0;data->States.yold = 0;data->Par.K = 4.4;data->Par.Ti = 0.4;data->Par.Td = 0.2;data->Par.N = 10;data->Par.ulow = -1;data->Par.uhigh = 1;data->Par.T = 0.03;data->Par.Ki = (data->Par.K) * (data->Par.T) / (data->Par.Ti); //计算Kidata->Par.bd = (data->Par.K) * (data->Par.N) * (data->Par.Td) /(data->Par.Td + data->Par.N * data->Par.T);data->Par.ad = data->Par.Td / (data->Par.Td + data->Par.N * data->Par.T);}void PID_CalculateOutput(struct PID_Data * data){//比例控制器输出data->States.P = data->Par.K * (data->Signals.uc - data->Signals.y);//微分控制器输出data->States.D = data->Par.ad * data->States.D-data->Par.bd * (data->Signals.y - data->States.yold);//积分控制器的输出data->States.I = data->States.I + data->Par.Ki*(data->Signals.uc - data->Signals.y);//计算控制器的输出data->Signals.v = data->States.P + data->States.I + data->States.D;//判断实际控制器的输出if(data->Signals.v < data->Par.ulow){data->Signals.u = data->Par.ulow;}else if(data->Signals.v > data->Par.uhigh){data->Signals.u = data->Par.uhigh;}else{data->Signals.u = data->Signals.v;}data->States.yold = data->Signals.y;}void PID_Main(){PID_Init(&pid_data);while(1){PID_CalculateOutput (&pid_data);}}（2）增量式PID控制算法struct PID_Data{struct{float uc; //输入命令值float y; //实际测量值}Signals;struct{double u; //实际控制器输出值double deta_u;double u_1; //u[(k-1)t]double u_2; //u[(k-2)t]double y_1; //y[(k-1)t]double y_2; //y[(k-2)t]double error;double error_1;double error_2;double kp;double ki;double kd;}States;struct{double x1;double x2;double x3;}Par;}pid_data;//PID参数初始化void PID_Init(struct PID_Data * data){data->Signals.uc = 5;data->States.deta_u = 0;data->States.u_1 = 0;data->States.u_2 = 0;data->States.y_1 = 0;data->States.y_2 = 0;data->States.kp = 0.05;data->States.ki = 0.000;data->States.kd = 0.000;data->States.error_1 = 0;data->States.error_2 = 0;data->Par.x1 = 0;data->Par.x2 = 0;data->Par.x3 = 0;}//增量式PID算法控制输出计算void PID_CalculateOutput(struct PID_Data * data){int k = 0;data->Signals.y = QepCNTB/10000.0;//控制器输出增量值data->States.deta_u =data->States.kp*data->Par.x1 + data->States.ki*data->Par.x2 + data->States.kd*data->Par.x3;//计算控制器输出data->States.u = data->States.u_1 + data->States.deta_u;//判断实际控制器输出if(data->States.u > 0.32){data->States.u = 0.32;}else if(data->States.u < -0.32){data->States.u = -0.32;}else{data->States.u = data->States.u;}data->States.error = data->Signals.uc-data->Signals.y;data->States.u_2 = data->States.u_1;data->States.u_1 = data->States.u;data->States.y_2 = data->States.y_1;data->States.y_1 = data->Signals.y;data->Par.x1 = data->States.error-data->States.error_1;data->Par.x2 = data->States.error-2*data->States.error_1+data->States.error_2;data->Par.x3 = data->States.error;data->States.error_2 = data->States.error_1;data->States.error_1 = data->States.error;}（3）单神经元自适应控制PID算法#include "math.h"struct PID_Data{struct{double uc; //输入命令值double y; //实际测量值double u; //实际控制器输出值double u_1; //u(k-1)double v; //控制器输出的一个比较量}Signals;struct{long xiteP;long xiteI;long xiteD;long yold; //y[(k-1)t]的值long error; //e(k)long error_1; //e(k-1)long error_2; //e(k-2)}States;struct{int K; //总比例系数long wkp_1;long wki_1;long wkd_1;long wkp;long wki;long wkd;}Par;}pid_data;void PID_Init(struct PID_Data * data){data->Signals.u_1=0;data->States.xiteP=40;data->States.xiteI=35;data->States.xiteD=40;data->States.yold=0;data->States.error_1=0;data->States.error_2=0;data->Par.wkp_1=10;data->Par.wki_1=10;data->Par.wkd_1=10;data->Par.K=0.5;}void PID_CalculateOutput(struct PID_Data * data){long x1,x2,x3;long wadd;long w11,w22,w33;data->States.error=data->Signals.uc-data->Signals.y;data->Par.wkp=data->Par.wkp_1+data->States.xiteP*data->States.error*data->Signals.u_1*(2*data->States.error-data->States.error_1);data->Par.wki=data->Par.wki_1+data->States.xiteI*data->States.error*data->Signals.u_1*(2*data->States.error-data->States.error_1);data->Par.wkd=data->Par.wkd_1+data->States.xiteD*data->States.error*data->Signals.u_1*(2*data->States.error-data->States.error_1);x1=data->States.error-data->States.error_1;x2=data->States.error;x3=data->States.error-2*data->States.error_1+data->States.error_2;wadd=fabs(data->Par.wkp)+fabs(data->Par.wki)+fabs(data->Par.wkd);w11=data->Par.wkp/wadd;w22=data->Par.wki/wadd;w33=data->Par.wkd/wadd;data->Signals.v=data->Signals.u_1+data->Par.K*(x1*w11+x2*w22+x3*w33)/100;if(data->Signals.v>10)data->Signals.u=10;else if(data->Signals.v<-10)data->Signals.u=-10;elsedata->Signals.u=data->Signals.v;data->States.error_2=data->States.error_1;data->States.error_1=data->States.error;data->Signals.u_1=data->Signals.u;}。

传统PID控制源程序

clear all; %清空内存 close all; %关闭所有 ts=0.001; %定义采集时间 1ms u_1=0.0;u_2=0.0;u_3=0.0; %初始状态,u_1 为前一次输入,u_2 为前二次输入、、、 y_1=0;y_2=0;y_3=0; %初始状态输出 y_1 为前一次输出;y_2 为前二次输出、、、 x=[0,0,0]'; %x=0 error_1=0; %前次偏差为零 error_2=0; %前二次偏差为零 for k=1:1:1000 %K=1、2、3、4、、、、1000 time(k)=k*ts; %时间 rin(k)=0.5*sign(sin(2*2*pi*k*ts)); %SIGN（x）：检测 X 的符号，x〈0，返回值为—1， 0， x〉返回值为 1，返回值为 x=0
0 .5 s in 4 t 0 0。定义输入 r in ( k ) 0
kp=0.4; ki=0.35; kd=0.4; % pid 控制参数 du(k)=kp*x(1)+ki*x(2) +kd*x(3);%定义输出 u(k)=u_1+du(k); %此次输出 yout(k)=0.368*y_1+0.26*y_2+0.1*u_1+0.632*u_2;%输出方程 error=rin(k)-yout(k); %偏差=输入值-输出值 u_3=u_2;u_2=u_1;u_1=u(k); %循环赋值 y_3=y_2;y_2=y_1;y_1=yout(k);%循环赋值 x(1)=error-error_1; x(2)=error; x(3)=error-2*error_1+error_2; error_2=error_1; error_1=error; %阶跃式跟踪 end plot(time,rin,'b',time,yout,'r');%画出时间（time）对输出（yout）的二维曲线图 xlabel('time(s)');ylabel('rin,yout');%坐标轴标示

经典PID算法程序

{
pid->pgain = p_gain;
pid->igain = i_gain;
pid->dgain = d_gain;
pid->deadband = dead_band;
pid->integral= integral_val;
pid->last_error=0;
}
//-----------------------------------------------------------------------------
}
//-----------------------------------------------------------
// Subroute Name: pid_setinteg
// Create Time: 06.11.7
// Ver: 0.99
// Author: YSF
// Description:执行PID计算，此过程是个反复过程
if(StationModeCtrl.CtrlAim == 0)
{
FluxGetConfig(2,&FluxConfig);
AI_GetConfig(FluxConfig.Temp1No,&AIConfig);
PIDFollowCtrl.temperaturerange = AIConfig.Max - AIConfig.Min;
// Subroute Name: pid_setinteg
// Create Time: 06.11.7
// Ver: 0.99
// Author: YSF
// Description:为PID平衡的积分设定一个新数值

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

比较典型的PID处理程序
[日期：2005-2-1] 来源：21ICbbs 作者：lookuper [字体：大中小]
/*============================================================================ ========================
这是一个比较典型的PID处理程序，在使用单片机作为控制cpu时，请稍作简化，具体的PID参数必须由具体对象通过实验确定。

由于单片机的处理速度和ram资源的限制，一般不采用浮点数运算，而将所有参数全部用整数，运算
到最后再除以一个2的N次方数据（相当于移位），作类似定点数运算，可大大提高运算速度，根据控制精度的不同要求，当精度要求很高时，注意保留移位引起的“余数”，做好余数补偿。

这个程序只是一般常用pid算法的基本架构，没有包含输入输出处理部分。

============================================================================== =======================*/
#include
#include
/*============================================================================ ========================
PID Function
The PID (比例、积分、微分) function is used in mainly
control applications. PIDCalc performs one iteration of the PID algorithm.
While the PID function works, main is just a dummy program showing a typical usage.
============================================================================== =======================*/
typedef struct PID {
double SetPoint; // 设定目标Desired value
double Proportion; // 比例常数Proportional Const
double Integral; // 积分常数Integral Const
double Derivative; // 微分常数Derivative Const
double LastError; // Error[-1]
double PrevError; // Error[-2]
double SumError; // Sums of Errors
} PID;
/*============================================================================ ========================
PID计算部分
============================================================================== =======================*/
double PIDCalc( PID *pp, double NextPoint )
{
double 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 // 微分项
);
}
/*============================================================================ ========================
Initialize PID Structure
============================================================================== =======================*/
void PIDInit (PID *pp)
{
memset ( pp,0,sizeof(PID));
}
/*============================================================================ ========================
Main Program
============================================================================== =======================*
double sensor (void) // Dummy Sensor Function
{
return 100.0;
}
void actuator(double rDelta) // Dummy Actuator Function
{}
void main(void)
{
PID sPID; // PID Control Structure
double rOut; // PID Response (Output)
double rIn; // PID Feedback (Input)
PIDInit ( &sPID ); // Initialize Structure
sPID.Proportion = 0.5; // Set PID Coefficients
sPID.Integral = 0.5;
sPID.Derivative = 0.0;
sPID.SetPoint = 100.0; // Set PID Setpoint
for (;;) { // Mock Up of PID Processing
rIn = sensor (); // Read Input
rOut = PIDCalc ( &sPID,rIn ); // Perform PID Interation
actuator ( rOut ); // Effect Needed Changes
}
（此文档部分内容来源于网络，如有侵权请告知删除，文档可自行编辑修改内容，
供参考，感谢您的配合和支持）。