Embedded Control Project -Iterative learning control for Author : Axel Andersson Hariprasad Govindharajan Shahrzad Khodayari Project Guide : Alexander Medvedev Program : Embedded Systems and Engineering Physics Course : Embedded Control System Date : 2012-04-25 1
Contents 1 Introduction... 3 2 Theory Description... 3 2.1 PID Controller... 3 2.2 ILC controller... 3 2.3 Architecture [1]... 4 3 Implementation... 5 3.1 PID Controller... 5 3.2 ILC controller... 5 3.3 Communication between LEGO and PC... 6 4 Modeling and simulation... 7 4.1 Purpose and goal... 7 4.2 Modeling the robot [2]... 8 4.2.1 GR(s)... 9 4.2.2 Gx,y(s)... 10 4.3 Modeling the ILC... 11 4.4 Simulation results... 12 5 Discussion and conclusions... 14 Appendix: Codes... 16 References... 20 2
1 Introduction An autonomous racing car runs laps on a track using a simple controller. Both the lap time and the mean deviation from the track are taken into account in evaluating the racer performance. Find a way of improving the car control from one lap to another by utilizing so-called iterative learning control, ILC, a method typically exploited in control of repetitive movements [1]. 2 Theory Description In order to control a car tracking the line, a simple PID controller is the first solution. As the goal is to improve the tracking by taking the advantage of the repetitive nature of close-loop track, ILC is one way of compensating the repetitive part of the error. 2.1 PID Controller PID stands for Proportional Integral Derivative controller. It is the most common feedback controller used in industrial systems. As the name suggests, there are three constant parameters need to be calculated for the PID controller. The final form of the PID controller is u(t)=kpe(t)+ki ( )dt+kd *de(t)/dt Where u(t) is the final output of the system, Kp is the proportional gain, Ki is the integral gain Kd is the derivative gain, e is the error = SP-PV and t is the time. 2.2 ILC controller The concept of ILC is inspired by human learning and has its origin in industrial robot applications where the same task is performed repeatedly. It is then a sound idea to try to improve the performance, using information of how the task was performed in previous repetitions by adding a correction signal to the system. The key problem in ILC is what type of algorithm to use for generation of the correction input signal, which should result in a smaller error in some norm. The simplest formulation of ILC may be: (, ) = (, 1)+ (, 1) The inputs in the current batch are determined by the inputs of the previous batch plus the proportional contribution of tracking error in the previous batch, where is the learning gain matrix. 3
2.3 Architecture [1] ILC can be combined with a feedback loop in serial, figure 1. It means the ILC control input is applied to the reference before the feedback loop for the situation that it is not allowed to modify directly the control signal. However, in the case that the individual control contributions from the ILC and feedback controller should be easily separable, ILC can be parallel with PID. The feedback controller modifies the input/output dynamics with regard to the ILC depending on the particular arrangement, figure 2. Figure 1. Serial architecture Figure 2. Parallel architecture where j is the iteration index, yj is the output, uj is the control input, yd the desired system output. 4
3 Implementation ILC uses open-loop control action only, which cannot compensate for non repeating disturbances. Thus, in most physical implementations, a well-designed feedback controller must be used in combination with ILC. In many cases, a feedback controller already exists on the system, and ILC can be implemented without modifying the feedback controller. The architecture implemented in our project is parallel architecture where the ILC directly alters the control signal, which is made by a PID controller, to the plant. There are three main components in order to have a complete system, PID controller, ILC controller and communication modules. 3.1.1 PID Controller In our project we have implmented the PID controller along with a LEGO Mindstorms kit which will follow the middle of the predefined track. To set the PID controller we start with the P pararmeter. The light sensor reading from the middle of the track is measured first. We determine the value of Kp by trial and error method. The proportional gain, which is a constant Kp is multiplied with the error value e(t). Care must be taken while tuning the initial Kp value. Because, if the Kp is too high then the system becomes unstable. Also the controller becomes less sensitive when Kp is very low. Once, the Kp is tund next our focus is on the Ki, the integral gain which is also a constant. In a PID controller, the integral denotes the sum of instantaneous error over the time t, and gives the accumulated offset which should have been corrected previously. The accumulated error is then multiplied with the Ki. And once again when tuning the Ki, if Ki is set very high then the stability of the system is affected along with increase in steady state error and a decrease in stability. The third parameter, Kd the derivative gain is multiplied with the slope of the error over time. This term will slow the rate of change of contorller output. Also, the magnitude of the overshoot produced by the integral component is reduced and the process stability is improved 3.1.2 ILC controller For practical implementation of ILC algorithms, it involves computer-based controllers operating in discrete time together with digital storage of the information. Thus, it is natural to consider discrete-time ILC algorithms applied to systems operating in finite time. The first issue was how to keep track of one lap. It is handled by marking the start point on the track. In the first lap, only PID works and all the errors of sampling points are stored in the memory. Then on the later laps, the ILC changes the control signal based on the value of the 5
same point (approximately) in the previous lap. ILC module contains three elements, memory, L- function, and Q-filter function. Figure 3. ILC block diagram L function is a PD controller and Q filter is a linear-phase low-pass filter. There are two gains, a0 and a1, for Q-filter which are tuned in the lab based on the rule 2a1+a0 = 1. While ILC alters the input control signal, the error is calculated and then it is saved in the memory in order to measure the derivation for the next point of the same lap by PID and next lap by ILC. 3.1.3 Communication between LEGO and PC In our ILC project, we have three parameters of our concern. The deviation of the robot from middle of the track, speed of the robot and time it takes to complete each lap. For measuring the deviation from the middle of the track, and send the measurement to the PC, three different ways are possible in RobotC. First is using Bluetooth communication, second is through creating a file inside the LEGO and writing the deviation values in the file and sending the file through BT or reading the file through file management utility provided by RobotC. The third option is to use Datalogs.BT communication is very slow and hence it is not tried here. In the second method, creating the files were successful but writing to te files was not successful. So, we decided to settle with thr Datalogs. The RobotC provides the neccessary APIs for Datalogs. The protocol is to first Save the desired value using the API AddToDatalog(); and then call the API savenxtdatalog();. In our PID code, we need to store the deviation from the middle of the track, ie the variable e in the datalog. The API savenxtdatalog() will save the existing datalog from RAM memory into a NXT file named DATAnnnn.rdt. The datalogs can be uploaded in to the PC through the file management utility feature provided in the RobotC IDE. We can upload the files as a spreadsheet which can be later opened through a openoffice calc tool. In the sample file provided along with the report, the column I has to be verified for the deviation from the middle of the track. 6
When tried with ILC, the datalogs were not completely successful. Since the in built delays in the robotc APIs are unknown, the line follower did not run on the track after 2 or 3 laps and the datalogs were also not created. The code for the PID controller along with the datalog and the datalog values stored in the spreadsheet are attached along with this project report. 3.2 Result of implementation The result of implementation was good and showed in table 1. We had 53% progress after 28 iterations. We tried ILC with and without Q filtering and it is observed that filtering had around 6% better result Max error(mm) Without ILC only PID 12.5 6.9 With ILC without filter 10.0 3.7 With ILC with Q filter 10.8 3.2 Reduction ~20% ~53% Table 1. Implementation result The parameters of the PID controller were: In addition, the L function parameters were: P = 1 I = 0.002 D = 0.001 P = 0.05 I = 0 D = 0.001 RMS error(mm) The sampling time for both ILC and PID was 20 Millisecond. Filtering gains were: a0 = 0.9 a1 = 0.05 4 Modeling and simulation 4.1 Purpose and goal Simulations of control systems can provide good insight in how the real life system behaves. Models of real life systems can be used for example when it is too time consuming to do real test runs, or too costly. In our case, the goal of the simulation was to give us some kind of pointer in what to expect from the real runs. Since no records were found of anyone trying to implement ILC on a Lego robot, we had no idea what to expect. In order to do this, a model representing our robot had to be derived and implemented in Simulink along with the other components that make up the complete control loop. Furthermore, the actual ILC had to be implemented as well. 7
4.2 Modeling the robot [2] Figure 4. The robot Figure 4 shows a simplified drawing of the robot. The wheels are connected to two motors. These motors can act independently of each other. The movement of the car is decided by the voltage applied to these motors. In our robot, the voltages to each motor is given by = + u/2 (1) = u/2 (2) where is a constant offset voltage that gives the car its forward motion and u is a differential voltage that controls the steering. u is the input to the system. The output of the system is the x and y position of the car. Figure 5. Block diagram of the robot model. Figure 5 shows how the block diagram of the model. From the input u to the output x and y. 8
4.2.1 GR(s) The following equations are given by the laws of mechanics. where - torque, - torque on right and left wheel, - force on right and left wheel, - rotation angle of right and left wheel moment of inertia for the robot around center of rotation Equation 3, 4 and 5 gives = φ (3) = ( ) (4), =, (5) φ = (6) ( ) = φ (7) A model that takes care of the effects caused by the DC motor is needed. The total torque exerted by the motor is proportional to the input voltage, = ( ). This torque contains 3 parts. One part is needed to accelerate the wheel, =. The second part is to compensate for the emf of the motor, this is proportional to the angular velocity of the wheel, =. The rest of the torque will act on the load, rotating the robot. This gives the equation Inserting 9 into 7, this gives the equation = + + (8) <=> = ( ) (9) φ = ( ) (9) which can be rearranged, using equation 6 and = u to give φ = φ φ (10) 9
<=> + φ = φ + (11) This is a second order differential equation that shows the relationship between input and output φ(t). From now on, the input will simply be called u. Using the Laplace transform on equation 11 gives the equation Ф( ) = ( ) ( ) (12) Where = 2, = 1 ( 2 + ) It's clear from equation 12 that the transfer function from u to phi is ( ) = ( ) (13) K and T need to be identified using system identification techniques. A MATLAB-file was provided for exactly this problem in a lab in a prior course. Using this, the values of K and T were found to be: K = 0.0255 T = 0.225 4.2.2 Gx,y(s) Now that a model from u to the angle around the center of rotation has been derived, a model that deals with the movement in the x-,y-plane with regard to the rotation needs to be derived. Two equations that do just that are and = cos ( ) (14) = sin ( ) (15) However, these equations do not fully relate to the control problem at hand. Since the robot does not measure its position at the center of rotation, these equations need to be expanded. The position of the sensor is at a distance L from the center of rotation in the direction of the angle. This adds a second term to equations 14 and 15, making the complete expressions from φ to x and y: 10
= cos ( ) + ( ) (16) = sin ( ) + ( ) (17) The simulation of the robot will take place in a discrete time environment. Because of this, there is no reason to derive a transfer function. Equations like 16 and 17 are easily implemented in discrete time. The only thing left is to find v and L. L is simply a set value, this is the length from the center of rotation to the sensor. This was measured with a ruler to be 0.15 m. The velocity is proportional to the offset voltage. This needs to be variable in order to test different settings, so no value was set. 4.3 Modeling the ILC Figure 6. Overview of the Simulink-model Figure 6 shows an overview of all the different blocks making up the entire model with the ILC within the gray box. The System block contains the discrete model of the robot as derived in the previous section, taking a voltage u as input and gives the x- and y-coordinates of the robot as output. The Controller block is a simple PID-controller. Track is a function that calculates the deviation from the track. The track itself is specified as a vector containing x- and y-coordinates of several points. The function compares the coordinates of the car and scans the vector for the closest point of the track. The distance between these coordinates is the deviation e. Using these coordinates and comparing to the origin, one can find whether the car is to the left or the right of the track. This does not work for all tracks, but it 11
works for our oval-shaped track and tracks with similar symmetry. The downside to using this type of comparison and using a track made up of points is that e gets noisy. Counter is a counter that resets each time the robot passes a certain point on the track. This is needed to define the iterations. Passing a certain point of the track means a new iteration has started. Because of the symmetry of the track, it was simple to use the x-coordinate as reference. When the car passes the y-axis, from either side, a new iteration starts. This actually splits the lap up in two iterations. This is not a problem because the track is symmetrical; the two halves are exactly the same. Instead it brings a big benefit, the ILC will converge (or blow up) twice as fast. Memory stores all the values from the previous iteration. In this case, it is the robot s deviation from the track and the output of the ILC. It uses the output from Counter to keep track which sample to use for the ILC L-function is a simple PID controller with I = 0 Q-filter is a linear-phase low-pass filter. 4.4 Simulation results In all simulations, the parameters of the PID controller were: P = 2000 I = 100 D = 800 These settings provide reasonably good tracking abilities without being too aggressive. The Q- filter coefficients used for all simulations were = 0.1 = 0.8 = 0.1 The velocity v was set to 0.1366. It made the car finish a lap in about 18 seconds, a speed that seemed realistic that the robot would use. Using different sample times didn t seem to make any difference, as long as the system was stable. For these runs, a sample time of 0.01s was used. 12
Figure 7. RMS-error for different values of the ILC parameters Figure 7 shows how the RMS error changes over the iterations. It can be seen that the error is greatly reduced when using ILC, compared to the case with no ILC. With ILC values of P = 1000 and D = 500, the error is reduced from 4.2 mm to 0.19 mm, a decrease of about 95%. It also converges quickly; it takes about 8 iterations for it to settle. As expected, if the ILC values are set too high, the error will increase instead of decrease. This will eventually lead to the car running off-track. 13
Figure 8. Maximum error for different values of the ILC Figure 8 shows how the maximum error changes over time. As expected, this is fairly similar to the RMS-error case. Using ILC values of P = 1000 and D = 500 reduces the max error from 7.2 mm to 0.59 mm, a decrease of about 92%. 5 Discussion and conclusions The goal of this simulation was to figure out whether our implementation will have any chance of working at all. Judging by these results it seems like it has. Keep in mind that this is a very simplified model of the robot; it doesn t contain any noise or constraints (other than the noise produced by the resolution of the track). The biggest problem we ran into was that using the MATLAB function c2d on the transfer function GR(s) did not seem to work. The system went unstable using the discrete function this function produced. Instead, the continuous transfer function G(s) was inserted in the discrete Simulink model and it worked without any problems Other than providing concrete results, these simulations have provided a deeper knowledge in MATLAB Simulink and modeling in general. 14
In the implementation, it is observed that as the ILC converges, the feedback controller applies less effort. Although the real word result was not the same as simulation s, which was expected, it shows that using the ILC could improve the performance in the real environment. The problems we had during implementation were how to determine the next lap, tuning the PID and ILC controller parameters in such a way that they both worked and the biggest one was how to store the data from Lego to pc for analyzing the performance. 15
Appendix: Codes ILC code 16
17
18
Datalog for PID controller 19
References [1] A Survey of Iterative Learning Control, Douglas A. Bristow, Marina Tharayil, and Andrew G. Alleyne, IEEE Control Systems Magazine 2006. [2] Introduction to computer based control systems, Process lab 2 Department of Systems and control, Uppsala University 20