Adaptive PID Controller For DC Motor Speed Control

I am developing a program to control the speed of a DC motor using an adaptive PID controller. As I am just getting started with this type of control, I would greatly appreciate it if anyone could share code, algorithms for simulation, or practical implementation examples of such a controller for my reference

[Sam Chak]

Hi @Mnh

Could you share the code for the DC motor model and the PID controller without the adaptive feature? The adaptive feature is not necessary to determine to what extent the motor can maintain its performance.

Answer 1

[Mathieu NOE]

hello

maybe this ?

clc
clearvars

% To control the speed of a DC motor using an adaptive PID controller in MATLAB, you can follow these steps. Below is an example implementation:
% 
% Step 1: Define the DC Motor Model
% The DC motor can be modeled using its transfer function or state-space representation. For simplicity, we use a transfer function:
% 
% ( J ): Moment of inertia
% ( b ): Damping coefficient
% ( K ): Motor constant
% ( R ): Resistance
% ( L ): Inductance



% Step 2: Implement Adaptive PID Controller
% An adaptive PID controller adjusts its parameters ((K_p), (K_i), (K_d)) dynamically based on system performance.
% Parameters of the DC motor
J = 0.01;  % Moment of inertia
b = 0.1;   % Damping coefficient
K = 0.01;  % Motor constant
R = 1;     % Resistance
L = 0.5;   % Inductance

% Simulation parameters
dt = 0.01;
t = 0:dt:3;  % Time vector

% Transfer function of the DC motor
num = K;
den = [(J*L) (J*R + L*b) (b*R + K^2)];
motor_tf = tf(num, den);
% discretization 
[B,A] = c2dm(num,den,dt,'tustin');


% Initial PID parameters
Kpi = 100; Kii = 500; Kdi = 10;


%% init 
desired_speed = 100;  % Desired motor speed (rad/s)
actual_speed(1) = 0;  % Initial speed


%% Adaptive PID control loop
% 1st sample 
    error(1) = desired_speed - 0 ;  % Calculate error
    error_int(1) = 0; % Calculate integral of error
    error_der(1) = 0;% Calculate derivative of error
    % PID controller output
    u(1) = Kpi*error(1) + Kii*error_int(1) + Kdi*error_der(1);
    % Simulate motor response
    actual_speed(1) = B(1)*u(1);

% 2nd sample 
    error(2) = desired_speed - actual_speed(1);  % Calculate error
    error_int(2) = error_int(1) + 0.5*(error(2)+0)*dt; % Calculate integral of error
    error_der(2) = (error(2)-error(1))/dt;% Calculate derivative of error
    % PID controller output
    u(2) = Kpi*error(2) + Kii*error_int(2) + Kdi*error_der(2);
    % Simulate motor response
    actual_speed(1) = B(1)*u(1);
    actual_speed(2) = B(1)*u(2) + B(2)*u(1) + 0 - (A(2)*actual_speed(1) + 0 );

% 3rd sample and after 
for i = 3:length(t)
    error(i) = desired_speed - actual_speed(i-1);  % Calculate error
    error_int(i) = error_int(i-1) + 0.5*(error(i)+error(i-1))*dt; % Calculate integral of error
    error_der(i) = (error(i)-error(i-1))/dt;% Calculate derivative of error

    % Adaptive PID tuning 
    Kp = Kpi + 1*abs(error(i));
    Ki = Kii + 1*abs(error(i));
    Kd = Kdi + 0.01*abs(error(i));

    % PID controller output
    u(i) = Kp*error(i) + Ki*error_int(i) + Kd*error_der(i);
    
    % Simulate motor response
    actual_speed(i) = B(1)*u(i) + B(2)*u(i-1) + B(3)*u(i-2) - (A(2)*actual_speed(i-1) + A(3)*actual_speed(i-2));
end

%% Plot results
figure;
plot(t, actual_speed, 'b', 'LineWidth', 1.5); hold on;
yline(desired_speed, 'r--', 'LineWidth', 1.5);
xlabel('Time (s)');
ylabel('Motor Speed (rad/s)');
title('Adaptive PID Control of DC Motor');
legend('Actual Speed', 'Desired Speed');
grid on;

●

[Mathieu NOE]

same code , but a better adaptative PID regulator :

% To control the speed of a DC motor using an adaptive PID controller in MATLAB, you can follow these steps. Below is an example implementation:
% 
% Step 1: Define the DC Motor Model
% The DC motor can be modeled using its transfer function or state-space representation. For simplicity, we use a transfer function:
% 
% ( J ): Moment of inertia
% ( b ): Damping coefficient
% ( K ): Motor constant
% ( R ): Resistance
% ( L ): Inductance



