Antilock Brake System Abs Model Based Design Computer Science Essay
An Antilock Brake System (ABS) is a closed loop control system that modulates the brake torque that is applied to the wheel in order to prevent the controlled wheel from becoming fully locked. ABS is among the most important safety systems in a vehicle. In automatic highway system, automatic brake actuation is a very important part of the overall vehicle control system. It prevents the wheel lock-up under critical braking conditions, such as those encountered with wet or slippery road surfaces and driver panic reaction (Bosch, 1995). By preventing the wheel lock-up, ABS ensures that the vehicle remains responsive to steering wheel inputs. Reduced stopping distance on account of ABS is more evident on wet or slippery road surfaces (Garrick et al., 1998).
1.2 MODEL BASED DESIGN
Designers of embedded control system software face difficult challenges. In addition to the need to complete projects at low cost and within tight schedules, embedded control system software designers must provide predictable performance and competitive features for the products they deliver. Traditional methods of designing, testing, and implementing embedded control systems cause designers to wait until late in the design effort, when actual or prototype products and real-time embedded targets become available, to find out if software really works as it was intended to. Only then, as system integration occurs, can the designer uncover the errors that may have found their way into the product during the early design stages.
Model-Based Design with MathWorks tools provides a proven technique for creating embedded control systems. It is used today for satellites, aircraft, and many other aerospace applications, in the automotive industry, and for process control, computer peripherals and industrial machinery. Through Model-Based Design, embedded control system design teams can begin evaluating software designs without using prototype products and real-time targets. The MathWorks environment for Model-Based Design allows engineers to mathematically model the behavior of the physical system, design the software and model its behavior, and then simulate the entire system model to accurately predict and optimize performance. The system model becomes a specification from which you can automatically generate real-time software for testing, prototyping, and embedded implementation, thus avoiding manual effort and reducing the potential for errors.
Fig 1.1. Model-Based Design for embedded control system software
Changes or corrections to the system requirements and specifications are easily incorporated into the model, fully evaluated by simulation, and automatically reflected in the final real-time embedded software.
1.3. MODELING AND SIMULATION
To effectively design an embedded control system and accurately predict its performance, designers must understand the behavior of the entire system in which the control system will reside. MATLAB and Simulink form the core environment for Model-Based Design for creating accurate, mathematical models of physical system behavior. The graphical, block-diagram paradigm of the MathWorks environment lets you drag-and-drop predefined modeling elements, connect them together, and create models of dynamic systems. These dynamic systems can be continuous-time, multi-rate discrete-time, or virtually any combination of the three. You can create custom model elements or reuse legacy code-based models by incorporating C, Fortran, or Ada code directly into the modeling environment.
The modeling environment is hierarchical and self-documenting. System structure and function can be clearly expressed by grouping model elements in virtually any combination, allowing large teams to work concurrently on the design. Libraries of hierarchical elements can be quickly created, allowing those elements to be reused easily by other members of the design team or on subsequent designs. Fully integrated into the environment is the capability to graphically model event-driven systems using state charts, truth tables, and flow diagrams. Specialized capability for mechanical and electrical power systems allows models of these systems to be constructed using modeling elements that correspond directly to the structure of the physical system, avoiding the need to express them as mathematical equations. If prototype or actual physical systems are available and input/output data can be acquired from them, mathematical models can also be created using system identification techniques.
As soon as a hierarchical element of the model is constructed, that element can be simulated. Simulation allows specification, requirements, and modeling errors to be found immediately, rather than waiting until later in the design effort. As the model becomes larger, through the addition of hierarchical elements or by increasing the complexity of existing ones, the designer can continue to find and correct errors during simulation by using the model coverage, performance profiling, and interactive debugging features. When the physical system model is specified to the required level of detail and simulation has shown the model to be accurate, the control system can be designed.
1.4. CONTROL SYSTEM SOFTWARE DESIGN
With the behavioral model of the physical system available, the designer can begin the embedded control system software design. The MathWorks environment for Model-Based Design supports many types of control system design techniques and requirements that range from the simple to the most complex and large-scale. For example, some product designs may require using linear control design methods to determine the correct algorithms and parameters for the control system software. Using MATLAB and Simulink, the designer can automatically create the linear physical system models needed by this design technique, calculate the parameters, and then visualize the results using Bode plots and root locus diagrams. Other applications may require less sophisticated techniques to determine the correct control system design. Regardless of the control system design method used, the MathWorks environment for Model-Based Design helps the designer use interactive simulation to quickly evaluate each control system design model in conjunction with the physical system model and avoid the risk, expense, or need for prototypes or actual physical systems.
As the control system functional design is completed and the target environment needs to be considered, the designer can specify implementation details for the software directly in the modeling environment. The MathWorks environment supports all aspects of control system software design, including processor, interface, or standards issues. For example, you may need scaled integer or fixed-point data types for target processors that have no floating-point math capability. The effects of fixed-point mathematics can be evaluated by simulation, to see if the proper data sizes and scale factors have been selected. Data structures that are needed to meet software standards or target environment interface requirements can be defined as part of the system model and then realized when the embedded control system software is automatically generated.
When the control system software design is complete, you can simulate the entire system model. During simulation, you can automatically collect model profiling and coverage information that will help you assess performance and discover errors. If performance does not meet expectations or errors are found, you can easily change the model to correct the problem and then simulate the model again to confirm the change or correction. Once simulation of the entire system model has shown that the design meets the desired performance requirements, you can automatically generate software for real-time testing and implementation, using the model as a specification.
1.5. EMBEDDED SOFTWARE TESTING AND IMPLEMENTATION
Using the system model and Real-Time Workshop, real-time code for testing, validation, and embedded implementation on the production target processor can be automatically generated. As it is created, the code is automatically optimized for fast execution and efficient use of memory. Automatically generating code from the system model avoids errors due to manual translation of the model into code, and saves time, allowing software developers to focus on more demanding tasks.
The MathWorks provides a turnkey software environment called xPC Target for real-time prototype testing, calibration, and validation of this automatically generated code using a PC-based hardware target system. xPC Target includes a real-time kernel, device drivers, and all the support software needed to create a rapid control prototyping system for real-time software testing and validation. It can also be used to provide hardware-in-the-loop capability, using code generated automatically from the physical system model. Hardware-in-the-loop testing allows the designer to simulate the real-time behavior and characteristics of their physical system, so that prototype or production control system software can be tested without the need for the actual hardware or operational environment. For embedded system designers who prefer an integrated capability, The MathWorks has a fully tested, custom configured, PC-based target hardware system.
Chapter 2
MODELING AND SIMULATION
2.1. MODELING
A computer model, as used in modeling and simulation science, is a mathematical representation of something-a person, a building, a vehicle, a tree-any object. A model also can be a representation of a process-a weather pattern, traffic flow, air flowing over a wing.
Models are created from a mass of data, equations and computations that mimic the actions of things represented. Models usually include a graphical display that translates all this number crunching into an animation that you can see on a computer screen or by means of some other visual device.
Models can be simple images of things-the outer shell, so to speak-or they can be complex, carrying all the characteristics of the object or process they represent. A complex model will simulate the actions and reactions of the real thing. To make these models behave the way they would in real life, accurate, real-time simulations require fast computers with lots of number crunching power.
2.2. SIMULATION
Simulations (and models, too) are abstractions of reality. Often they deliberately emphasize one part of reality at the expense of other parts. Where as models are mathematical, logical, or some other structured representation of reality, simulations are the specific application of models to arrive at some outcome.
2.2.1 Types of simulations
Simulations generally come in three styles: live, virtual and constructive. A simulation also may be a combination of two or more styles.
Live simulations typically involve humans and/or equipment and activity in a setting where they would operate for real. Think war games with soldiers out in the field or manning command posts. Time is continuous, as in the real world. Another example of live simulation is testing a car battery using an electrical tester.
Virtual simulations typically involve humans and/or equipment in a computer-controlled setting. Time is in discrete steps, allowing users to concentrate on the important stuff, so to speak. A flight simulator falls into this category.
Constructive simulations typically do not involve humans or equipment as participants. Rather than by time, they are driven more by the proper sequencing of events.
A simulator is a device that may use any combination of sound, sight, motion and smell to make you feel that you are experiencing an actual situation. Some video games are good examples of low-end simulators. Simulations are complex, computer-driven re-creations of the real thing. When used for training, they must recreate “reality” accurately; otherwise you may not learn the right way to do a task.
2.3. MODELING AND SIMULATING ORDINARY SECOND ORDER DIFFERENTIAL EQUATION
Consider the second order differential equation
(1)
This can be written as two first order differential equations if we introduce two new variables, x1(t) and x2(t). Let x1(t)=y(t). We can then write two coupled first order equations.
(2)
(3)
The solution can be approximated in Simulink by using two integrators to integrate the first order derivatives.
2.3.1. Building a Simulink Model
We start Simulink from the Matlab prompt by typing “Simulink”. We will be needing blocks from the “Source”, “Sink”, “Linear” and “Non-linear” libraries, so double click on them to open them up. In the window labeled “untitled”, drag two integrators from the “Linear” library, connect them, and change their labels.
Fig2.1. Building Simulink Model (Step 1)
The input to the leftmost integrator is the derivative of x2, and its output is x2. The input to the rightmost integrator is the derivative of x1 (=x2), and its output is x1.
We can complete the representation of the differential equation except for the input, by adding two gain blocks (and flipping them using the “Format” option of the Simulink menu.
Fig2.2 Building Simulink Model (Step 2)
To add the input we will use the clock (from “Source”), the trigonometric function (from “Non-Linear”) and another gain block. The completed diagram should look like the one shown below.
Fig2.3. Building Simulink Model (Step 3)
2.3.2. Running Simulation and Viewing Results
To view the results of the simulation, add a scope (from “Sink”). In this case we only want to view 80 ms of simulation, so go to the “Simulation” menu and choose “Parameters”, and set the stop time to 0.08 seconds. To start the simulation hit the start button, or go to “Simulation”->”Start”. The scope output is shown below (after zooming with the “Binocular” tool at the top of the scope window.
Fig2.4 Simulation Results of the Model
It is often desirable to save the data to Matlab. To save the time variable, the input and the output, we add three “To Workspace” blocks (from “Sink”) and give them each a different name (these are the names of the variables that will be in the Matlab workspace).
Fig2.5 Building Simulink Model (Step 4)
Chapter 3
ANTI-LOCK BRAKING SYSTEM
3.1 INTRODUCTION
Antilock Braking Systems (ABS) are closed loop control devices within the braking systems which prevent the wheel lock-up during braking and as a result, retain vehicle steerability and stability. The main ABS components are hydraulic modulators, wheel speed sensors, ECU for signal processing and control and triggering of the signal lamp and of the actuators in the hydraulic modulator.
Fig 3.1 Location of the ABS in a vehicle
3.2 DESCRIPTION OF THE SYSTEM
The theory behind anti-lock brakes is simple. A skidding wheel (where the tire contact patch is sliding relative to the road) has less traction than a non-skidding wheel. If we have been stuck on ice, for example, we know that if the wheels are spinning we have no traction. This is because the contact patch is sliding relative to the ice. By keeping the wheels from skidding while we slow down, anti-lock brakes benefit in two ways: The vehicle stops faster, and we will be able to steer while we stop.
There are four main components to an ABS system: Speed Sensors, Pump, Valve and an ECU.
3.2.1 Speed Sensor
The anti-lock braking system needs some way of knowing when a wheel is about to lock up. The speed sensors, which are located at each wheel, or in some cases in the differential, provide this information.
3.2.2 Valves
There is a valve in the brake line of each brake controlled by the ABS. On some systems, the valve has three positions:
In position one, the valve is open; pressure from the master cylinder is passed right through to the brake.
In position two, the valve blocks the line, isolating that brake from the master cylinder. This prevents the pressure from rising further should the driver push the brake pedal harder.
In position three, the valve releases some of the pressure from the brake.
3.2.3 Pump
Since the valve is able to release pressure from the brakes, there has to be some way to put that pressure back. That is what the pump does; when a valve reduces the pressure in a line, the pump is there to get the pressure back up.
3.2.4 The ECU
The ECU receives, filters and amplifies the speed sensor signals and ascertains from them the degree of wheel slip and the acceleration of the individual wheels as well as the reference speed which is the best possible calculation of the vehicle road speed. Most of the systems use vehicle specific LSI circuits for this purpose.
Fig 3.2 Anti Lock Brake Pump and Valves
3.3 WORKING OF ABS
There are many different variations and control algorithms for ABS systems. We will discuss how one of the simpler systems works. The controller monitors the speed sensors at all times. It is looking for decelerations in the wheel that are out of the ordinary. Right before the wheel locks up, it will experience a rapid deceleration. If left unchecked, the wheel would stop much more quickly than any car could. It might take a car five seconds to stop from 60 mph (96.6 kph) under ideal conditions, but a wheel that locks up could stop spinning in less than a second.
The ABS controller knows that such a rapid deceleration is impossible, so it reduces the pressure to that brake until it sees acceleration, then it increases the pressure until it sees the deceleration again. It can do this very quickly, before the tire can actually significantly change speed. The result is that the tire slows down at the same rate as the car, with the brakes keeping the tires very near the point at which they will start to lock up. This gives the system maximum braking power.
When the ABS system is in operation we will feel a pulsing in the brake pedal; this comes from the rapid opening and closing of the valves. Some ABS systems can cycle up to 15 times per second.
3.4 TYPES OF ABS:
Anti-lock braking systems use different schemes depending on the type of brakes in use. Referring them by the number of channels, that is, how many valves that are individually controlled and the number of speed sensors, we have the following:
i) Four-channel, four-sensor ABS – This is the best scheme. There is a speed sensor on all four wheels and a separate valve for all four wheels. With this setup, the controller monitors each wheel individually to make sure it is achieving maximum braking force.
ii) Three-channel, three-sensor ABS – This scheme, commonly found on pickup trucks with four-wheel ABS, has a speed sensor and a valve for each of the front wheels, with one valve and one sensor for both rear wheels. The speed sensor for the rear wheels is located in the rear axle. This system provides individual control of the front wheels, so they can both achieve maximum braking force. The rear wheels, however, are monitored together; they both have to start to lock up before the ABS will activate on the rear. With this system, it is possible that one of the rear wheels will lock during a stop, reducing brake effectiveness.
iii) One-channel, one-sensor ABS – This system is commonly found on pickup trucks with rear-wheel ABS. It has one valve, which controls both rear wheels, and one speed sensor, located in the rear axle. This system operates the same as the rear end of a three-channel system. The rear wheels are monitored together and they both have to start to lock up before the ABS kicks in. In this system it is also possible that one of the rear wheels will lock, reducing brake effectiveness. This system is easy to identify. Usually there will be one brake line going through a T-fitting to both rear wheels. We can locate the speed sensor by looking for an electrical connection near the differential on the rear-axle housing.
Chapter 4
IMPLEMENTATION OF ANTI-LOCK BRAKING SYSTEM
4.1 BLOCK DIAGRAM OF ABS
On initial braking, the brake pressure is increased, the brake slip λ rises and at the maximum point on the adhesion/slip curve, it reaches the limit between the stable and unstable ranges. From this point on, any further increase in the brake pressure or braking torque does not cause any further increase in braking force FB. In the stable range, the brake slip is largely deformation slip, it increasingly tends towards skidding in the unstable range.
Actuator
Desired Slip
Controller
Vehicle Dynamics
Actual Slip
Fig4.1. Block Diagram of ABS
We model the ABS using Matlab/Simulink where in the various mechanical blocks are realized and mathematical models of the same are readily available in the Simulink library. The ABS simulation model follows the below shown control loop. The reference variable is the desired relative slip which is fed as an input to the system. The control system in our case is the wheel whose parameters like wheel speed are measured. The feedback path consists of the user defined equation which measures the relative slip of the wheel and the error is rectified at the initial stage. The model represents a single wheel, which may be replicated a number of times to create a model for a multi-wheel vehicle.
Fig 4.2. ABS Control Loop
4.2 ANALYSIS OF ABS:
For understanding the concept of ABS, we make use of the free body diagram of a wheel. We make use of the formulae for force and torque acting on the wheel. The below figure gives us a clear understanding about the forces acting on a wheel. The wheel rotates with an initial angular speed that corresponds to the vehicle speed before the brakes are applied. We used separate integrators to compute wheel angular speed and vehicle speed. We use two speeds to calculate slip, which is determined below. Note that we introduce vehicle speed expressed as an angular velocity (see below).
. (Equal to wheel angular speed if there is no slip.) (1)
Fig 4.3 Free Body Diagram of a single wheel
(2)
(3)
is the wheel speed divided by the wheel radius.
is the vehicle linear velocity.
is the wheel radius.
is the wheel angular velocity.
We can also write (3) as
(4)
Where
V is the vehicle speed, ω is the wheel speed and r is the radius of the wheel. From these expressions, we see that slip is zero when wheel speed and vehicle speed are equal, and slip equals one when the wheel is locked. A desirable slip value is 0.2, which means that the number of wheel revolutions equals 0.8 times the number of revolutions under non-braking conditions with the same vehicle velocity. This maximizes the adhesion between the tire and road and minimizes the stopping distance with the available friction.
If an excessive brake torque is applied, the wheel will be locked, which means that it slides on the road surface but does not rotate at all. A locked wheel has no lateral stability and less longitudinal friction force, which is the ultimate force to stop the vehicle. Thus, a braking with a locked wheel will cause longer stopping distance and lateral instability. The tire force from the road surface causes the wheel velocity to increase, thus decreases the wheel slip. A high μ leads to a large tyre force and a low μ leads to a small tyre force. In the increasing part of the μ-slip curve, an increase of the wheel slip leads to a larger μ and a larger tyre force, which reverses the wheel slip to a small value. However, in the decreasing part of the μ-slip curve, an increase of the wheel slip leads to a smaller μ and a smaller tyre force, which causes the wheel slip to increase continuously. So, the peak point of the μ-slip curve is critical.
When a braking is initiated, the wheel velocity starts to decrease and the wheel slip starts to increase from zero. The wheel slip may stop increasing and start to decrease before the μ reaches its peak point. But if an excessive brake torque is applied, the wheel slip may go straightly to a large number, which causes the μ to pass its peak point and reach somewhere in the decreasing part of the μ-slip curve. If the brake torque is not reduced quickly at this point, the reduction of the road friction force will lead to a rapid increase of the wheel slip and eventually to a wheel lockup. ABS tries to detect when this peak point is going to be reached and then reduces the brake torque properly so that a wheel lockup could be avoided.
Fig 4.4. μ-slip Friction Curve
It appears to be true that maintaining the wheel slip at the peak point of the μ- slip curve is ideal. However, the position of the peak μ point varies on the different road surfaces. In addition, stay at the peak point of the μ- slip curve sometime may lead to a poor lateral stability. Thus, many control strategies define their performance goal as maintaining the wheel slip near a value of 0.2. This represents a compromise between the lateral stability, which is best at λ=0 and the maximum deceleration which usually appears when λ is between 0.1 and 0.3.
4.3 IMPLEMENTATION
The friction coefficient between the tire and the road surface, µ, is an empirical function of slip, known as the µ-slip curve. We created mu-slip curves by passing MATLAB variables into the block diagram using a Simulink lookup table. The model multiplies the friction coefficient, µ, by the weight on the wheel, W, to yield the frictional force, Ff, acting on the circumference of the tire. Ff is divided by the vehicle mass to produce the vehicle deceleration, which the model integrates to obtain vehicle velocity.
In this model, we used an ideal anti-lock braking controller, that uses ‘bang-bang’ control based upon the error between actual slip and desired slip. We set the desired slip to the value of slip at which the µ-slip curve reaches a peak value, this being the optimum value for minimum braking distance (see note below.).
Note: In an actual vehicle, the slip cannot be measured directly, so this control algorithm is not practical. It is used here to illustrate the conceptual construction of a simulation model.
Fig 4.5. Simulink Model of the ABS
In the above figure, the wheel speed, vehicle speed and the stopping distance are measured and the error value is fed back through the feedback path. Also, tire torque and the relative slip are fed as inputs to the wheel speed block. Notice that the model is a reference model which has its own internal block. Double click on the ‘Wheel Speed’ subsystem in the model window to open it. Given the wheel slip, the desired wheel slip, and the tire torque, this subsystem calculates the wheel angular speed.
To control the rate of change of brake pressure, the model subtracts actual slip from the desired slip and feeds this signal into a bang-bang control (+1 or -1, depending on the sign of the error). This on/off rate passes through a first-order lag that represents the delay associated with the hydraulic lines of the brake system. The model then integrates the filtered rate to yield the actual brake pressure. The resulting signal, multiplied by the piston area and radius with respect to the wheel (Kf), is the brake torque applied to the wheel.
Fig 4.6. Wheel Speed Model for the ABS
The model multiplies the frictional force on the wheel by the wheel radius (Rr) to give the accelerating torque of the road surface on the wheel. The brake torque is subtracted to give the net torque on the wheel. Dividing the net torque by the wheel rotational inertia, I, yields the wheel acceleration, which is then integrated to provide wheel velocity. In order to keep the wheel speed and vehicle speed positive, limited integrators are used in this model.
After we build the ABS model in simulink, we have to configure the parameters related to simulation of the model. We need to specify that the signals are exported to the Matlab workspace where they are analyzed and results are viewed. This is done by checking the signal logging field in the configuration parameters option provided in the simulation tab.
Fig 4.7. Configuring Parameters for the model
We make a Matlab code which makes use of the inputs and outputs used by the simulink model and we plot the waveforms.
4.3.1 ABS Code
h = findobj(0, ‘Name’, ‘ABS Speeds’);
if isempty(h),
h=figure(‘Position’,[26 239 452 257],…
‘Name’,’ABS Speeds’,…
‘NumberTitle’,’off’);
end
figure(h)
set(h,’DefaultAxesFontSize’,8)
logsout.unpack(‘all’);
plot(Vs.Time, Vs.Data);
set(findobj(‘type’,’line’),’color’,[0 1 0]);
hold on;
plot(Ww.Time, Ww.Data);
title(‘Vehicle speed and wheel speed’);
ylabel(‘Speed(rad/sec)’);
xlabel(‘Time(secs)’);
set(gca,’Position’,[0.1300 0.1500 0.7750 0.750]);
set(get(gca,’xlabel’),’FontSize’,10);
set(get(gca,’ylabel’),’FontSize’,10);
set(get(gca,’title’),’FontSize’,10);
% Plot arrow with annotation
hold on
plot([5.958; 4.192],[36.92; 17.29],’r-‘,[5.758; 5.958; 6.029],[36.55; 36.92; 35.86],’r-‘ )
text(8.533,54.66,’Vehicle speed (omega_v)’,’FontSize’,10)
plot([7.14; 8.35],[43.1; 56.3],’r-‘,[7.34; 7.14; 7.07],[43.4; 43.1; 44.1],’r-‘ )
text(4.342,15.69,’Wheel speed (omega_w)’,’FontSize’,10)
drawnow
hold off
h = findobj(0, ‘Name’, ‘ABS Slip’);
if isempty(h),
h=figure(‘Position’,[486 239 452 257],…
‘Name’,’ABS Slip’,…
‘NumberTitle’,’off’);
end
figure(h);
set(h,’DefaultAxesFontSize’,8)
slp = logsout.slp.Data;
time = logsout.slp.Time;
plot(time,slp);
title(‘Slip’)
xlabel(‘Time(secs)’)
ylabel(‘Normalized Relative Slip’)
set(gca,’Position’,[0.1300 0.1500 0.7750 0.750])
set(get(gca,’xlabel’),’FontSize’,10)
set(get(gca,’ylabel’),’FontSize’,10)
set(get(gca,’title’),’FontSize’,10)
Chapter 5
RESULTS AND CONCLUSION
After building the model, we simulate it using the options provided in the same Simulink window.
5.1 RUNNING THE SIMULATION
5.1.1 With ABS
Press the “Play” button on the model toolbar to run the simulation. We can also run the simulation by executing the sim(‘FILE NAME’) command in MATLAB. ABS is turned on during this simulation.
Fig 5.1 Vehicle Speed and Wheel Speed(with ABS)
The model logs relevant data to MATLAB workspace. Logged signals have a blue indicator. In this case yout and slp are logged (see the model).The above figure visualizes the ABS simulation results. The first plot in figure shows the wheel angular velocity and corresponding vehicle angular velocity. This plot shows that the wheel speed stays below vehicle speed without locking up, with vehicle speed going to zero in less than 15 seconds.
Fig 5.2 Normalised Relative Slip(with ABS)
5.1.2 Without ABS
For more meaningful results, consider the vehicle behavior without ABS. At the MATLAB command line, set the model variable ctrl = 0. This disconnects the slip feedback from the controller, resulting in maximum braking. The results are shown in the figure below.
ctrl = 0;
Now run the simulation again. This will model braking without ABS.
Fig 5.3 Vehicle Speed and Wheel Speed(without ABS)
Fig 5.4 Normalized Relative Slip (without ABS)
The above shown results are observed when the slip is set at its peak value i.e. 0.2. Now, we also consider two more cases in which the slip values are 0.1 and 0.3 respectively.
Fig 5.5. Vehicle Speed & Wheel Speed with ABS(slip=0.1)
Fig 5.6. Normalized Relative Slip with ABS (slip=0.1)
Note that, when ctrl=0, i.e. when the ABS system is disabled, the results will be same as in fig 5.3 and fig 5.4. Now, we change the desired relative slip value to 0.3 and observe the results.
Fig 5.7. Vehicle Speed & Wheel Speed with ABS (slip=0.3)
Fig 5.8. Normalized Relative Slip with ABS (slip=0.3)
5.1.3 Braking With ABS Vs Braking Without ABS
Fig 5.9. Stopping distance for hard braking with and without ABS
In the plots of Fig 5.3 and Fig 5.4, observe that the wheel locks up in about seven seconds. The braking, from that point on, is applied in a less-than-optimal part of the slip curve. That is, when slip = 1, as seen in the lower plot of fig 5.3, the tire is skidding so much on the pavement that the friction force has dropped off. This is, perhaps, more meaningful in terms of the comparison shown in Fig 5.9. The distance traveled by the vehicle is plotted for the two cases. Without ABS, the vehicle skids about an extra 100 feet, taking about three seconds longer to come to a stop.
5.2 CONCLUSIONS AND FUTURE SCOPE
This model demonstrates how we can use Simulink to simulate a braking system under the action of an ABS controller. We have also simulated the model and observed the results with using ABS and without using ABS. The controller in this example is idealized, but we can use any proposed control algorithm in its place to evaluate the system’s performance. We can also use the Real-Time Workshop with Simulink as a valuable tool for rapid prototyping of the proposed algorithm. C code is generated and compiled for the controller hardware to test the concept in a vehicle. This significantly reduces the time needed to prove new ideas by enabling actual testing early in the development cycle.
For a hardware-in-the-loop braking system simulation, we can remove the ‘bang-bang’ controller and run the equations of motion on real-time hardware to emulate the wheel and vehicle dynamics. We can do this by generating real-time C code for this model using the Real-Time Workshop. We can then test an actual ABS controller by interfacing it to the real-time time hardware, which runs the generated code. In this scenario, the real-time model would send the wheel speed to the controller, and the controller would send brake action to the model.
APPENDIX
μ- Slip Curve Data for Wet Pavement
Friction Coefficient
μ
Wheel Slip
λ
0.00
0.00
0.40
0.05
0.80
1.0
0.97
0.15
1.00
0.20
0.98
0.25
0.96
0.30
0.94
0.35
0.92
0.40
0.90
0.45
0.88
0.50
0.86
0.55
0.83
0.60
0.81
0.65
0.79
0.70
0.77
0.75
0.75
0.80
0.73
0.85
0.72
0.90
0.71
0.95
0.7
1
μ- Slip Curve Data for Dry Pavement
Friction Coefficient
μ
Wheel Slip
λ
0.00
0.00
0.60
0.05
0.90
1.0
1.00
0.15
1.20
0.20
1.18
0.25
1.16
0.30
1.14
0.35
1.12
0.40
1.10
0.45
1.08
0.50
1.06
0.55
1.05
0.60
1.04
0.65
1.03
0.70
1.03
0.75
1.02
0.80
1.02
0.85
1.01
0.90
1.01
0.95
1
1
Order Now