用纯C语言分别实现增量式与位置式的PID自整定算法

这篇具有很好参考价值的文章主要介绍了用纯C语言分别实现增量式与位置式的PID自整定算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1、对于增量式PID自整定算法,C语言代码如下:

#include <stdio.h>

#define SAMPLE_TIME 0.1     // 采样时间
#define KP_DEFAULT 0.5      // 比例系数默认值
#define KI_DEFAULT 0.2      // 积分系数默认值
#define KD_DEFAULT 0.1      // 微分系数默认值
#define TAU_DEFAULT 10.0    // 积分时间常数默认值
#define N_DEFAULT 10.0      // 微分时间常数默认值

// PID自整定函数
void pid_auto_tune(double* kp, double* ki, double* kd, double* tau, double* n, double* process_value, double* setpoint) {
    double delta = 0.1;     // 步进大小
    double tolerance = 0.1; // 容忍度
    double prev_error = 0;  // 上一次误差
    double integral = 0;    // 积分项
    double derivative = 0;  // 微分项
    double output;          // 控制器输出
    double overshoot;       // 超调量
    double process_value1, process_value2, process_value3;
    
    // 初始化参数
    *kp = KP_DEFAULT;
    *ki = KI_DEFAULT;
    *kd = KD_DEFAULT;
    *tau = TAU_DEFAULT;
    *n = N_DEFAULT;

    // 开始自整定
    while (1) {
        // 增加比例系数
        *kp += delta;
        // 计算控制器输出
        output = *kp * (*setpoint - *process_value);
        // 计算误差
        double error = *setpoint - *process_value;
        // 计算积分项
        integral += error * SAMPLE_TIME;
        // 计算微分项
        derivative = (error - prev_error) / SAMPLE_TIME;
        prev_error = error;
        // 计算控制器输出
        output = *kp * error + *ki * integral + *kd * derivative;
        // 更新过程值
        process_value3 = process_value2;
        process_value2 = process_value1;
        process_value1 = *process_value;
        *process_value += output;
        // 计算超调量
        overshoot = (*process_value1 - *setpoint) / (*setpoint - *process_value2);
        // 判断是否达到稳态
        if (overshoot > 1 + tolerance) {
            *kp -= 2 * delta;
            break;
        }
    }

    // 重新开始自整定
    while (1) {
        // 增加积分时间常数
        *tau += delta;
        // 增加微分时间常数
        *n += delta;
        // 计算控制器输出
        output = (*kp * (*setpoint - *process_value)
            + *ki * (1 + *tau / SAMPLE_TIME) * integral
            - *kd * *n / (*tau + SAMPLE_TIME) * derivative);
        // 更新过程值
        process_value3 = process_value2;
        process_value2 = process_value1;
        process_value1 = *process_value;
        *process_value += output;

        // 计算超调量
        overshoot = (*process_value1 - *setpoint) / (*setpoint - *process_value2);
        // 判断是否达到稳态
        if (overshoot > 1 + tolerance) {
                *tau -= 2 * delta;
                break;
        }
    }

    // 计算微分系数
    *kd = *tau * *kp / (*n * SAMPLE_TIME);
}

int main() {
    double kp, ki, kd, tau, n, process_value, setpoint;
    // 初始化过程值和设定值
    process_value = 0;
    setpoint = 1;

    // 进行自整定
    pid_auto_tune(&kp, &ki, &kd, &tau, &n, &process_value, &setpoint);

    // 输出结果
    printf("kp = %lf\n", kp);
    printf("ki = %lf\n", ki);
    printf("kd = %lf\n", kd);

    return 0;
}

2、位置式PID控制是一种常用的控制方法,可以实现给定值与实际值之间的闭环控制。下面是使用C语言编写的一个位置式PID自整定算法的代码,包含详细的注释:

#include <stdio.h>

// 位置式PID自整定算法
float position_pid_autotune(float (*process_variable)(float), void (*control_variable)(float), float setpoint) {
    float kp = 0, ki = 0, kd = 0; // 初始化PID系数
    float error = 0, last_error = 0, sum_error = 0; // 初始化误差和变量
    float output = 0; // 初始化控制输出

    // 自整定过程
    for (int i = 0; i < 1000; i++) {
        float pv = process_variable(setpoint); // 获取当前过程变量
        error = setpoint - pv; // 计算当前误差
        sum_error += error; // 累计误差
        float d_error = error - last_error; // 计算误差变化率
        last_error = error; // 更新上一次误差

        // 更新PID系数
        kp += 0.1 * error;
        ki += 0.0001 * sum_error;
        kd += 0.01 * d_error;

        // 计算控制输出
        output = kp * error + ki * sum_error + kd * d_error;
        control_variable(output);
    }

    // 返回得到的PID系数中的Kp值
    return kp;
}

