当前位置：首页 > 云服务器 > 正文

如何用C语言实现PID算法？BP神经网络编程应用全解析

admin
云服务器
2026-02-14
3611

#include <stdio.h> #include <stdlib.h> #include <math.h> #include <time.h> // PID 控制器结构体 typedef struct { double Kp, Ki, Kd; // PID参数 double integral; // 积分项 double prev_error; // 上一次误差 } PIDController; // 神经网络层结构 typedef struct { int num_nodes; // 节点数量 double *outputs; // 输出值 double *errors; // 误差项 } NeuralLayer; // BP神经网络结构 typedef struct { NeuralLayer input_layer; NeuralLayer hidden_layer; NeuralLayer output_layer; double **w_ih; // 输入层到隐藏层权重 double **w_ho; // 隐藏层到输出层权重 double learning_rate; // 学习率 } BPNeuralNetwork; // 初始化PID控制器 void initPID(PIDController *pid, double Kp, double Ki, double Kd) { pid->Kp = Kp; pid->Ki = Ki; pid->Kd = Kd; pid->integral = 0.0; pid->prev_error = 0.0; } // PID控制计算 double computePID(PIDController *pid, double setpoint, double actual, double dt) { double error = setpoint - actual; pid->integral += error * dt; double derivative = (error - pid->prev_error) / dt; pid->prev_error = error; return pid->Kp * error + pid->Ki * pid->integral + pid->Kd * derivative; } // 初始化神经网络层 void initLayer(NeuralLayer *layer, int num_nodes) { layer->num_nodes = num_nodes; layer->outputs = (double *)malloc(num_nodes * sizeof(double)); layer->errors = (double *)malloc(num_nodes * sizeof(double)); } // 初始化BP神经网络 void initBPNN(BPNeuralNetwork *nn, int input_nodes, int hidden_nodes, int output_nodes, double lr) { // 初始化各层 initLayer(&nn->input_layer, input_nodes); initLayer(&nn->hidden_layer, hidden_nodes); initLayer(&nn->output_layer, output_nodes); nn->learning_rate = lr; // 分配权重内存 nn->w_ih = (double **)malloc(input_nodes * sizeof(double *)); nn->w_ho = (double **)malloc(hidden_nodes * sizeof(double *)); // 初始化权重（随机小值） srand(time(NULL)); for (int i = 0; i < input_nodes; i++) { nn->w_ih[i] = (double *)malloc(hidden_nodes * sizeof(double)); for (int j = 0; j < hidden_nodes; j++) { nn->w_ih[i][j] = (rand() % 100) / 100.0 * 0.2 - 0.1; // [-0.1, 0.1] } } for (int i = 0; i < hidden_nodes; i++) { nn->w_ho[i] = (double *)malloc(output_nodes * sizeof(double)); for (int j = 0; j < output_nodes; j++) { nn->w_ho[i][j] = (rand() % 100) / 100.0 * 0.2 - 0.1; } } } // Sigmoid激活函数 double sigmoid(double x) { return 1.0 / (1.0 + exp(-x)); } // Sigmoid导数 double sigmoidDerivative(double x) { return x * (1.0 - x); } // 神经网络前向传播 void forwardPropagation(BPNeuralNetwork *nn, double *inputs) { // 设置输入层输出 for (int i = 0; i < nn->input_layer.num_nodes; i++) { nn->input_layer.outputs[i] = inputs[i]; } // 计算隐藏层输出 for (int j = 0; j < nn->hidden_layer.num_nodes; j++) { double sum = 0.0; for (int i = 0; i < nn->input_layer.num_nodes; i++) { sum += nn->input_layer.outputs[i] * nn->w_ih[i][j]; } nn->hidden_layer.outputs[j] = sigmoid(sum); } // 计算输出层输出 for (int k = 0; k < nn->output_layer.num_nodes; k++) { double sum = 0.0; for (int j = 0; j < nn->hidden_layer.num_nodes; j++) { sum += nn->hidden_layer.outputs[j] * nn->w_ho[j][k]; } nn->output_layer.outputs[k] = sigmoid(sum); } } // 神经网络反向传播 void backwardPropagation(BPNeuralNetwork *nn, double *targets) { // 计算输出层误差 for (int k = 0; k < nn->output_layer.num_nodes; k++) { double output = nn->output_layer.outputs[k]; nn->output_layer.errors[k] = (targets[k] - output) * sigmoidDerivative(output); } // 计算隐藏层误差 for (int j = 0; j < nn->hidden_layer.num_nodes; j++) { double sum = 0.0; for (int k = 0; k < nn->output_layer.num_nodes; k++) { sum += nn->output_layer.errors[k] * nn->w_ho[j][k]; } nn->hidden_layer.errors[j] = sum * sigmoidDerivative(nn->hidden_layer.outputs[j]); } // 更新隐藏层到输出层权重 for (int j = 0; j < nn->hidden_layer.num_nodes; j++) { for (int k = 0; k < nn->output_layer.num_nodes; k++) { nn->w_ho[j][k] += nn->learning_rate * nn->output_layer.errors[k] * nn->hidden_layer.outputs[j]; } } // 更新输入层到隐藏层权重 for (int i = 0; i < nn->input_layer.num_nodes; i++) { for (int j = 0; j < nn->hidden_layer.num_nodes; j++) { nn->w_ih[i][j] += nn->learning_rate * nn->hidden_layer.errors[j] * nn->input_layer.outputs[i]; } } } // 使用神经网络调整PID参数 void adjustPIDWithNN(BPNeuralNetwork *nn, PIDController *pid, double error, double dt) { // 准备输入: 归一化的误差、积分、微分 double inputs[3] = { error / 10.0, // 假设误差范围在[-10,10] pid->integral / 100.0, (error - pid->prev_error) / dt / 10.0 }; // 前向传播获取PID调整量 forwardPropagation(nn, inputs); // 输出层对应Kp, Ki, Kd的调整量（范围0.5~2.0倍） double k_adjust[3]; for (int i = 0; i < 3; i++) { k_adjust[i] = 0.5 + 1.5 * nn->output_layer.outputs[i]; // 映射到[0.5, 2.0] } // 应用调整 pid->Kp *= k_adjust[0]; pid->Ki *= k_adjust[1]; pid->Kd *= k_adjust[2]; } // 训练神经网络（简化示例） void trainNN(BPNeuralNetwork *nn, double actual, double setpoint, double dt) { double error = setpoint - actual; double targets[3] = {1.0, 1.0, 1.0}; // 理想调整量为1（不调整） // 当误差较大时需要调整 if (fabs(error) > 0.5) { targets[0] = (error > 0) ? 1.2 : 0.8; // 根据误差方向调整 } // 准备输入 double inputs[3] = { error / 10.0, 0, // 简化示例 (error - 0) / dt / 10.0 // 简化示例 }; forwardPropagation(nn, inputs); backwardPropagation(nn, targets); } // 模拟被控对象（一阶惯性系统） double plantModel(double input, double *state) { *state = 0.9 * (*state) + 0.1 * input; return *state; } int main() { PIDController pid; BPNeuralNetwork nn; double setpoint = 5.0; // 目标值 double actual = 0.0; // 实际值 double control; // 控制量 double plant_state = 0.0;// 被控对象状态 const double dt = 0.1; // 控制周期 // 初始化PID和神经网络 initPID(&pid, 0.5, 0.1, 0.01); initBPNN(&nn, 3, 4, 3, 0.1); // 3输入, 4隐藏节点, 3输出 // 控制循环 for (int step = 0; step < 200; step++) { // 计算控制量 control = computePID(&pid, setpoint, actual, dt); // 应用控制量到被控对象 actual = plantModel(control, &plant_state); // 每10步调整一次PID参数 if (step % 10 == 0) { double error = setpoint - actual; adjustPIDWithNN(&nn, &pid, error, dt); } // 每5步训练一次神经网络（简化） if (step % 5 == 0) { trainNN(&nn, actual, setpoint, dt); } // 打印结果 printf("Step %d: Setpoint=%.2f, Actual=%.4f, Control=%.4fn", step, setpoint, actual, control); } return 0; }

代码说明：

PID控制器：
- 实现标准位置式PID算法
- 包含积分项累积和微分项计算
BP神经网络：
- 3层结构（输入层3节点、隐藏层4节点、输出层3节点）
- 输入：归一化的误差、积分项、微分项
- 输出：PID三个参数的调整系数
- 使用Sigmoid激活函数
自适应控制流程：
- 每10步使用神经网络调整PID参数
- 神经网络输出将PID参数缩放至[0.5, 2.0]倍范围
- 每5步用当前误差训练神经网络
被控对象模型：
- 简化的一阶惯性系统：y(k) = 0.9y(k-1) + 0.1u(k)