Analysis of Forces Acting on a Vehicle and Modelling of WOT (Wide Open Throttle) of GM EV1 Car

ANALYSIS OF FORCES ACTING ON A VEHICLE AND MODELLING OF WOT (WIDE OPEN THROTTLE) OF GM EV1 CAR

AIM :-

To analyze the forces acting on a vehicle and modeling of wide-open throttle of an electric car.

PLATFORM USED :-

1. Software – MATLAB R2019a & Microsoft EXCEL

SYSTEM SPECIFICATIONS :-

1. Manufacturer - DELL
2. Model – Vostro 3478
3. Operating System - Windows 10
4. Processor - Intel(R) Core(TM) i5-8250U CPU @ 1.60GHz 1.80GHz
5. RAM – 8 GB

OBJECTIVES :-

1. Evaluate the hill climbing ratio of a TATA ultra-truck at fully loaded and half loaded conditions.
2. Analyze the gradeability and its associated parameters.
3. Analyze the forces acting on vehicle by creating a drive cycle and plot graph of speed vs time.
4. Modelling of WOT (Wide Open Throttle) of GM EV1 car and compare the data with 5% change in parameters to original dataset.

THEORY :-

Wide open throttle (WOT) refers to an internal combustion engine's maximum intake of air and fuel that occurs when the throttle plates inside the carburetor or throttle body are "wide open", providing the least resistance to the incoming air.

GOVERNING EQUATIONS :-

1.Rolling Resistance Force,

`F_(rr) = mu_{rr}*m*g`

Where,

2.Aerodynamic Drag Force,

`F_(ad) = 0.5*rho*A*C_d*v^2`

Where,

3.Hill Climbing Force,

`F_(hc) = m*g*sinvarphi`

Where,

4.Traction Effort Force (Plain Surface),

`F_(te) = F_(rr) + F_(ad)`

Where,

5.Traction Effort Force (Hill Climbing),

`F_(te) = F_(rr) + F_(ad) + F_(hc) + F_(la) + F_(omegaa)`

Where,

6.Linear Acceleration Force,

`F_(la) = m*a`

Where,

7.Angular Acceleration Force,

`F_(omegaa) = I*(G^2/r^2)*(a/ƞ_g)`

Where,

8.Tractive Power,

`P_(te) = F_(te)*v`

Where,

9.Power for Rotational Motion,

`P = tau*omega`

Where,

10.Angular Speed including the Gear Ratio,

`omega = (v/r)*G`

Where,

11.Motor torque,

`T = (F*r)/G`

`F = (T*G)/r`

Where,

RATIO OF HILL CLIMBING POWER REQUIRED BY FULLY LOADED AND HALF LOADED TATA ULTRA TRUCK

INTRODUCTION :-

In this analysis we are considering the TATA T7 ULTRA TRUCK for determining the hill climbing power ratio.

DATA EXTRACTED :-

1. Gross Weight – 7300 Kg
2. Payload – 4200 Kg
3. Kerb Weight – 3100 Kg
4. Gradeability – 31.16 %

TO FIND :-

1. Hill Climbing Power Ratio = ?

ASSUMPTION :-

1. The truck is climbing the hill at constant speed of 30 Kmph.
2. The respective velocity is 8.33 m/s.

CALCULATIONS :-

Finding the slope angle for the respective gradeability,

WKT,

Gradeability = 31.16%

Gradeability = 0.3116

For Gradeability,

G = (Rise/Run)*100%

G = (tan `theta`)

Here we are considering value as 0.3116 to find the angle inclined,

`G = tan^{-1}(0.3116)`

`G = 17.3^0`

We can verify our value with the scale,

Fully Loaded Condition,

Now,

Gross Weight = Kerb Weight + Payload

Gross Weight = 3100 + 4200

Gross Weight = 7300 Kg

WKT the Hill Climbing Force,

`F_(hc) = m*g*sinvarphi`

`F_(hc) = 7300*9.81*sin(17.3)`

`F_(hc (FULL-LOAD)) = 21295.90 N`