// 过程变量函数
float process_variable(float setpoint) {
    // 这里模拟获取实际值,返回一个随机数
    return (float)rand() / RAND_MAX * setpoint;
}

// 控制变量函数
void control_variable(float output) {
    // 这里模拟控制输出,输出结果打印在控制台上
    printf("Output: %f\n", output);
}

int main() {
    float setpoint = 50.0; // 设定值
    float kp = position_pid_autotune(process_variable, control_variable, setpoint); // 自整定,得到Kp系数
    printf("Kp: %f\n", kp); // 输出得到的Kp系数
    return 0;
}

这个代码实现了一个位置式PID自整定算法,它包括了两个函数process_variablecontrol_variable,分别模拟了获取实际值和控制输出的过程。在position_pid_autotune函数中,首先初始化了PID系数,误差和输出等变量。接着使用一个循环,对于设定值,获取当前的实际值,计算当前的误差,累计误差,计算误差变化率,更新PID系数,计算控制输出,并调用control_variable函数进行控制输出。

在自整定过程中,我们通过不断更新Kp系数,使得误差能够快速收敛到0,从而得到一个适合当前系统的PID.

3、下面是另一个版本的位置式PID自整定算法,实现方式略有不同,但同样包含详细的注释。

#include <stdio.h>

// 位置式PID自整定算法
float position_pid_autotune(float (*process_variable)(void), void (*control_variable)(float), float setpoint) {
    float kp = 0, ki = 0, kd = 0; // 初始化PID系数
    float error = 0, last_error = 0, sum_error = 0; // 初始化误差和变量
    float output = 0; // 初始化控制输出
    float delta_t = 0.1; // 控制时间步长
    float tolerance = 0.1; // 允许的误差范围
    int iterations = 0; // 循环次数

    // 执行自整定过程
    while (1) {
        float pv = process_variable(); // 获取当前过程变量
        error = setpoint - pv; // 计算当前误差
        sum_error += error; // 累计误差
        float d_error = (error - last_error) / delta_t; // 计算误差变化率
        last_error = error; // 更新上一次误差

        // 更新PID系数
        kp += 0.1 * error;
        ki += 0.01 * sum_error;
        kd += 0.01 * d_error;

        // 计算控制输出
        output = kp * error + ki * sum_error + kd * d_error;
        control_variable(output);

        // 检查是否满足误差范围,如果满足则跳出循环
        if (error < tolerance && error > -tolerance) {
            break;
        }

        iterations++; // 增加循环次数
        if (iterations >= 1000) { // 如果循环次数超过1000,跳出循环
            break;
        }
    }

    // 返回得到的PID系数中的Kp值
    return kp;
}

// 过程变量函数
float process_variable() {
    // 这里模拟获取实际值,返回一个随机数
    return (float)rand() / RAND_MAX * 100.0;
}

// 控制变量函数
void control_variable(float output) {
    // 这里模拟控制输出,输出结果打印在控制台上
    printf("Output: %f\n", output);
}

int main() {
    float setpoint = 50.0; // 设定值
    float kp = position_pid_autotune(process_variable, control_variable, setpoint); // 自整定,得到Kp系数
    printf("Kp: %f\n", kp); // 输出得到的Kp系数
    return 0;
}

这个代码实现了一个类似的位置式PID自整定算法,它同样包括了process_variablecontrol_variable函数,以及自整定过程中使用的PID系数、误差和输出等变量。不同之处在于,这个算法使用了一个while循环,而不是for.

4、自整定PID算法示例四:

自整定PID算法通常需要一些特定的步骤来自动调整PID参数。下面是一个简单的例子,展示如何使用Ziegler-Nichols方法进行自整定。请注意,这只是一个基本的实现,实际应用中可能需要更复杂的自整定算法和参数整定方法。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct {
    float Kp;      // 比例系数
    float Ki;      // 积分系数
    float Kd;      // 微分系数

    float setpoint; // 设定值
    float prev_error; // 上一次误差
    float integral;  // 积分项
} PIDController;

