Encoder values for PID control

Question

I'm working on a two-wheeled robot and I'm trying to implement a PID control for the motors. But I have a problem, all sources I found online said I have to calculate the error with my encoder values.

For the robot I'm programming I got 2 functions. One that gets the absolute encoder values and one that gets the speed in ticks/s.

The sources I found didn't specify if I use absolute encoder values or the speed encoder values. I tried both already but it didn't work out too well, so I would like to know if some already have some experience with a motor PID control using the encoders.

This is my PID code I wanted to use:

e_func_r = v_des-v_act_r;

r_mot_r = r_old_r
    + (1/K_P)*(e_func_r-e_old_r) 
    + K_I*(e_func_r+e_old_r)/2
    + K_D*(e_func_r-2*e_old_r+e_old2_r);

if(r_mot_r >= 100)
{
    r_mot_r = 100;
}
if(r_mot_r <= -100)
{
    r_mot_r = 100;
}

r_old_r  = r_mot_r;
e_old2_r = e_old_r;
e_old_r  = e_func_r;

Answer 1

The "PID code" you have is not a PID controller. At all. You should have error terms defined as:

error = setpoint - feedback; // Setpoint and feedback should be in the same units.
deltaTime = TimeSinceLastCall(); // Platform/language specific. 

proportionalError = error;
integralError = integralError + error*deltaTime;
derivativeError = (error-prevError)/deltaTime;
prevError = error;

controlSignal = (kP*proportionalError) + (kI*integralError) + (kD*derivativeError);

That's a PID controller. I'm not going to go through the code that you posted point-by-point because it's very wrong, to the point that I can't understand how it was intended to work, so I don't really have a rebuttal or explanation to try to help point out where it went wrong. If you want a PID controller, use the error terms as I provided above.

Also, with the original code, the motor control signal is always accumulating. It shouldn't do this, it should instead just be the output of the PID controller. You have:

r_mot_r = r_old_r + <controller output>

when it should just be

r_mot_r = <controller output>

as in:

r_mot_r = controlSignal

where controlSignal is the term I defined in the block of code at the top of this post.

I'll point out that two-wheeled vehicles are non-holonomic platforms, which means you can't just position the actuators (wheels) independently and arrive at a given position and orientation. Going forward 10 blocks and then turning left is not the same as turning left and then going forward 10 blocks! You are going to find that your robot will never go straight without having some kind of absolute position feedback. Wheel encoder feedback is okay for (very) short term, but you will experience drift.

Answer 2

Looking at the code in Embedded Robotics by Thomas Bräunl, DOI: 10.1.1.474.8129 this appears to be an 'optimised' (i.e. difficult to follow) version of an integer PID controller for velocity control.

It sounds like you want control position rather than velocity though, so you need a position PID controller, as described by Chuck♦, which is more directly applicable to your problem and easier to understand.

If you do want a velocity controller however, read on...

---

The code in question is on page 93, Program 5.7: PID controller code:

static int r_old=0, e_old=0, e_old2=0;
...
e_func = v_des - v_act;    /* error in velocity */
r_mot  = r_old + Kp*(e_func-e_old) + Ki*(e_func+e_old)/2
               + Kd*(e_func - 2* e_old + e_old2);
                           /* motor output */
r_mot = min(r_mot, +100);  /* limit motor output */
r_mot = max(r_mot, -100);  /* limit motor output */
r_old  = r_mot;            /* store this motor output */
e_old2 = e_old;            /* store last velocity error */
e_old  = e_func;           /* store this velocity error */

In this snippet I've restored the static line (which is important as it shows this is an integer controller and not a floating point controller), left the original max functions in place, as they are easier to understand, and added comments.

In this code, the v_des is the desired velocity per controller period, the v_act is the current actual velocity per controller period.

Your changes appear to be:

• The addition of the _r suffix (presumably to designate the right motor, and I assume there is similar code for the left motor)
• Replacing the max function with a pair of hard coded if statements
• Defining $K_P$ in terms of it's reciprocal.

The problem is the last change combined with the fact that we are using integer arithmetic.

Calculating 1/K_P will evaluate to either 0 for K_P>1) and 1 for K_P==1, assuming sensible values of $K_P>0$.

So you are effectively turning your Proportional Integral Derivative controller into a Integral Derivative controller for any value of $K_P$ other than 1.

If you went back to using K_P directly rather than trying to use (1/K_P) then you should be able to tune your motor for velocity control.