WKT the Hill Climbing Power,

`P_(hc) = F_(hc)*v`

`P_(hc) = 21295.90*8.33`

`P_(hc) = 177394.84 W`

`P_(hc (FULL-LOAD)) = 177.39 KW`

Half Loaded Condition,

For half load the payload of the vehicle should be reduced to half the value.

Payload = 4200 Kg

Payload = 2100 Kg

Now,

Gross Weight = Kerb Weight + Payload

Gross Weight = 3100 + 2100

Gross Weight = 5200 Kg

WKT the Hill Climbing Force,

`F_(hc) = m*g*sinvarphi`

`F_(hc) = 5200*9.81*sin(17.3)`

`F_(hc (HALF-LOAD)) = 15169.68 N`

WKT the Hill Climbing Power,

`P_(hc) = F_(hc)*v`

`P_(hc) = 15169.68*8.33`

`P_(hc) = 126363.43 W`

`P_(hc (HALF-LOAD)) = 126.36 KW`

Hill Climbing Power Ratio,

`Power Ratio = frac{P_((hc) (FULL-LOAD))}{P_((hc) (HALF-LOAD))}`

`Power Ratio = frac{177.39}{126.36}`

`Power Ratio = 1.4`

GRADEABILITY AND IT’S PARAMETERS

GIVEN DATA :-

Minimum Height (Rise) = 5.5 m

TO FIND :-

Minimum Length of the flyover = ?

ASSUMPTIONS :-

Gradeability (angle) = `17.3^o` (From TATA T7 ULTRA TRUCK)

CALCULATIONS :-

Finding the run and then minimum length using basic trigonometric formulae,

WKT,

`tan varphi = frac{Opposite}{Adjacent}`

`Tan varphi = frac{Rise}{Run}`

`Tan (17.3) = frac{5.5}{Run}`

`Run = frac{5.5}{tan (17.3)}`

`Run = 17.65 m`

Now,

`sin varphi = frac{Opposite}{Hypotenuse}`

`sin varphi = (Rise)/(L(Hypo)`

`sin (17.3) = frac{5.5}{L(Hypo)}`

`L(hypo) = frac{5.5}{sin (17.3)}`

`L(Hypo) = 18.49 m`

Verification of the calculated values,

By Gradeability Formula,

`Gradeability = frac{Rise}{Run}*100%`

`Gradeability = frac{5.5}{17.65}*100%`

`Gradeability = 31.16%`

By Pythagoras Theorem,

`c^2 = a^2 + b^2`

`(L(hypo))^2 = (Rise)^2 + (Run)^2`

`(L(hypo))^2 = (5.5)^2 + (17.65)^2`

`L(hypo) = 18.48 m`

CONCLUSION :-

Hence we obtained the gradeability as 31.16% same value mentioned in the TATA T7 ULTRA TRUCK and the calculated height as 18.48 m.

RESULT :-

The minimum length of the fly-over is 18.49 m.

PREPARING A DRIVE CYCLE AND PLOT GRAPH OF TIME VS VELOCITY USING SIMULINK

INTRODUCTION :-

In this analysis we are taking the Simulink model from MathWorks website and feeding our drive cycle to plot time vs velocity graph.

OVERALL MODEL :-

Work Flow,

1. The Drive Cycle data will be fed to the input block.
2. From the input block the velocity data will be sent to driver block and compared to the calculated veloctiy to determine any error.
3. After checking the error in the data will be fed into the glider block for calculations and output to be sent to results block.

DRIVER MODEL :-

Work Flow,

1. The drive cycle data and the calculated velocity data to be sent into PID control block.
2. PID – Proportional, Integrate and Differential block where it checks the error so that there is no exceeding difference in the default value.
3. Then we get the desired output if the condition gets satisfied in the PID block.
4. The output we are obtaining as Tractive Force (`F_(te)`).

GLIDER MODEL :-

Work Flow,

• From the driver module we take the output and give it as input in the glider model.
• Where the Traction force is a sum of drag, hill climbing, inertia, rolling resistance,