void initPID(PIDController *pid, float Kp, float Ki, float Kd, float setpoint) {
    pid->Kp = Kp;
    pid->Ki = Ki;
    pid->Kd = Kd;
    pid->setpoint = setpoint;
    pid->prev_error = 0.0;
    pid->integral = 0.0;
}

float calculatePID(PIDController *pid, float current_value) {
    float error = pid->setpoint - current_value;
    pid->integral += error;

    // PID计算
    float output = pid->Kp * error + pid->Ki * pid->integral + pid->Kd * (error - pid->prev_error);

    pid->prev_error = error;

    return output;
}

void autotunePID(PIDController *pid, float (*processFunction)(float)) {
    // Ziegler-Nichols自整定方法
    printf("Running Ziegler-Nichols autotuning...\n");

    float Ku = 0.0; // 临界增益
    float Tu = 0.0; // 临界周期

    // 找到临界增益和临界周期
    printf("Measuring ultimate gain...\n");
    while (1) {
        // 使用一定的输入来激励系统,并测量输出
        // 这里需要根据具体的系统来实现processFunction
        float output = processFunction(10.0);

        // 判断是否出现了振荡
        if (output > 90.0 && Ku == 0.0) {
            Ku = 10.0 / output; // 计算临界增益
            printf("Ultimate Gain (Ku): %f\n", Ku);
            break;
        }

        // 延时,等待系统稳定
        // 这里需要根据具体的系统来实现延时
    }

    // 计算临界周期
    printf("Measuring ultimate period...\n");
    while (1) {
        // 使用一定的输入来激励系统,并测量输出
        // 这里需要根据具体的系统来实现processFunction
        float output = processFunction(10.0);

        // 判断是否出现了振荡
        if (output < 10.0) {
            // 计算临界周期
            // 这里需要根据具体的系统来实现计算
            printf("Ultimate Period (Tu): %f\n", Tu);
            break;
        }

        // 延时,等待系统稳定
        // 这里需要根据具体的系统来实现延时
    }

    // 根据Ziegler-Nichols方法计算PID参数
    pid->Kp = 0.6 * Ku;
    pid->Ki = 2.0 * pid->Kp / Tu;
    pid->Kd = pid->Kp * Tu / 8.0;

    printf("Tuned PID parameters: Kp=%f, Ki=%f, Kd=%f\n", pid->Kp, pid->Ki, pid->Kd);
}

// 模拟系统的过程函数
float simulatedProcessFunction(float input) {
    // 这里是一个简单的例子,模拟系统的响应
    // 实际应用中,这个函数应该根据系统的物理特性来实现
    static float state = 0.0;
    state += input;
    return state;
}

int main() {
    // 初始化PID控制器
    PIDController pid;
    initPID(&pid, 0.0, 0.0, 0.0, 50.0); // 初始参数可以是0,因为后面会进行自整定

    // 运行自整定过程
    autotunePID(&pid, simulatedProcessFunction);

    // 在实际应用中,你将使用调整后的PID参数进行控制
    // 这里的例子中,我们仍然使用初始的PID参数来演示PID控制过程
    float target_temperature = 100.0;

    // 主循环
    for (int i = 0; i < 100; ++i) {
        // 模拟获取当前温度值
        float current_temperature = simulatedProcessFunction(pid.setpoint);

        // 使用PID计算PWM输出
        float pid_output = calculatePID(&pid, current_temperature);

        // 输出PID控制的PWM值
        printf("PWM Output: %f\n", pid_output);

        // 等待一段时间,模拟系统响应
        // 这里需要根据具体的系统来实现延时
    }

    return 0;
}

上述代码中,autotunePID 函数使用 Ziegler-Nichols 方法来自动调整 PID 参数。请注意,这个例子是一个简单的模拟,并非真实的物理系统。在实际应用中,你需要根据你的系统特性来实现 processFunction 函数,以及延时函数等。自整定过程需要小心进行,确保在实际系统中不会引起不稳定。文章来源地址https://www.toymoban.com/news/detail-555481.html

