advertisement

PROJECT 2 PID CONTROLLER Qin Rong Yiqi Ju Ying Shen 2011/4/28 We aim to learn how to use PID controller to ensure a robot car run a specified degree with PID controller. And the inbuilt PID controller is disabled. Objectives 1. Build a robotic car 2. Understand PID control design for robots 3. Design a PID controller. Tune a PID controller Equipment 1. LEGOS NXT Robotic kit 2. PC to NXT USB cable 3. Computer with RobotC installed Background The car robot we are using is a differential drive car robot as it has two motorized wheels that provide drive and steering functions. There are some basic problems with this program. The car may not go straight as the two motors may not have the same speed even though we have commanded both of them to be at a specified power. This can be due to the different construction of the two motors as well as different outside environment for the two wheels. One motor my rotate faster than the other causing the car to drift. To counter these effects, we can use ROBOTC’s inbuilt PID control function or we can build our own PID controller to ensure the car will run a specified degree. Theory A proportional–integral–derivative controller (PID controller) is a generic control loop feedback mechanism (controller) widely used in industrial control systems – a PID is the most commonly used feedback controller. A PID controller calculates an "error" value as the difference between a measured process variable and a desired setpoint. The controller attempts to minimize the error by adjusting the process control inputs. Figure 1: PID control for general system The PID controller calculation (algorithm) involves three separate constant parameters, and is accordingly sometimes called three-term control: the proportional, the integral and derivative values, denoted P, I, and D. Heuristically, these values can be interpreted in terms of time: P depends on the present error, I on the accumulation of past errors, and D is a prediction of future errors, based on current rate of change. The weighted sum of these three actions is used to adjust the process via a control element such as the position of a control valve or the power supply of a heating element. In the absence of knowledge of the underlying process, a PID controller is the best controller. By tuning the three parameters in the PID controller algorithm, the controller can provide control action designed for specific process requirements. The response of the controller can be described in terms of the responsiveness of the controller to an error, the degree to which the controller overshoots the setpoint and the degree of system oscillation. Note that the use of the PID algorithm for control does not guarantee optimal control of the system or system stability. As for LEGO NXT, the motors have rotation sensors, and therefore can measure the speed. A speed rating 100 corresponds to the power of 100%. The max speed of the motor in ideal conditions is 1000 degrees per second. The closed loop PID control algorithm uses feedback from the motor encoder to adjust the raw power to provide consistent speed. Closed loop control continuously adjusts the motor raw power to maintain a motor speed relative to the maximum regulated speed. To set the maximum regulated speed we use the command nMaxRegulatedSpeedNxt, which is the max regulated speed level in degrees per second. We can use any value lower than 1000. Usually, the batteries may not be 100% charged, so we will not be able to get the max speed and therefore a lower value is recommended. Here we set the max speed as 500. We will use nMotorPIDSpeedCtrl[motorB] = mtrNoReg and nSyncedMotors = synchNone to disable the inbuilt PID controller. And we will write our own PID controller. PID tuning Tuning a control loop is the adjustment of its control parameters (gain/proportional band, integral gain/reset, derivative gain/rate) to the optimum values for the desired control response. Stability (bounded oscillation) is a basic requirement, but beyond that, different systems have different behavior, different applications have different requirements, and requirements may conflict with one another. PID tuning is a difficult problem, even though there are only three parameters and in principle is simple to describe, because it must satisfy complex criteria within the limitations of PID control. There are accordingly various methods for loop tuning, and more sophisticated techniques are the subject of patents. Ziegler–Nichols method This method was developed by John G. Ziegler and Nathaniel B. Nichols in the 1940’s. Here we will discuss the Z-M method for those systems that can become unstable by using proportional control only. The basic steps in Z-M method are 1. Set K I and K D equal to zero. 2. Slowly increase K p to a value K u at which we see sustained oscillations (constant amplitude and periodic). 3. Note the period of oscillation. We will denote it by Tu . 4. Use the following values as the initial tuning constants Z-M model Kp KI KD P controller 0.5 K u 0 0 PI controller 0.455 K u 0.833 Tu 0 PID controller 0.588 K u 0.5 Tu 0.125 Tu Table 1: Z-M table for PID tuning Task 1. Build a LEGO NXT Robot car. Instructions are provided in the LEGO MINDSTORM’s instruction manual. For testing, keep the robotic car upside down for design. Keep the robot fully charged, as design solution may change if the battery power changes. Position Output set point NXT Servo Motor ∑ + - Figure 2: PID control for NXT position control position 2. In ROBOTC, write a code for the PID controller. Define the error signal as the actual angle of the encoder and angle set point (target angle). The angle set point is 500 degrees. The motor should run for 10s. a. It is important to disable all inbuilt ROBOTC PID control functions. This can be done using the commands shown below. Do not use any inbuilt ROBOTC PID control function. nMotorPIDSpeedCtrl[motorA] = mtrNoReg;//disable NXT inbuilt PID nMotorPIDSpeedCtrl[motorB] = mtrNoReg;//disable NXT inbuilt PID nSyncedMotors = synchNone;//disable NXT inbuilt PID b. Provide a soft copy (.c) of the code as well as put in the project report. The code should not be unnecessary complex and should be well commented explaining the functioning of the program. 3. Tune the PID controller by following the steps below a. Use the Ziegler–Nichols (Z-N) method to find K u and Tu . Draw a plot showing sustained oscillations and period of the oscillations. An example plot is shown in figure 3.5. Provide the values of K u and Tu b. Using the values of K u and Tu , show the initial tuned performance of the PID controller. Provide the rise time, percentage overshoot and settling time (± 5%) c. Tune the PID values further for a maximum percent overshoot Mp < 6% , settling time < 1.2 sec (2% scenario) and steady state error of < 1.3 %. 4. Design a PID controller for speed control using the set point speed to 250 degrees per second. Tune the PID values for a percent overshoot < 7%, settling time < 1.5 s (5% scenario) and steady state error of < 10%. Model Figure 3: Robot Car Model based on LEGO NXT Code #define Kp 0.05292 // Kp #define Ki 0.0000000075 // Ki #define Kd 0.0375 //Kd task main() { nMaxRegulatedSpeedNxt=500; // set the max speed as 500 nMotorEncoder[motorB]=0; // initialize encoder of motor B nMotorEncoder[motorC]=0; // initialize encoder of motor C nMotorPIDSpeedCtrl[motorB] = mtrNoReg;//disable NXT inbuilt PID nMotorPIDSpeedCtrl[motorC] = mtrNoReg;//disable NXT inbuilt PID nSyncedMotors = synchNone;//disable NXT inbuilt PID motor[motorB] = 50;//set speed to 500/2=250 degrees per second motor[motorC] = 50;//set speed to 500/2=250 degrees per second int setPoint=500; // target degrees // initialize all variables for both motor B and motor C int actualDegreesB=0; int actualDegreesC=0; int errorB=0; int errorC=0; int pre_errB=0; int pre_errC=0; int IB=0; int IC=0; int DB=0; int DC=0; float outputB=0; float outputC=0; time1[T1]=0; while(time1[T1]<10000) { // motor B actualDegreesB = nMotorEncoder[motorB]; // find actual degrees of motor B errorB=setPoint-actualDegreesB; // find error of motor B IB=IB+errorB; // find value of integral DB=errorB-pre_errB; // find value of derivative outputB=Kp*errorB+Ki*IB+Kd*DB; // pid contorl for motor B pre_errB=errorB; // store the error motor[motorB]=50+outputB*50; // motor C actualDegreesC = nMotorEncoder[motorC]; // find actual degrees of motor C errorC=setPoint-actualDegreesC; // find error of motor B IC=IC+errorC; // find value of integral DC=errorC-pre_errC; // find value of derivative outputC=Kp*errorC+Ki*IC+Kd*DC; // pid contorl for motor C pre_errC=errorC; // store the error motor[motorC]=50+outputC*50; // record the value of actual degree of motor C for further research. AddToDatalog(1, actualDegreesC); // wait for 50 ms wait1Msec(50); } // store all data into a file. SaveNxtDatalog(); } Solution When we set Ku as 0.09, the robot starts to oscillate: Figure 4: PID tuning. Z-N oscillations Figure 5: Zoom in the plot of PID tuning. Z-N oscillations Tu is easily to be found as 0.3s. So when we set Kp=0.588*Ku=0.05292, Ki=0.5*Tu=0.15, Kd=0.125*Tu=0.0375. We find it still oscillates. The plot diagram is shown as below: Figure 6: A test example PID response We can find the Ki is too big from this example. So we low Ki until the PID response is proper. When we try about 70 times, we find when Ki is equal to 0.0000000075 the response is very good. The plot diagram is shown below: Figure 7: A good PID response Though we want to let the robot run only 500 degrees, the steady state we get is 519. The steady state error is (519-500)/519*100%=3.8% Figure 8: Zoom in for the good PID response We don’t know why there is such a tolerance. But when we try different target degrees, like 480, 400, and 300, we get the plot diagram below: Figure 9: An example PID response for target degree as 480 Figure 10: An example PID response for target degree as 400 Figure 11: An example PID response for target degree as 300 If the tolerance is generated by algorithm, the tolerance should be changed proportionally to the target degree. But we found the steady states are always 20 bigger than the target states. So we believe the tolerance may be generated by the robot itself, not algorithm. Overshoot is when a signal or function exceeds its target. It arises especially in the step response of bandlimited systems such as low-pass filters. Figure 12: The highest value the system reached So the overshot in this plot diagram is (526-519)/519*100%=1.349% Rise time refers to the time required for a signal to change from a specified low value to a specified high value. Typically, these values are 10% and 90% of the step height. Since the steady degree is 519, the rise time is the time that values rise from 10% to 90% of the step height, which is about 51.9-467.1. Figure 13: The trend line for the rise part We use the rise part of the plot to determine the formula for that part. The formula is y=0.2842x2+36x-57.622 Since we know the formula and values, we can find the rise time easily. If y=51.9, which means 51.9=0.2842x2+36x-57.622 x=2.97252 If y=467.1, which means 467.1=0.2842x2+36x-57.622 X=13.20007 So the rise time is 13.2007-2.97252)/200*10=0.511s The settling time of an amplifier or other output device is the time elapsed from the application of an ideal instantaneous step input to the time at which the amplifier output has entered and remained within a specified error band, usually symmetrical about the final value. Figure 14: The lowest value after highest value After the system reaches the highest value, the lowest value is 513. When the specified error band is ± 5%, the error band will be about 493.05-544.95. Since the highest value is 526, so we just find when the system reaches 493.05. If y=493.05, which means 493.05=0.2842x2+36x-57.622 X=13.79427 So the settling time is 13.79427/200*10=0.6897s When the specified error band is ± 2%, the error band will be about 508.62-529.38. Since the highest value is 526, so we just find when the system reaches 493.05. If y=508.62, which means 508.62=0.2842x2+36x-57.622 X=14.14861 So the settling time is 14.14861/200*10=0.7074s Conclusion There exists a tolerance generated by the system itself, not my program. All values we got are very good. The plot diagram we got looks beautiful. From this project, we know how to use ROBOTC. And we know more about PID controller, especially why we need PID controller. Reference Wikipedia. (2011, April 30). PID controller. Retrieved from http://en.wikipedia.org/wiki/PID_controller Wikipedia. (2011, April 29). Rise time. Retrieved from http://en.wikipedia.org/wiki/Rise_time Wikipedia. (2011, April 28). Settling time. Retrieved from http://en.wikipedia.org/wiki/Settling_time Wikipedia. (2011, April 29). Ziegler–Nichols method. Retrieved from http://en.wikipedia.org/wiki/Ziegler%E2%80%93Nichols_method Wikipedia. (2011, April 28). Overshoot_(signal). Retrieved from http://en.wikipedia.org/wiki/Overshoot_(signal)