`F_(te) = F_(rr) + F_(ad) + F_(hc) + F_(i)`

• From this the inertia force is being calculated,

`F_i = F_(te) – (F_(rr) + F_(ad) + F_(hc))`

• The obtained inertia force is divided by the inertia mass of the vehicle to obtain the acceleration,

`a = F_i/m_i`

`a = (F_te - F_rr + F_ad + F_hc)/m_i [m/s^2]`

• Then the acceleration is integrated to obtain the velocity,

`a = m/s^2`

`int (a)ds = int(m/s^2) ds = m/s`

`Velocity = m/s (SI-Unit)`

• Again, the velocity is integrated to obtain the position,

`v = m/s`

`int (v) ds = int(m/s) ds = m`

`Position = m (SI-Unit)`

• Then the velocity is taken and the units gets converted to mph from mps.
• Then the tractive force and velocity is taken to evaluate the power.
• The power is converted to KW from W.
• Then the power is integrated to obtain energy,

`Power (P) = Kgm^2/s^3`

`int(P)ds = int(Kgm^2/s^3) ds = Kgm^2/s^2`

`ENERGY (J) = Kgm^2/s^2 (SI-Unit)`

• The energy is converted from J to KWh.
• The energy is separated into tractive power (`P_(te)`) and brake power (`P_b`) by applying some limits to determine the energy taken for traction and braking.
• Finally the output is taken as velocity in mph to plot the graph between time and velocity to obtain the drive cycle.

OUTPUT :-

The drive cycle data is being plotted and the included hill climbing angle do not make any change in the drive cycle as there is only very minute change which is not visible. And for evaluating we are comparing the simulink plot and matlab plot.

MODELLING OF WOT (WIDE OPEN THROTTLE) OF GM EV1 CAR

INTRODUCTION :-

The General Motors (GM) EV1 was an electric car produced and leased by General Motors from 1996 to 1999. It was the first mass-produced and purpose-designed electric vehicle of the modern era from a major automaker and the first GM car designed to be an electric vehicle.

CAR SPECIFICATIONS :-

1. Class – Electric Subcompact Coupe
2. Electric Motor – 102 KW at 7000 rpm and 149 Nm at 0-7000 rpm
3. Transmission – Single speed reduction integrated with motor and clutch
4. Battery – 18.7 KWh (Lead-Acid) and 26.4 KWh (Nickel Metal Hydride)
5. Range – 89 Km (Lead-Acid) and 169 Km (Nickel Metal Hydride)
6. Wheelbase – 2510 mm
7. Length – 4310 mm
8. Width – 1770 mm
9. Height – 1280 mm
10. Kerb Weight – 1400 Kg (Lead-Acid) and 1319 Kg (Nickel Metal Hydride)

CASE 1 – WITH ORIGINAL PARAMETERS

DATA FOR CALCULATIONS :-