到了这里,关于用纯C语言分别实现增量式与位置式的PID自整定算法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 位置式Pid和增量式Pid的定义及应用

    PID算法是一个典型的闭环控制系统。P、I、D,比例、积分、微分。 开环:输入量对输出量没有反馈作用; 闭环:输入量对输出量有反馈作用。 位置式Pid 位置式Pid就是位置闭环控制,位置闭环控制就是根据编码器的脉冲累加,测量电机的位置信息,并与目标值进行比较得到一

    2024年02月05日
    浏览(40)
  • PID算法(位置式pid算法和增量式pid算法)

    PID 算法是闭环控制系统中常用的算法,PID 分别是 Proportion(比例)、Integral(积分)、 Differential(微分)的首字母缩写。它是一种结合比例、积分和微分三个环节于一体的闭环控 制算法,具体的控制流程如图 8.2.1 所示: u = Kp * e u ----- 输出 Kp ----- 比例系数 e ----- 偏差 以温度

    2024年02月16日
    浏览(53)
  • 【PID】基于Matlab实现增量式PID算法

    ✅作者简介:热爱科研的Matlab仿真开发者,修心和技术同步精进,matlab项目合作可私信。 🍎个人主页:Matlab科研工作室 🍊个人信条:格物致知。 增量式PID控制较常规PID更具优势,但有关其参数整定的方法很少,针对这种问题,介绍了增量式PID算法的原理及特点,基于MATLAB平台

    2024年02月14日
    浏览(40)
  • 4 OpenCV实现多目三维重建(多张图片增量式生成稀疏点云)【附源码】

    本文是基于 OpenCV4.80 进行的,关于环境的配置可能之后会单独说,先提一嘴 vcpkg 真好用 从多张图片逐步生成稀疏点云,这个过程通常包括以下步骤: 初始重建: 初始两张图片的选择 十分重要 ,这是整个流程的基础,后续的增图都是在这两张图片的基础上进行的 对于输入图

    2024年02月06日
    浏览(43)
  • STM32之增量式编码器电机测速

    编码器,是一种用来测量机械旋转或位移的传感器。它能够测量机械部件在旋转或直线运动时的位移位置或速度等信息,并将其转换成一系列电信号。 . 按监测原理分类 光电编码器 光电编码器,是一种通过光电转换将输出轴上的机械几何位移量转换成脉冲或数字量的传感器

    2024年02月13日
    浏览(36)
  • 霍尔增量式编码器左右车轮线速度的计算

    对于霍尔式编码器的左右轮线速度计算: 首先线速度=距离s / 时间 t 要获得距离S ,也就是轮子在一段时间内跑过的距离。要先知道一下两个参数: 1.轮子的半径 r 2.轮子转动一圈的脉冲数 cnt 轮子转动一圈的脉冲数:如电机我们选用减速比为1:90的TT直流减速电机,编码器为

    2024年02月15日
    浏览(38)
  • STM32增量式pid直流电机调速(内附源码)

            目录 一. 1.硬件组成 2.模块分析         1.TB6612电机驱动模块         2.直流减速电机         3.电源稳压模块 二.接线 三.代码思路讲解(详见源码) 四.STM32cubmx配置 1.系统基础配置:(重要) 2.电机旋转方向引脚配置 3.TIM1每10ms触发一次的定时器中断 4.TI

    2024年02月16日
    浏览(36)
  • 《LIO-SAM阅读笔记》-为何要引入增量式里程计?

    前言: LIO-SAM在后端中同时维护着两个里程计,一个是增量式里程计,一个是优化后的里程计,其中优化后的里程计是经过imu、回环、gps因子图联合优化后的结果,是整个系统中最准确的位姿估计,那么为什么还需要维护增量式里程计呢? 以下是我的理解 ,不一定正确,如有

    2024年01月22日
    浏览(45)
  • 博途PLC增量式PID和脉冲轴组合控制阀门开度(算法介绍)

    这篇博客我们以S7-1200PLC平台来举例,介绍我们的PID闭环控制器如何控制脉冲轴实现阀门角度控制。SMART PLC PID控制器控制伺服驱动器实现关节角度控制详细内容请参考下面文章: https://rxxw-control.blog.csdn.net/article/details/129658364 https://rxxw-control.blog.csdn.net/article/details/129658364 增量

    2024年01月21日
    浏览(78)
  • 用纯C语言实现3D空间中的点坐标转化为屏幕二维点坐标,包含主视图、侧视图、俯视图、正等轴投影

    要实现3D空间中的点坐标转换为屏幕二维点坐标,需要进行透视变换和投影变换。以下是一些基本的思路和示例代码,可以用于实现主视图、侧视图、俯视图、正等轴投影。 1. 主视图投影 主视图投影是指以一个点作为视点,从一个方向观察物体,投影到一个平面上。通常情况

    2024年02月04日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包