% Step 2: Implement Adaptive PID Controller
% An adaptive PID controller adjusts its parameters ((K_p), (K_i), (K_d)) dynamically based on system performance.
% Parameters of the DC motor
J = 0.01;  % Moment of inertia
b = 0.1;   % Damping coefficient
K = 0.01;  % Motor constant
R = 1;     % Resistance
L = 0.5;   % Inductance

% Simulation parameters
dt = 0.01;
t = 0:dt:1;  % Time vector

% Transfer function of the DC motor
num = K;
den = [(J*L) (J*R + L*b) (b*R + K^2)];
motor_tf = tf(num, den);
% discretization 
[B,A] = c2dm(num,den,dt,'tustin');


% Initial PID parameters
Kpi = 200; Kii = 200; Kdi = 10;


%% init 
desired_speed = 100;  % Desired motor speed (rad/s)
actual_speed(1) = 0;  % Initial speed


%% Adaptive PID control loop
% 1st sample 
    error(1) = desired_speed - 0 ;  % Calculate error
    error_int(1) = 0;
    error_der(1) = 0;
    % PID controller output
    u(1) = Kpi*error(1) + Kii*error_int(1) + Kdi*error_der(1);
    % Simulate motor response
    actual_speed(1) = B(1)*u(1);

% 2nd sample 
    error(2) = desired_speed - actual_speed(1);  % Calculate error
    error_int(2) = error_int(1) + 0.5*(error(2)+0)*dt;
    error_der(2) = (error(2)-error(1))/dt;
    % PID controller output
    u(2) = Kpi*error(2) + Kii*error_int(2) + Kdi*error_der(2);
    % Simulate motor response
    actual_speed(1) = B(1)*u(1);
    actual_speed(2) = B(1)*u(2) + B(2)*u(1) + 0 - (A(2)*actual_speed(1) + 0 );

% 3rd sample and after 
for i = 3:length(t)
    error(i) = desired_speed - actual_speed(i-1);  % Calculate error
    error_int(i) = error_int(i-1) + 0.5*(error(i)+error(i-1))*dt; % Calculate integral of error
    error_der(i) = (error(i)-error(i-1))/dt;% Calculate derivative of error

    % Adaptive PID tuning 
    Kp = Kpi + 1*abs(error(i));
    Ki = Kii + 1*abs(error(i));
    Kd = Kdi + 0.01*abs(error(i));

    % PID controller output
    u(i) = Kp*error(i) + Ki*error_int(i) + Kd*error_der(i);
    
    % Simulate motor response
    actual_speed(i) = B(1)*u(i) + B(2)*u(i-1) + B(3)*u(i-2) - (A(2)*actual_speed(i-1) + A(3)*actual_speed(i-2));
end

%% Plot results
figure;
plot(t, actual_speed, 'b', 'LineWidth', 1.5); hold on;
yline(desired_speed, 'r--', 'LineWidth', 1.5);
xlabel('Time (s)');
ylabel('Motor Speed (rad/s)');
title('Adaptive PID Control of DC Motor');
legend('Actual Speed', 'Desired Speed');
grid on;

●

[Sam Chak]

Hi @Mathieu NOE

Thank you for sharing the code. While the proposed PID controller, which uses static equations to update the proportional, integral, and derivative gains based on the error state, can be considered a form of adaptive control, it may not fit the strictest definitions that involve dynamic learning or model identification. In fact, it is much closer to a nonlinear PID controller.

e   = linspace(-1, 1, 201);
Kp  = 1;                % proportional gain
uP  = Kp*e;             % linear controller
uPn = Kp*abs(e).*e;     % nonlinear controller

figure(1)
hold on
plot(e, uP)
plot(e, uPn)
grid on
hold off
xlabel({'Error, $e$'}, 'interpreter', 'latex')
ylabel({'Control action, $u_{P}$'}, 'interpreter', 'latex')
title({'Proportional Control action, $u_{P}$'}, 'interpreter', 'latex')
legend('Linear control', 'Nonlinear control', 'location', 'northwest')

●

figure(2)
hold on
plot(e, Kp*ones(1, numel(e)))
plot(e, Kp*abs(e))
grid on
hold off
ylim([-0.5, 1.5])
xlabel({'Error, $e$'}, 'interpreter', 'latex')
ylabel({'Control gain, $K_{p}$'}, 'interpreter', 'latex')
title({'Proportional Gain, $K_{p}$'}, 'interpreter', 'latex')
legend('Constant gain', 'Varying gain', 'location', 'north')

[Mathieu NOE]

sure

that was just a starting point... the code I provided ca, be further enhanced.

I think on point that usually poses problem to people is how to implement the recursive equation of the discretized plant.

all of this could be also done more efficiently with simulink IMHO

[Sam Chak]

Hi @Mathieu NOE

The OP can benefit from your code by learning how the P, I, D gains can be easily adjusted based on static equations.

[Mathieu NOE]

yeap , that was the purpose indeed !

[Sam Chak]

+1 👍

[Mathieu NOE]

tx !