1. Drag Co-efficient (C_d) = 0.19
2. Co-efficient of Rolling Resistance (= 0.0048
3. Motor Speed (N) = 12000 rpm
4. Frontal Area (A) = 1.8 m^2
5. Efficiency of Drive Coupling (ƞ_g) = 0.95
6. Gross Weight (m) = 1540 Kg
7. Kerb Weight = 1400 Kg
8. Pay Load = 140 Kg
9. Gear Ratio (G) =11
10. Tire Radius = 0.3 m
11. Motor Torque (T_max) = 140 Nm
12. Critical Velocity (v) = 19.8 m/s
13. Critical Angular Speed (= 733 rad/s
14. Constant Power = 102 KW
15. Density of Air (`rho`) = 1.25 Kg/m^3
16. Velocity for limiting acceleration (v) = 35.8 m/s

CALCULATIONS :-

WKT for Motor Torque,

`T = (F*r)/G`

`F = (T*G)/r`

Here the force (F) is considered as tractive force (`F_(te)`),

`F_(te) = (T*G)/r`

WKT the Total Tractive Force,

`F_(te) = F_(rr) + F_(ad) + F_(la) + F_(omegaa)`

`(T*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m*a) + (I*(G^2/r^2)*(a/ƞ_g))`

`(T*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m) + (I*(G^2/(r^2*ƞ_g)))*(d_v/d_t)`

In most cases at low speeds, the maximum torque is a constant until the motor speed reaches a critical value `omega_c` (critical speed) after which the torque falls.

`So, T=T_max`

`(T_max*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m + (I*(G^2/(r^2*ƞ_g))))*(d_v/d_t)`

Here we don’t have the moment of Inertia (I) value because for a such huge vehicle it will be in negligible quantity. So we are adding 20 Kg more to the gross weight,

m = 1560 Kg (for acceleration alone)

By substituting the respective values,

`(0.95*37*140)= 72.4 + (0.214*v^2) + 1560*(d_v/d_t)`

`(d_v/d_t) = 3.11 – 0.000137*v^2 --------- A`

Once the speed has reached the critical speed v = 19.8 m/s the torque (T) is,

WKT for Rotational Motion,

`P = tau*omega`

Angular Speed,

`omega = (v/r)*G`

Now,

`P = tau*omega`

`P = tau*((v/r)*G)`

Substituting the values,

`P = tau*((v/r)*G)`

`P = tau*((v/0.3)*11)`

`P = tau*v*37`

`tau = (P/(v*37))`

`tau = (102000/(v*37))`

`tau = 2756/v`

Now the equation becomes,

`(T*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m + (I*(G^2/(r^2*ƞ_g))))*(d_v/d_t)`

`((0.95*37*2756)/v) = 72.4 + (0.214*v^2) + 1560*(d_v/d_t)`

`(d_v/d_t) = (62.1/v) – 0.046 – 0.000317*v^2 -------- B`

The motor limits the acceleration of the vehicle when the vehicle attains the speed of 35.8 m/s i.e., 128.86 Kmph. Till this speed the vehicle accelerates after that it runs at constant speed so, no more acceleration is provided after 128.86 Kmph.

Equations A and B should be written in Finite Difference form,

`v_(n+1) = v_n + partial t*(3.11 – 0.000137*(v_n)^2) ------ C`

`v_(n+1) = v_n + partial t*((62.1/v_n) – 0.046 – 0.000317*(v_n)^2) -------- D`

CODE :-

% Clearing all previous memory in Workspace
clear all
% Clearing all previous memory in Workspace
close all
% Clearing all the values in Command Window
clc
 
% Original Parameters of GM EV1 Car
% Time(s) array	
t = linspace(0,50,201);

% Creating the velocity array of zeros to store the calculated values
% Velocity Array - (Defining before calculation
v = zeros(1,201);
 
% Differentiation time - dt (t = 0.1 s)
dt = 0.1;
 
% Loop for velocity and distance calculation
for i = 1:200
    if v(i)<19.8 % (w(omega) = 10.8 rad/s after Critical Speed)
        v(i+1) = v(i) + dt*(3.11-(0.000137*(v(i)^2)));
    elseif v(i)>=35.8
        v(i+1) = v(i);
    else
        v(i+1) = v(i) + dt*(((62.1)/v(i))-0.046-(0.000137*(v(i)^2)));
end
end

% Converting the velocity from (m/s) to Kmph
v = v.*3.6;

% Plotting the time vs velocity graph
plot(t,v,'linewidth',1.5,'color','r');

% Turning on the grid in plot
grid on

% Providing label to the axes
xlabel('Time (s)')
ylabel('Velocity (Kmph)')

% Providing title to the plot
title('WOT (Wide Open Throttle) of GM EV1 Car')

PROGRAM PROCESS :-

1. The compiler starts the program.
2. It creates a time array ‘t’ containing values from 0-50 sec.
3. Then creating velocity ‘v’ vector with zeros to store the calculated values.
4. Differentiation time ‘dt’ is checked for correct value.
5. The looping statement starts
6. Then the velocity ‘v’ is calculated till 19.8 m/s i.e.,71.28 Kmph from equation C.
7. Then the compiler checks for the condition v>35.8 m/s i.e.,128.88 Kmph and if the condition fails it calculates the velocity from equation D.
8. If the condition v>35.8 m/s i.e.,128.88 Kmph satisfies then it stops acceleration (calculating velocity) and it repeats the same velocity till the time value (constant speed).
9. The looping statement ends.
10. Then the velocity (m/s) is converted into Kmph.
11. Then graph is plotted between time and velocity.
12. Title is assigned to the axes.
13. Title is assigned to the plot.
14. Compiler stops the program.

OUTPUT :-

The graph is plotted between time and velocity.

CASE 2 – WITH 5% CHANGE IN ORIGINAL PARAMETERS

DATA FOR CALCULATIONS :-

1. Drag Co-efficient (C_d) = 0.1995
2. Co-efficient of Rolling Resistance (= 0.00504
3. Motor Speed (N) = 12600 rpm
4. Frontal Area (A) = 1.911 m^2
5. Efficiency of Drive Coupling (ƞ_g) = 0.9975
6. Gross Weight (m) = 1617 Kg
7. Kerb Weight = 1470 Kg
8. Pay Load = 147 Kg
9. Gear Ratio (G) =11.55
10. Tire Radius = 0.315 m
11. Motor Torque (T_max) = 147 Nm
12. Critical Velocity (v) = 20.49 m/s
13. Critical Angular Speed (= 769.65 rad/s
14. Constant Power = 107.1 KW
15. Density of Air (`rho`) = 1.31 Kg/m^3
16. Velocity for limiting acceleration (v) = 37.59 m/s

CALCULATIONS :-

WKT for Motor Torque,

`T = (F*r)/G`

`F = (T*G)/r`

Here the force (F) is considered as tractive force (`F_(te)`),

`F_(te) = (T*G)/r`

WKT the Total Tractive Force,

`F_(te) = F_(rr) + F_(ad) + F_(la) + F_(omegaa)`

`(T*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m*a) + (I*(G^2/r^2)*(a/ƞ_g))`

`(T*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m) + (I*(G^2/(r^2*ƞ_g)))*(d_v/d_t)`

In most cases at low speeds, the maximum torque is a constant until the motor speed reaches a critical value `omega_c` (critical speed) after which the torque falls.

`So, T=T_max`

`(T_max*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m + (I*(G^2/(r^2*ƞ_g))))*(d_v/d_t)`

Here we don’t have the moment of Inertia (I) value because for a such huge vehicle it will be in negligible quantity. So we are adding 20 Kg more to the gross weight,

m = 1637 Kg (for acceleration alone)

By substituting the respective values,

`5384.61= 79.94 + (0.249*v^2) + 1637*(d_v/d_t)`

`(d_v/d_t) = 3.23 – 0.000152*v^2 --------- A`

Once the speed has reached the critical speed v = 20.49 m/s the torque (T) is,

WKT for Rotational Motion,

`P = tau*omega`

Angular Speed,

`omega = (v/r)*G`

Now,

`P = tau*omega`

`P = tau*((v/r)*G)`

Substituting the values,

`P = tau*((v/r)*G)`

`P = tau*((v/0.3)*11)`

`P = tau*v*37`

`tau = (P/(v*37))`

`tau = (107100/(v*37))`

`tau = 2894.59/v`

Now the equation becomes,

`(T*G)/r = (mu_{rr}*m*g) + (0.5*rho*A*C_d*v^2) + (m + (I*(G^2/(r^2*ƞ_g))))*(d_v/d_t)`

`((106028.832)/v) = 79.94 + (0.249*v^2) + 1637*(d_v/d_t)`

`(d_v/d_t) = (64.77/v) – 0.048 – 0.000152*v^2 -------- B`

The motor limits the acceleration of the vehicle when the vehicle attains the speed of 37.59 m/s i.e., 135.32 Kmph. Till this speed the vehicle accelerates after that it runs at constant speed so, no more acceleration is provided after 135.32 Kmph.

Equations A and B should be written in Finite Difference form,

`v_(n+1) = v_n + partial t*(3.23 – 0.000152*(v_n)^2) ------ C`

`v_(n+1) = v_n + partial t*((64.77/v_n) – 0.048 – 0.000152*(v_n)^2) -------- D`

CODE :-

% Clearing all previous memory in Workspace
clear all
% Clearing all previous memory in Workspace
close all
% Clearing all the values in Command Window
clc
 
% 5% change in parameters of GM EV1 Car
% Time(s) array	
t1 = linspace(0,50,201);

% Creating the velocity array of zeros to store the calculated values
% Velocity Array - (Defining before calculation
v1 = zeros(1,201);
 
% Differentiation time - dt (t = 0.1 s)
dt1= 0.1;
 
% Loop for velocity and distance calculation
for j = 1:200
    if v1(j)<20.49 % (w(omega) = 10.8 rad/s after Critical Speed)
        v1(j+1) = v1(j) + dt1*(3.23-(0.000152*(v1(j)^2)));
    elseif v1(j)>=37.59
        v1(j+1) = v1(j);
    else
        v1(j+1) = v1(j) + dt1*(((64.77)/v1(j))-0.048-(0.000152*(v1(j)^2)));
end
end

% Converting the velocity from (m/s) to Kmph
v1 = v1.*3.6;

% Plotting the time vs velocity graph
plot(t1,v1,'linewidth',1.5,'color','b');

% Turning on the grid in plot
grid on

% Providing label to the axes
xlabel('Time (s)')
ylabel('Velocity (Kmph)')

% Providing title to the plot
title('WOT (Wide Open Throttle) of GM EV1 Car')

PROGRAM PROCESS :-

1. The compiler starts the program.
2. It creates a time array ‘t1’ containing values from 0-50 sec.
3. Then creating velocity ‘v1’ vector with zeros to store the calculated values.
4. Differentiation time ‘dt1’ is checked for correct value.
5. The looping statement starts
6. Then the velocity ‘v1’ is calculated till 20.49 m/s i.e.,73.76 Kmph from equation C.
7. Then the compiler checks for the condition v>37.59 m/s i.e.,135.32 Kmph and if the condition fails it calculates the velocity from equation D.
8. If the condition v1>37.59 m/s i.e.,135.32 Kmph satisfies then it stops acceleration (calculating velocity) and it repeats the same velocity till the time value (constant speed).
9. The looping statement ends.
10. Then the velocity (m/s) is converted into Kmph.
11. Then graph is plotted between time and velocity.
12. Title is assigned to the axes.
13. Title is assigned to the plot.
14. Compiler stops the program.

OUTPUT :-

The graph is plotted between time and velocity.

COMPARISION OF PLOTS,

For comparison of the original parameters and change in 5% we are combining both the codes into single one.

CODE :-

% Clearing all previous memory in Workspace
clear all
% Clearing all previous memory in Workspace
close all
% Clearing all the values in Command Window
clc
 
% Original Parameters of GM EV1 Car
% Time(s) array	
t = linspace(0,50,201);

% Creating the velocity array of zeros to store the calculated values
% Velocity Array - (Defining before calculation
v = zeros(1,201);
 
% Differentiation time - dt (t = 0.1 s)
dt = 0.1;
 
% Loop for velocity and distance calculation
for i = 1:200
    if v(i)<19.8 % (w(omega) = 10.8 rad/s after Critical Speed)
        v(i+1) = v(i) + dt*(3.11-(0.000137*(v(i)^2)));
    elseif v(i)>=35.8
        v(i+1) = v(i);
    else
        v(i+1) = v(i) + dt*(((62.1)/v(i))-0.046-(0.000137*(v(i)^2)));
end
end

% Converting the velocity from (m/s) to Kmph
v = v.*3.6;

% 5% change in parameters of GM EV1 Car
% Time(s) array	
t1 = linspace(0,50,201);

% Creating the velocity array of zeros to store the calculated values
% Velocity Array - (Defining before calculation
v1 = zeros(1,201);
 
% Differentiation time - dt (t = 0.1 s)
dt1= 0.1;
 
% Loop for velocity and distance calculation
for j = 1:200
    if v1(j)<20.49 % (w(omega) = 10.8 rad/s after Critical Speed)
        v1(j+1) = v1(j) + dt1*(3.23-(0.000152*(v1(j)^2)));
    elseif v1(j)>=37.59
        v1(j+1) = v1(j);
    else
        v1(j+1) = v1(j) + dt1*(((64.77)/v1(j))-0.048-(0.000152*(v1(j)^2)));
end
end

% Converting the velocity from (m/s) to Kmph
v1 = v1.*3.6;

% Plotting the time vs velocity graph
plot(t,v,'linewidth',1.5,'color','r');
hold on
plot(t1,v1,'linewidth',1.5,'color','b');

% Turning on the grid in plot
grid on

% Providing label to the axes
xlabel('Time (s)')
ylabel('Velocity (Kmph)')

% Providing title to the plot
title('WOT (Wide Open Throttle) of GM EV1 Car')

% Providing the respective legends
legend('Original Parameters','5% change in Parameters','location','northwest')

PROGRAM PROCESS :-

1. The compiler starts the program.
2. It creates a time array ‘t’ containing values from 0-50 sec.
3. Then creating velocity ‘v’ vector with zeros to store the calculated values.
4. Differentiation time ‘dt’ is checked for correct value.
5. The looping statement starts
6. Then the velocity ‘v’ is calculated till 19.8 m/s i.e.,71.28 Kmph from equation C.
7. Then the compiler checks for the condition v>35.8 m/s i.e.,128.88 Kmph and if the condition fails it calculates the velocity from equation D.
8. If the condition v>35.8 m/s i.e.,128.88 Kmph satisfies then it stops acceleration (calculating velocity) and it repeats the same velocity till the time value (constant speed).
9. The looping statement ends.
10. Then the velocity (m/s) is converted into Kmph.
11. It creates a time array ‘t1’ containing values from 0-50 sec.
12. Then creating velocity ‘v1’ vector with zeros to store the calculated values.
13. Differentiation time ‘dt1’ is checked for correct value.
14. The looping statement starts
15. Then the velocity ‘v1’ is calculated till 20.49 m/s i.e.,73.76 Kmph from equation C.
16. Then the compiler checks for the condition v>37.59 m/s i.e.,135.32 Kmph and if the condition fails it calculates the velocity from equation D.
17. If the condition v1>37.59 m/s i.e.,135.32 Kmph satisfies then it stops acceleration (calculating velocity) and it repeats the same velocity till the time value (constant speed).
18. The looping statement ends.
19. Then the velocity (m/s) is converted into Kmph.
20. Then graph is plotted between time and velocity.
21. Title is assigned to the axes.
22. Title is assigned to the plot.
23. Legends are mentioned respectively.
24. Compiler stops the program.

OUTPUT :-

The plot for original parameters and 5% change in parameters is obtained.

CONCLUSION :-

We can verify the plots with the motor limit where there is no acceleration (constant speed) beyond,

1. Original Parameters (RED) – 128.88 Kmph
2. 5% change Parameters (BLUE) – 135.32 Kmph

MATLAB & SIMULINK FILES :-

1. Simulation Files
2. Drive Cycle

REFERENCES :-

1. https://indotrux.com/new-trucks/TATAULTRA-T7/1124
2. https://skill-lync.freshdesk.com/en/support/solutions/articles/43000571381-how-to-add-drive-cycle-to-the-driver-glider-model-file-in-matlabhttps://skill-lync.freshdesk.com/en/support/solutions/articles/43000576806-how-to-open-driver-glider-model-in-simulink
3. https://skill-lync.freshdesk.com/en/support/solutions/articles/43000572438-how-to-model-gm-ev1-car-for-wide-open-throttle-calculation
4. https://skill-lync.freshdesk.com/en/support/solutions/articles/43000576806-how-to-open-driver-glider-model-in-simulink