Pid lfr

PID CONTROL
Feedback loop system.

BLOCK DIAGRAM
1. Compare the desired position to
the current position
2. The result is stored as the "Error"
3. The PID system decides how much
to steer
4. The motors steer the robot and the
sensors check the position again
5. Repeat

POSITION IN LFR
• Perfectly on the line corresponds to a
position of 1000.
• The further to the left our cart is, the
closer position is to 0
The further to the right our cart is, the
closer position is to 2000.
• Position is never greater than 2000 or
less than 0!
•

SET POINT
• It is the position the robot is stable in.
• in our case in dead center of the line.
• This is the position the control algorithm strives to achieve.
• We use two new quantities in our algorithm,
• An average of the sensor readings and sum of the sensor readings.

4 STEPS OF PID FOR LFR
• Sensor read and average values.
• PID calculate
• Calculate set point
• Drive motor

USING THE SENSOR TO FIND THE
LINE
We can have each sensor report how much light is
reflected and get a picture of which side the line is
on.
If we then take a weighted average of the sensor
values, we get a single number representing our
position.
In this case we know we know the sensor is to the
left of the center position, 1000.
So we can expect the values to average out to a bit
lower, around 750.

SETTING POINT
• It is simple as taking average of all sensor values.
• Now we’ll build the complete PID algorithm.
• We start with calculation of the sensor sum and average similar to code
To take an average of a bunch of values, we use this formula
We're going to take a weighted average, which is similar, only each value is multiplied by a "weight"

SETTING POINT
sensors_average = 0;
sensors_sum = 0;
for (int i = 0; i < 5; i++){
sensors[i] = analogRead(i);
sensors_average += sensors[i] * i * 1000; //Calculating the weighted
mean of the sensor readings.
sensors_sum += int(sensors[i]); //Calculating sum of sensor readings.
}
void pid_calc(){
position = int(sensors_average / sensors_sum);
proportional = position – set_point; // Replace set_point by your set
point
integral = integral + proportional;
derivative = proportional - last_proportional;
last_proportional = proportional;
error_value = int(proportional * Kp + integral * Ki + derivative * Kd);
}

CALCULATE TURN
• Formula for calculation of error value is the functional definition of PID control.
• you have to define the values of Kp, Ki and Kd in the code somewhere.
• After calculating the value of error,we need to tell the motor to move such that the
error is minimized.

CALCULATE TURN
void calc_turn(){ //Restricting the error value between +256.
if (error_value< -256){ error_value = -256; } if (error_value> 256){
error_value = 256;
}
// If error_value is less than zero calculate right turn speed values
if (error_value< 0){
right_speed = max_speed + error_value;
left_speed = max_speed;
}
// Iferror_value is greater than zero calculate left turn values
else{
right_speed = max_speed;
left_speed = max_speed - error_value;
}
}

SETTING MOTOR DRIVING
• According to your execute a left turn if you reduce the speed of your left motor and
a right turn if you reduce the speed of the right motor
• We use a value max_speed that has to be defined by you right in the beginning to
control the peed of the motor.
• The maximum value of this is 256, which corresponds to the maximum output of the
8 bit DAC converter on the Arduino.
• So let’s define a function which does exactly
that. ‘motor_right’ and ‘motor_left’ are the pin numbers at which your motors are
connected via the motor driver

SETTING MOTOR DRIVING
• void motor_drive(intright_speed, intleft_speed){
• // Drive motors according to the calculated values for a turn
• analogWrite(motor_right, right_speed);
• analogWrite(motor_left, left_speed);
• delay(50); // Optional
• }

SUMMING-UP
• Say your left motor moves faster than your right motor, add this before
the analogWrite().
• The ‘20’ is a random number, and you should set it depending on your motors.
• Just set the values and do a test run if its still not approximately same add subtract
accordingly till you have a more or less syncdmotors(i.e they run at approx. the
same speed).
• Put the functions together, and use this statement in the loop section.

SUMMING-UP
• void loop(){
• sensors_read(); //Reads sensor values and computes sensor sum and weighted
average
• pid_calc(); //Calculates position[set point] and computes Kp,Ki and Kd
• calc_turn(); //Computes the error to be corrected
• motor_drive(right_speed, left_speed); //Sends PWM signals to the motors
• }

SUMMING-UP
• Set all three constants to zero. Run the robot and see how it handles.
• Vary the values of Kp, Ki and Kd in that order, one at a time and test your robot.
• Do step 2 over and over again to get your bot perfectly tuned.

Pid lfr

More Related Content

Similar to Pid lfr (20)

Recently uploaded (20)

Pid lfr