3DoF Helicopter Trim , Deceleration manouver simulation, Stability

HELICOPTER PERFORMANCE STABILITY AND CONTROL
COURSE CODE: AE4314
Name: DEEPAK PAUL TIRKEY
ASSIGNMENT NUMBER 05 Student number: 4590929
Question 1. Trim calculation in forward flight of a helicopter 3DoF longitudinal model for flight speeds
varying from hover to maximum forward speed.
Trim calculations have been performed using two methods:
1. TU Delft method
2. Bramwell’s method
TU Delft method:
Algorithm to compute main rotor collective 𝜃0 , and longitudinal cyclic 𝜃𝑐 :
𝜈𝑖0 = √
𝑊
2𝜌𝐴
hover induced inflow
𝜆𝑖 =
𝜈 𝑖0
𝑉 𝑡𝑖𝑝
initial starting value for λ
Iteration through fwd. velocity V starting from 0.0 m/s to 100.00 m/s in increments of 0.01 m/s
𝐷𝑓𝑢𝑠 =
1
2
∑ 𝐶𝐷𝑆 𝜌 𝑉2
fuselage drag
𝑇 = √𝑊2 + 𝐷𝑓𝑢𝑠
2
main rotor thrust
𝐶 𝑇 =
𝑇
𝜌𝐴𝑉 𝑡𝑖𝑝
2 thrust coefficient
𝛼 𝐷 =
𝐷 𝑓𝑢𝑠
𝑊
disc angle of attack
𝜇 =
𝑉
𝑉 𝑡𝑖𝑝
tip speed ratio
Now thrust coefficient is recalculated using Glauerts’ theory and iteration is performed using
improved value of 𝜆𝑖 till the difference between 𝐶 𝑇 and 𝐶 𝑇 𝑡𝑒𝑚𝑝
becomes less than 0.0001
do{
𝐶 𝑇 𝑡𝑒𝑚𝑝
= 2 𝜆𝑖√(𝜇 𝑐𝑜𝑠𝛼 𝐷)2 + (𝜇 𝑠𝑖𝑛𝛼 𝐷 + 𝜆𝑖)2
𝜆𝑖 = 𝜆𝑖 − 0.000001
} while(( 𝐶 𝑇 − 𝐶 𝑇 𝑡𝑒𝑚𝑝
)<= 0.0001)
Determinant computation using crammer’s rule
𝐷𝑒𝑡 = [
1 +
3
2
𝜇2
−
8
3
𝜇
−𝜇
2
3
+ 𝜇2
] eq. (121) AE4-314 reading
Det = 0.67-0.67*𝜇2
+1.5*𝜇4
𝑎1 =
(−2𝜇2
𝐷 𝑓𝑢𝑠
𝑊
)−(2𝜇𝜆𝑖)
𝐷𝑒𝑡
𝑎1 = 𝜃𝑐
𝜃0 =
4𝐶 𝑇
𝜎 𝑐 𝑙𝛼
+(𝜇
𝐷 𝑓𝑢𝑠
𝑊
)+(𝜆𝑖)
𝐷𝑒𝑡
The above algorithm was implemented using C++ in a source code named ‘trim.cpp’. It was compiled using
Dev-C++ V 7.4.2. It creates a .csv file named ‘trim.csv’ in the directory were trim.exe is located.
trim.csv data was analysed and plotted using MS EXCEL and is shown below in Fig 01.

COURSE CODE: AE4314
Source code listing of trim.cpp
/**************************************************************************
Trim of the helicopter using 3DoF longitudinal model for forward speeds
ranging from hover to maximum speed.
-Deepak Paul Tirkey
References:1. Memo M-756 by MD Pavel
2. Helicopter Performance stability and control
AE4-213 reading by T Van Holten
3. Lecture slides AE4-213 TU Delft by MD Pavel
4. Helicopter Flight Dynamics by G Padfield
for Bo105 data
**************************************************************************/
#include<math.h>
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
using namespace std;
int main()
{
//Bo105 Helicopter data declaration and initialization
double M=2200; //mass of the helicopter (kg)
double R=4.91; //radius
double V=0.0; //velocity (m/s)
double Dfus=0.0; //Fuselage drag force
double CDS=1.673; //Drag coeffi * Equivalent flat plate area
double W=0.0; //weight of the helicopter
double T=0.0; //rotor thrust
double CT=0.0; //thrust coeffi
double rho=1.225; //density ISA in kg/m^2
double Vtip=218; //Omega*R (m/sec)
double A=0.0; //rotor disc area Pi*R^2 (m^2)
double nui0=0.0; //nui for hovering case
double mu=0.0; //advance ratio
double lambdai=0.0; //induced inflow ratio
double sigma=0.07; //solidity
double cla=5.73; //lift curve slope
double a1=0.0; //longitudinal disc tilt angle
double thetac=0.0; //longitudinal cyclic
double theta0=0.0; //collective
double alfaD = 0.0; //Disc angle of attack
double CTtemp=0.0; //temporary storage of CT
double Det=0.0; //for calculation of a1 and theta0
//creates a csv file named trim.csv in the working directory
ofstream myfile;
myfile.open ("trim.csv");
int MSE=5;
int percent=25;

COURSE CODE: AE4314
W = M*9.81;
A = 3.14159*R*R;
//inserts heading into the trim.csv file
myfile <<"V (m/s)"<<","<<"thetaC (deg)"<<","<<"theta0 (deg)"<<endl;
nui0 = sqrt(W/(2*rho*A)); //Hover induced inflow
lambdai = nui0/Vtip; //initial starting value for lambda
for(V=0.0;V<100.0;) //iterate through helicopter velocity
{
Dfus = 0.5*CDS*rho*V*V; //fuselage drag
T = sqrt(W*W+Dfus*Dfus); //rotor thrust
CT = T/(rho*Vtip*Vtip*A);//thrust coeffi
alfaD = Dfus/W; //disc AoA
mu = V/Vtip; //tip speed ratio
do{
CTtemp =2*lambdai*sqrt((mu*cos(alfaD))*(mu*cos(alfaD))+
((mu*sin(alfaD))+lambdai)*((mu*sin(alfaD))+lambdai));
lambdai-=0.000001; //decrement of lambdai
}while((CT-CTtemp)<= 0.0001); //convergence criteria
Det = 0.67-0.67*mu*mu+1.5*mu*mu*mu*mu; //crammer rule eq. 121 (ref.2)
a1 = ((-2*mu*mu*Dfus/W)-(2*mu*lambdai))/Det;
theta0 = ((4*CT)/(sigma*cla)+mu*Dfus/W+lambdai)/Det;
myfile <<V<<","<<a1*-57.2958<<","<<theta0*57.2958<<endl;
printf("n V = %f",V);
V = V+0.01; //fwd velocity increment
}
myfile.close(); //close trim.csv file
printf("n Trim calculation complete");
printf("n trim.csv file created in the working directory");
printf("n press any key to continue");
getch();
return 0;
}
/*************************************************************************/

COURSE CODE: AE4314
Fig.01 Trim values of 𝜃0 and 𝜃𝑐 as a function of forward velocity
Bramwell’s method:
Algorithm to compute main rotor collective 𝜃0 , and longitudinal cyclic 𝜃𝑐(𝐵1) using Bramwell’s Helicopter
Dynamics:
𝑤𝑐 =
𝑊
𝜌𝑠𝐴Ω2 𝑅2 weight coefficient
s solidity
𝐴 = 𝜋𝑅2
area of main rotor disc
𝑡 𝑐 𝐷
= 𝑤𝑐 thrust coefficient in Disc plane
ℎ 𝑐 𝐷
=
1
4
𝜇𝛿 H force coefficient, where δ=0.013 blade profile drag coefficient
𝛼 𝐷 = −
(
1
2
𝑉̂2 𝑑0+ℎ 𝑐 𝐷
)
𝑡 𝑐 𝐷
angle of attack of Disc plane, where 𝑉̂ =
𝑉
Ω𝑅
and 𝑑0 =
𝑆 𝐹𝑃
𝑠𝐴
where 𝑆 𝐹𝑃 is equivalent flat plate area
𝜆 𝐷 = 𝑉̂ 𝑠𝑖𝑛𝛼 𝐷 − 𝜆𝑖
𝜆𝑖 = 𝜈𝑖0
̅̅̅̅
𝜈0
Ω𝑅
𝜈0 = √
𝑊
2𝜌𝐴
hover induced velocity
𝑉̅ = 𝑉̂ Ω𝑅
𝜈0

COURSE CODE: AE4314
𝜈𝑖0
̅̅̅̅ = √−
𝑉̅2
2
+ √
𝑉̅4
4
+ 1
With 𝜆 𝐷 value obtained, calculate collective pitch from
𝑡 𝑐 𝐷
=
𝑎
4
[
2
3
𝜃0
1−𝜇2+
9
4
𝜇4
1+
3
2
𝜇2
+ 𝜆 𝐷
1−
𝜇2
2
1+
3
2
𝜇2
]
or 𝜃0 =
3
2
[𝑡 𝑐 𝐷
(
4
𝑎
) − 𝜆 𝐷
1−
𝜇2
2
1+
3
2
𝜇2
] [
1+
3
2
𝜇2
1−𝜇2+
9
4
𝜇4
]
With 𝜃0 obtained previously, calculate 𝑎1
𝑎1 =
2𝜇(
4
3
𝜃0+𝜆 𝐷)
1+
3
2
𝜇2
Longitudinal cyclic pitch 𝐵1
𝐵1 = 𝑎1 +
ℎ 𝑐 𝐷
𝑤 𝑐
Where 𝜇 =
𝑉𝑐𝑜𝑠𝛼 𝑛𝑓
Ω𝑅
and 𝜇 𝐷 =
𝑉𝑐𝑜𝑠𝛼 𝐷
Ω𝑅
The above algorithm was implemented using C++ in a source code named ‘bramwelltrim.cpp’. It was compiled
using Dev-C++ V 7.4.2. It creates a .csv file named ‘bramwelltrim.csv’ in the directory were bramwelltrim.exe
is located.
bramwelltrim.csv data was analysed and plotted using MS EXCEL and is shown below in Fig 02.
Source code listing of bramwelltrim.cpp
/**************************************************************************
Trim of the helicopter using 3DoF longitudinal model for forward flight
speeds ranging from zero (hover) to maximum speed.
-Deepak Paul Tirkey
References:1. Bramwell's Helicopter Dynmaics
**************************************************************************/
#include<math.h>
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
int main()
{
float W=21582; //weight of the helicopter (N)
float R=4.91; //radius
float s=0.07; //solidity sigma
float tcD=0.0; //thrust coefficient
float wC=0.0; //weight coefficient

COURSE CODE: AE4314
float hcD=0.0; //H force coefficient
float d=0.013; //blade profile drag coefficient
float SFP=2.3; //equivalent flat plate area
float A=0.0; //rotor area
float d0=0.0; //ratio of SFP/sA
float mu=0.0;
float V=0.0; //helicopter velocity
float Vcap=0.0; //Vcap
float Vtip=218; //tip speed Omega*R (m/s)
float Vbar=0.0;
float nu0=0.0;
float rho=1.225;
float nui0bar=0.0;
float lambdai=0.0;
float alfaD=0.0;
float lambdaD=0.0;
float theta0=0.0; //collective
float a=5.73; //lift curve slope
float a1=0.0; //longitudinal disk tilt
float B1=0.0; //longitudinal cyclic
//creates a csv file named bramwelltrim.csv in the working directory
ofstream myfile;
myfile.open ("bramwelltrim.csv");
int MSE=5;
int percent=25;
//inserts heading into the bramwelltrim.csv file
Myfile <<"velo. (m/s)"<<","<<"theta0(deg)"<<","<<"thetaC(deg)"<<endl;
A = 3.14159*R*R;
d0=SFP/(s*A);
nu0 = sqrt(W/(2*rho*A)); //Hover induced inflow
for(V=0.0;V<100.0;) //iteration through helicopter velocity
{
Vcap = V/Vtip;
Vbar=V/nu0;
wC=W/(rho*s*A*Vtip*Vtip);
tcD=wC;
mu=V/Vtip; //first approximation
hcD=0.25*mu*d;
nui0bar=sqrt(-0.5*Vbar*Vbar+sqrt(0.25*Vbar*Vbar*Vbar*Vbar+1));
lambdai = nui0bar*nu0/Vtip;
alfaD=(-0.5*Vcap*Vcap*d0+hcD)/tcD;
lambdaD=Vcap*sin(alfaD)-lambdai;
mu=Vcap*cos(alfaD);
theta0=((4*tcD/a)-lambdaD*(1-0.5*mu*mu)
/(1+1.5*mu*mu))*1.5*(1+1.5*mu*mu)/(1-mu*mu+2.25*mu*mu*mu*mu);

COURSE CODE: AE4314
a1=2*mu*(1.33*theta0+lambdaD)/(1+1.5*mu*mu);
hcD=0.25*mu*d; //recalculation of hcD with improved mu
B1=a1+hcD/wC;
myfile <<V<<","<<theta0*57.2958<<","<<B1*57.2958<<endl;
V=V+0.2; //velocity increment by 0.2 m/s
}
myfile.close(); //close bramwelltrim.csv file
printf("n Trim calculation complete");
printf("n bramwelltrim.csv file created in the working directory");
getch();
return 0;
}
/*************************************************************************/
Fig.02 Trim values of 𝜃0 and 𝜃𝑐 as a function of forward velocity

COURSE CODE: AE4314
Question 2. Manoeuvre simulation: perform a numerical simulation and fly a DECELERATION
MANOEUVRE as part of Acceleration Deceleration manoeuver given by ADS-33.
Develop a P, PI or PID Pilot model to fly the manoeuvre.
DECELERATION MANOUVER SIMULATION USING 3DOF LONGITUDINAL MODEL
The simulation has been implemented in C++ programming language and has the following major
components:
1. 3DoF longitudinal helicopter model
2. PID pilot model
3. Output data logging in .csv file format which can be analysed later using MS Excel
Two separate simulations have been carried out:
A. 3dofsim01.cpp From 0 sec to 150 sec the helicopter attains fwd speed of 50 m/s . At 150 sec
deceleration manoeuvre is initiated.
B. 3dofsim02.cpp From 0 sec itself deceleration manoeuvre is initiated.
3DOF LONGITUDINAL HELICOPTER MODEL
3DoF helicopter model as described in reading AE4-314 by Theo Van Holten has been adapted with
the exception of 𝜈𝑖. Quasi dynamic inflow with a time constant of 𝜏 = 0.1 𝑠𝑒𝑐 has been
implemented.
PID PILOT MODEL
LONGITUDINAL CYCLIC CONTROL:
𝜃𝑐 = 𝑘1(𝜃𝑓 − 𝜃𝑓𝑑𝑒𝑠𝑖) + 𝑘2 𝑞 + 𝑘3 ∫ (𝜃𝑓 − 𝜃𝑓𝑑𝑒𝑠𝑖)𝑑𝜏
𝑡
0
eq. 01
𝜃𝑓𝑑𝑒𝑠𝑖 = 𝑘4(𝑥 𝑑𝑒𝑠𝑖 − 𝑥) + 𝑘5 𝑢 + 𝑘6 ∫ (𝑥 𝑑𝑒𝑠𝑖 − 𝑥)𝑑𝜏
𝑡
0
eq. 02
COLLECTIVE CONTROL:
𝜃0 = 𝜃0 𝑔𝑒𝑛
+ 𝑘7(𝑐 𝑑𝑒𝑠𝑖 − 𝑐) + 𝑘8 ∫ (𝑐 𝑑𝑒𝑠𝑖 − 𝑐)𝑑𝜏
𝑡
0
eq. 03
𝑐 𝑑𝑒𝑠𝑖 = 𝑘9(ℎ 𝑑𝑒𝑠𝑖 − ℎ) + 𝑘10 𝑐 eq. 04
GAINS:
GAIN k1 k2 k3 k4 k5 k6 k7 k8 k9 k10
VALUE 0.890 0.60 0.07 -0.000569 0.0168 0.00 0.06 0.050 0.0386 0.890
C++ PROGRAM VARIABLES:
LONGITUDINAL CYCLIC CONTROL:
dxdot 𝑥 𝑑𝑒𝑠𝑖 − 𝑥
dx ∫ (𝑥 𝑑𝑒𝑠𝑖 − 𝑥)𝑑𝜏
𝑡
0
thetafdesi 𝜃𝑓𝑑𝑒𝑠𝑖

COURSE CODE: AE4314
eq. 02 in terms of program variables:
thetafdesi=k4*dxdot+k5*u+k6*dx
dtfdot 𝜃𝑓 − 𝜃𝑓𝑑𝑒𝑠𝑖
dtf ∫ (𝜃𝑓 − 𝜃𝑓𝑑𝑒𝑠𝑖)𝑑𝜏
𝑡
0
thetac=k1*(dtfdot*180/3.14)+k2*q*180/3.14+k3*dtf*180/3.14
thetac=thetac*3.14/180
COLLECTIVE CONTROL:
dcdot 𝑐 𝑑𝑒𝑠𝑖 − 𝑐
dc ∫ (𝑐 𝑑𝑒𝑠𝑖 − 𝑐)𝑑𝜏
𝑡
0
cdesi=k9*(htdesi-ht)+k10*c
theta0=(5.00*3.14/180)+k7*dcdot+k8*dc
OUTPUT DATA LOGGING
At the end of the program run a file named helisim.csv is generated in the directory where the
executable 3dofsim01.exe or 3dofsim02.exe is located.
PID TUNING
The gains of the PID were determined by trial and error.
A. 3dofsim01.cpp PROGRAM SOURCE CODE
/**************************************************************************
3DoF longitudinal Helicopter simulator for MBB Bo105 helicopter for
deceleration manoeuvre with PID pilot model.
Deepak Paul Tirkey
2. Helicopter Performance stability and control AE4-213 reading
**************************************************************************/
#include<math.h>
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
int main()
{

COURSE CODE: AE4314
double m=2200.00; //mass of the helicopter (kg)
double Iy=4973.00; //pitch moment of inertia kg-m^2
double CDS=1.673; //equivalent flat plate area NASA CR 3579
double omega=44.4012; //rotor rad/sec
double R=4.91; //rotor radius
double gamma=5.07; //Locks inertia number
double a=5.7; //lift curve slope
double sigma=0.075; //solidity ratio
double rho=1.225; //density at ISA
double g=9.81;
double h=0.945; //height of the rotor above cg
double step=0.01; //for looping
double number=0;
//control variables
double theta0=8.7*3.14/180; //collective
double thetac=0.00*3.14/180; //longitudinal cyclic
//state variables
double u=00.001; //initial velo
double udot=0.0;
double w=0.0;
double wdot=0.0;
double q=0.0;
double qdot=0.0;
double thetaf=0.00*3.14/180; //fuselage pitch attitude (-ve nose down)
double thetafdot=0.0*3.14/180;
double V=0.0; //velocity of the helicopter (m/s)
double c=0.0; // vertical velo
double ht=0.00; //height above ground
double z=0.0;
double zdot=0.0;
double alfac=0.0*3.14/180; //AoA of CP
double lambdac=0.0; //total inflow ratio w.r.t. control plane
double lambdai=sqrt(m*g/(3.14*R*R*2*rho))/(omega*R);//induced inflow
ratio
double lambdaidot=0.0;
double tau=0.1; //time lag
double a1=0.0*3.14/180; //longitudinal disk tilt
double CTbem=0.0; //thrust coeffi through BEM theory
double CTglau=0.0; //thrust coeffi through Glauert
double A=0.0,B=0.0; //for CTglau calculation
double T=0.0; //thrust
double D=0.0; //drag
double phi=0.0*3.14/180;
double dtf=0.0;
double dtfdot=0.0;
double x=0.0;
double xdot=0.0;
double dx=0.0;
double dxdot=0.0;
double dc=0.0;
double dcdot=0.0;
double thetafdesi=0.0*3.14/180; // in rad
double xdesi=5866.74+2000.00; // 2 km from start of deceleration

COURSE CODE: AE4314
double cdesi=0.0;
double htdesi=100.00; //100 m altitude
//gains for PID pilot model
/*******for longitudinal cyclic**************************************/
double k1=0.890; //k1*(thetaf-thetafdesi)
double k2=0.60; //k2*q
double k3=0.07; //k3*INTEGRAL(thetaf-thetafdesi)
double k4=-0.000569; //k4*(xdesi-x)
double k5=0.0168; //k5*u
double k6=0.00; //k6*INTEGRAL(xdesi-x)
/*******for collective***********************************************/
double k7=0.06; //k7*(cdesi-c)
double k8=0.050; //k8*INTEGRAL(cdesi-c)
double k9=0.0386; //k9*(htdesi-ht)
double k10=0.890; //k10*c
/*******end of PID gains*********************************************/
//creates a csv file named helisim.csv in the working directory
ofstream myfile;
myfile.open ("helisim.csv");
int MSE=5;
int percent=25;
//inserts heading into the helisim.csv file
myfile <<"Time (s)"<<","<<"u (m/s)"<<","<<"thetaf(deg)"<<","<<"theta0
(deg)"<<","<<"thetac (deg)"<<","<<"Hori. dist. (m)"<<","<<"Height
(m)"<<","<<"vertical velo. (m/s)"<<","<<"w (m/s)" <<","<<"q"<<endl;
for(number=0;number<=300;)
{
// correction for alfac
if(u==0.0){ if(w>0.0) phi=1.57;
else if(w==0.00) phi=0.0;
else phi=-1.57;}
else phi=atan(w/u);
if(u<0.0) phi=phi+3.14;
alfac = thetac-phi;
V = sqrt(u*u+w*w); //helicopter fwd velocity
mu = (V/(omega*R))*cos(alfac);
lambdac = (V/(omega*R))*sin(alfac);
//calculate longitudinal disk tile angle
a1 = (2.67*mu*theta0-2*mu*(lambdac+lambdai)-(16*q)/(gamma*omega))/
(1-0.5*mu*mu);
//Thrust coeffi according to BEM theory
CTbem = 0.25*a*sigma*(0.67*theta0*(1+1.5*mu*mu)-(lambdac+lambdai));
//Thrust coefficient according to Glauert theory
A = (V*cos(alfac-a1)/(omega*R))*(V*cos(alfac-a1)/(omega*R));
B = (V*sin(alfac-a1)/(omega*R)+lambdai)*
(V*sin(alfac-a1)/(omega*R)+lambdai);
CTglau = 2*lambdai*sqrt(A+B);

COURSE CODE: AE4314
T = 3.14*CTbem*rho*omega*omega*R*R*R*R;
D = CDS*0.5*rho*V*V;
/********Euler integration *****************************************/
udot = -g*sin(thetaf)-(D*u)/(m*V)+T*sin(thetac-a1)/m-q*w;
wdot = g*cos(thetaf)-(D*w)/(m*V)-T*cos(thetac-a1)/m+q*u;
qdot = -T*h*sin(thetac-a1)/Iy;
thetafdot =q;
xdot = u*cos(thetaf)+w*sin(thetaf);
zdot =-c;
lambdaidot = (CTbem-CTglau)/tau;
u += udot*step;
w += wdot*step;
q += qdot*step;
thetaf += thetafdot*step;
x +=xdot*step;
z +=zdot*step;
lambdai += lambdaidot*step;
/********PID pilot action*******************************************/
//longitudinal cyclic control
if(number==150){xdesi=5866.74+2000.00;}
dxdot=xdesi-x;
dx=dx+dxdot*step;
thetafdesi=k4*dxdot+k5*u+k6*dx;
if(number<150){thetafdesi=-7.00*3.14/180;}
dtfdot=thetaf-thetafdesi;
dtf=dtf+dtfdot*step;
thetac=k1*(dtfdot*180/3.14)+k2*q*180/3.14+k3*dtf*180/3.14;
thetac=thetac*3.14/180; //final longi cyclic control
//collective control
c=u*sin(thetaf)-w*cos(thetaf);
ht=-z;
cdesi=k9*(htdesi-ht)+k10*c;
dcdot=(cdesi-c);
dc=dc+dcdot*step;
theta0=(5.00*3.14/180)+k7*dcdot+k8*dc; //final collective control
/*******End of PID pilot action*******************************************/
printf("n number=%f",number);
myfile <<number<<","<<u<<","<<thetaf*57.325<<","<<theta0*57.325<<","
<<thetac*57.325<<","<<x<<","<<ht<<","<<c<<","<<w<<","<<q<<endl;
number +=step;
} // end of for loop
myfile.close(); //close helisim.csv file
printf("n simulation complete ");
printf("n helisim.csv file created in the working directory");
getch();
return 0;
}

COURSE CODE: AE4314
/*************************************************************************/
SIMULATION RESULT ANALYSIS
Fig.03 Deceleration manoeuvre simulation result
Deceleration manoeuvre has been carried out in 4 phases. (refer Fig. 03)
Phase 1: Helicopter starts with zero forward velocity, zero altitude
Phase 2: Helicopter builds up forward velocity of about 50 m/s, attains an altitude of 100 m.
This phase of the flight lasts up to 150 second.
Phase 3 & 4: Deceleration part of the manoeuver starts at 150 second. The objective of this
flight phase is to stop after 2 km from this point on while maintaining constant altitude and
hold the hover for at least 5 seconds.
The simulation state variables have been plotted in different figures below.
Fig.04 Plot of Horizontal distance covered (m x 50), Altitude (m) and u (m/sec)
Fig.05 Plot of 𝜃𝑓𝑢𝑠𝑒 Fuselage pitch attitude (degree)
Fig.06 Plot of 𝜃0 Main rotor collective (degree)
Fig.07 Plot of 𝜃𝑐 Longitudinal cyclic (degree)
Fig.08 Plot of 𝜃𝑐 Longitudinal cyclic (degree) from 145 second to 180 second
Fig.09 Plot of Vertical velocity (m/s) and w (m/s)
Fig.10 Plot of q (rad/s)

COURSE CODE: AE4314
Fig.04 Plot of Horizontal distance covered (m x 50), Altitude (m) and u (m/sec)
ALTITUDE (m): The simulation starts with 0 m altitude which rises rapidly to settle at 100 m height
after a small oscillation and remains constant throughout except at 150 second when the
deceleration manoeuvre is initiated. When the longitudinal cyclic stick is pulled back to slowdown
the forward velocity of the helicopter, the nose of the helicopter pitches up and the helicopter
begins to climb. Main rotor collective is lowered to maintain the altitude.
U (m/s): The simulation starts with 0.001 m/s speed (to avoid numerical instability) and builds up a
speed of 50 m/s during phase 2. At 150 second (phase 3) when the deceleration is initiated, the
speed is gradually reduced to 0 m/s as the target is reached in phase 4.
HORIZONTAL DISTANCE (m x 50): The requirement of the deceleration manoeuvre is to stop at a
target after 2 km from the point of initiation of the deceleration. As my simulation starts with 0 m/s
fwd speed and builds up speed upto 50 m/s , the helicopter already covers a horizontal distance of
5866.74 meters upto phase 3. Therefore, the deceleration manoeuvre is continued for
5866.74+2000.00 meters.

COURSE CODE: AE4314
Fig.05 Plot of 𝜃𝑓𝑢𝑠𝑒 Fuselage pitch attitude (degree)
Helicopter starts from hover with 0 pitch attitude, attains an initial (larger) nose down pitch attitude
of - 7.2 degree which reduces to -6.3 degree during phase 2. During phase 2 of flight helicopter
attains a forward speed of about 50 m/s. At 150 second (phase 3) when deceleration is abruptly
initiated, the nose pitches up to +31.7 degree (at 151 sec) and the helicopter rapidly loses forward
speed. By 210 sec the fuselage pitch becomes 0 again as the helicopter reaches the target and begins
to hover.
Fig.06 Plot of 𝜃0 Main rotor collective (degree)
During phase 1, initially the main rotor collective is 18.3 degree which momentarily increases to 18.9
degree and falls rapidly and settles at 7.8 degree during (phase 2) 50 m/s forward flight. At 150
second when the deceleration manoeuvre is initiated, main rotor collective is lowered rapidly from
7.7 degree to prevent rise in altitude as the longitudinal cyclic is pulled back to initiate deceleration.
During phase 4 , collective is held at 8.15 degree to hover above the target.

COURSE CODE: AE4314
Fig.07 Plot of 𝜃𝑐 Longitudinal cyclic (degree)
Fig.08 Plot of 𝜃𝑐 Longitudinal cyclic (degree) from 145 second to 180 second
Looking at both the Fig 07 and Fig 08; At phase 1, longitudinal cyclic is 6.2 degree. Which
falls to 0 and gradually rises to 3.5 degree (phase 2) during which the helicopter attains a
forward speed of 50 m/s. At 150 second, the pilot rapidly pulls back the longitudinal stick
back to decrease the forward speed and then forward to 8.4 degree and then gradually
lowers to 0 degree to bring the helicopter to hover above the target.
[note: at the start (phase 1) and initiation of deceleration (phase 3), the controls take time to
stabilize and exhibit unrealistic values, after stabilization the values obtained are
reasonable]

COURSE CODE: AE4314
Fig.09 Plot of Vertical velocity (m/s) and w (m/s)
Vertical velocity starts with 0 m/s at phase 1 and rapidly increases to 23 m/s till 100 m of
altitude is attained. As the altitude overshoots and oscillates about 100 m, the vertical
velocity too oscillates about 0 m/s. The same observations repeat at 150 second.
Fig.10 Plot of q (rad/s)
Except at time 0 sec and 150 second the q remains nearly zero during stable phases (2 and
4) of forward flight at 50 m/s and hover after reaching the target.
B. 3dofsim02.cpp PROGRAM SOURCE CODE
/*******************************************************************
3DoF longitudinal Helicopter simulator for MBB Bo105
Deepak Paul Tirkey

COURSE CODE: AE4314
2. Helicopter Performance stability and control
AE4-213 reading by T Van Holten
*******************************************************************/
#include<math.h>
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
int main()
{
double m=2200.00; //mass of the helicopter (kg)
double Iy=4973.00; //pitch moment of inertia kg-m^2
double CDS=1.673; //equi flat plate area NASA CR 3579
double omega=44.4012; //rotor rad/sec
double R=4.91; //rotor radius
double gamma=5.07; //Locks inertia number
double a=5.7; //lift curve slope
double sigma=0.075; //solidity ratio
double rho=1.225; //density at ISA
double g=9.81;
double h=0.945; //height of the rotor above cg
double step=0.01; //for looping
double number=0;
//control variables
double theta0=8.7*3.14/180; //collective
double thetac=4.3*3.14/180; //longitudinal cyclic
//state variables
double u=50.00; //initial velo 50 m/s
double udot=0.0;
double w=0.0;
double wdot=0.0;
double q=0.0;
double qdot=0.0;
double thetaf=-7.3*3.14/180; //fuselage pitch attitude
double thetafdot=0.0*3.14/180;
double V=0.0; //velocity of the helicopter (m/s)
double c=0.0; // vertical velo
double ht=0.0; //height above ground
double z=0.0;
double zdot=0.0;

COURSE CODE: AE4314
double alfac=0.0*3.14/180; //AoA of CP
double lambdac=0.0; //total inflow ratio w.r.t. CP
double lambdai=sqrt(m*g/(3.14*R*R*2*rho))/(omega*R); //induced
inflow ratio
double lambdaidot=0.0;
double tau=0.1; //time lag
double a1=0.0*3.14/180; //longitudinal disk tilt
double CTbem=0.0; //thrust coeffi through BEM theory
double CTglau=0.0; //thrust coeffi through Glauert
double A=0.0,B=0.0; //for CTglau calculation
double T=0.0; //thrust
double D=0.0; //drag
double phi=0.0*3.14/180;
double dtf=0.0;
double dtfdot=0.0;
double x=0.0;
double xdot=0.0;
double dx=0.0;
double dxdot=0.0;
double dc=0.0;
double dcdot=0.0;
double thetafdesi=0.0*3.14/180; // in rad
double xdesi=2000.0; // 2 km from starting point
double cdesi=0.0;
double htdesi=100; //100 m above ground
//gains for PID pilot model
/*****for longitudinal cyclic*********************************/
double k1=0.890; //k1*(thetaf-thetafdesi)
double k2=0.60; //k2*q
double k3=0.000143; //k3*INTEGRAL(thetaf-thetafdesi)
double k4=-0.000569; //k4*(xdesi-x)
double k5=0.0138; //k5*u
double k6=0.00; //k6*INTEGRAL(xdesi-x)
/*******for collective****************************************/
double k7=0.06; //k7*(cdesi-c)
double k8=0.050; //k8*INTEGRAL(cdesi-c)
double k9=0.0386; //k9*(htdesi-ht)
double k10=0.890; //k10*c
/*******end of PID gains**************************************/
//creates a csv file named helisim.csv in the working directory
ofstream myfile;
myfile.open ("helisim.csv");

COURSE CODE: AE4314
int MSE=5;
int percent=25;
//inserts heading into the helisim.csv file
myfile <<"number"<<","<<"V m/s"<<","<<"thetaf deg"<<","<<"theta0
deg"<<","<<"thetac deg"<<","<<"x"<<","<<"ht"<<endl;
for(number=0;number<=200;)
{
// correction for alfac
if(u==0.0){ if(w>0.0) phi=1.57;
else if(w==0.00) phi=0.0;
else phi=-1.57;}
else phi=atan(w/u);
if(u<0.0) phi=phi+3.14;
alfac = thetac-phi;
V = sqrt(u*u+w*w); //helicopter fwd velocity
mu = (V/(omega*R))*cos(alfac);
lambdac = (V/(omega*R))*sin(alfac);
//calculate longitudinal disk tile angle
a1 = (2.67*mu*theta0-2*mu*(lambdac+lambdai)-
(16*q)/(gamma*omega))/(1-0.5*mu*mu);
//Thrust coeffi according to BEM theory
CTbem = 0.25*a*sigma*(0.67*theta0*(1+1.5*mu*mu)-
(lambdac+lambdai));
//Thrust coefficient according to Glauert theory
A = (V*cos(alfac-a1)/(omega*R))*(V*cos(alfac-a1)/(omega*R));
B = (V*sin(alfac-a1)/(omega*R)+lambdai)*(V*sin(alfac-a1)/
(omega*R)+lambdai);
CTglau = 2*lambdai*sqrt(A+B);
T = 3.14*CTbem*rho*omega*omega*R*R*R*R;
D = CDS*0.5*rho*V*V;
/********Euler integration **********************************/
udot = -g*sin(thetaf)-(D*u)/(m*V)+T*sin(thetac-a1)/m-q*w;
wdot = g*cos(thetaf)-(D*w)/(m*V)-T*cos(thetac-a1)/m+q*u;
qdot = -T*h*sin(thetac-a1)/Iy;

COURSE CODE: AE4314
thetafdot =q;
xdot = u*cos(thetaf)+w*sin(thetaf);
zdot =-c;
lambdaidot = (CTbem-CTglau)/tau;
u += udot*step;
w += wdot*step;
q += qdot*step;
thetaf += thetafdot*step;
x +=xdot*step;
z +=zdot*step;
lambdai += lambdaidot*step;
/********PID pilot action************************************/
//longitudinal cyclic control
dxdot=xdesi-x;
dx=dx+dxdot*step;
thetafdesi=k4*dxdot+k5*u+k6*dx;
dtfdot=thetaf-thetafdesi;
dtf=dtf+dtfdot*step;
thetac=k1*(dtfdot*180/3.14)+k2*q*180/3.14+k3*dtf*180/3.14;
thetac=thetac*3.14/180; //final longi cyclic control
//collective control
c=u*sin(thetaf)-w*cos(thetaf);
ht=-z;
cdesi=k9*(htdesi-ht)+k10*c;
dcdot=(cdesi-c);
dc=dc+dcdot*step;
theta0=(5.01*3.14/180)+k7*dcdot+k8*dc;//final colle control
/*******End of PID pilot action******************************/
printf("n number=%f",number);
myfile
<<number<<","<<V<<","<<thetaf*57.325<<","<<theta0*57.325
<<","<<thetac*57.325<<","<<x<<","<<ht<<endl;
number +=step;
} // end of for loop
myfile.close(); //close helisim.csv file
printf("n end of simulation ");
getch();
return 0;
}
/******************************************************************/

COURSE CODE: AE4314
SIMULATION RESULT ANALYSIS
Fig.11 Deceleration manoeuvre simulation result
Helicopter starts with 50 m/s forward velocity.
Deceleration part of the manoeuver starts at 0 second. The objective of this manoeuvre is to stop
after 2 km from this point on while maintaining constant altitude and hold the hover for at least 5
seconds after reaching the target.
The simulation state variables have been plotted in different figures below.
Fig.12 Plot of Horizontal distance covered (m x 50) and Altitude (m)
Horizontal distance of 2000 m from start is covered within 134 second.
Simulation starts with 0 altitude, after an initial overshoot upto 108 m in 10 second, the altitude
settles at 100 meter.

COURSE CODE: AE4314
Fig.13 Plot of forward velocity V (m/s)
The simulation starts with 50 m/s forward speed, due to initial nose down pitch attitude, the speed
increases upto 61 m/s and then gradually reduces to zero after reaching the target (2 km)
Fig. 14 Plot of 𝜃𝑓𝑢𝑠𝑒 Fuselage pitch attitude (degree), 𝜃0 Main rotor collective (degree) and
𝜃𝑐 Longitudinal cyclic (degree)
𝜃𝑓𝑢𝑠𝑒 starts with -7.3 degree which increases further to -14 degree. With longitudinal cyclic
stick gradually pulled back; 𝜃𝑓𝑢𝑠𝑒 begins to come to zero but overshoots and settles at zero
after reaching the target. 𝜃𝑐 is gradually reduced from 16 degree to 0 degree on reaching

COURSE CODE: AE4314
the target. 𝜃0 starts from 20.8 degree, initially rises upto 22 degree then falls rapidly to 5
degree, then gradually attains hover value of 8.15 degree when target is reached.
Question 3. Stability: For the chosen helicopter, calculate the frequency and damping
characteristics of the phugoid mode in hover using phugoid approximation. Show how the
PID controllers developed to fly the manoeuvre are affecting the phugoid mode
characteristics (frequency and damping)
STABILITY DERIVATIVE CALCULATIONS: Stability derivative calculations are based on Bramwell’s
Helicopter Dynamics. It has been implemented using C++ in a source code named
‘stabilityderivatives.cpp’. It creates a csv file named stabilityderivatives.csv in the working
directory.
stabilityderivatives.cpp Source code
/**************************************************************************
Stability derivatives
-Deepak Paul Tirkey
References:1. Bramwell's Helicopter Dynamics
**************************************************************************/
#include<math.h>
#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<fstream>
int main()
{
float W=21582; //weight of the helicopter (N)
float R=4.91; //radius
float Iyy=4973; //kg-m^2
float gamma=5.07; //Lock’s inertia
float s=0.07; //solidity sigma
float tcD=0.0; //thrust coefficient wrt Disc plane
float tc=0.0;
float wC=0.0; //weight coefficient
float hcD=0.0; //H force coefficient
float d=0.013; //blade profile drag coefficient
float SFP=2.3; //equivalent flat plate area
float A=0.0; //rotor area
float d0=0.0; //ratio of SFP/sA
float mu=0.0;
float V=0.0; //helicopter velocity
float Vcap=0.0; //Vcap
float Vtip=218; //tip speed Omega*R (m/s)
float Vbar=0.0;
float nu0=0.0;
float rho=1.225;
float nui0bar=0.0;
float nuibar=0.0;
float lambdai=0.0;
float alfaD=0.0;
float lambdaD=0.0;
float theta0=0.0; //collective

COURSE CODE: AE4314
float a=5.73; //lift curve slope
float a1=0.0; //longitudinal disk tilt
float B1=0.0; //longitudinal cyclic
float l=0.0;
float h=0.1924; //M-756
float a1s=0.0;
float alfaNF=alfaD-a1; //pg 151 AoA of No Feathering Plane
float xu=0.0,xw=0.0,xq=0.0;
float zu=0.0,zw=0.0,zq=0.0;
float mud=0.0,mw=0.0,mq=0.0; // mud to distinguish with mu
float mup=0.0,mwp=0.0,mqp=0.0; // prime values
// control
float xB1=0.0,xT0=0.0;
float zB1=0.0,zT0=0.0;
float mB1=0.0,mT0=0.0;
float mB1p=0.0,mT0p=0.0;
float dlambdai_dT0=0.0;
float dlambdaD_dT0=0.0;
// mu derivatives
float da1_dmu=0.0;
float dtc_dmu=0.0;
float dhcd_dmu=0.0;
// w derivatives
float da1_dw=0.0;
float dtc_dw=0.0;
float dhcd_dw=0.0;
// q derivatives
float da1_dq=0.0;
float dtc_dq=0.0;
float dhcd_dq=0.0;
//B1 control derivatives
float da1_dB1=0.0;
float dtc_dB1=0.0;
float dhcd_dB1=0.0;
//Theta0 T0 control derivatives
float da1_dT0=0.0;
float dtc_dT0=0.0;
float dhcd_dT0=0.0;
float dlambdai_dmu=0.0;
float dlambda_dmu=0.0;
A = 3.14159*R*R;
float mus=W/(9.81*rho*s*A*R); //mu star page 142
float iB=Iyy/(W*R*R/9.81); // page 142
//creates a csv file named stabilityderivatives.csv in the working
directory
ofstream myfile;
myfile.open ("stabilityderivatives.csv");
int MSE=5;

COURSE CODE: AE4314
int percent=25;
//inserts heading into the stabilityderivatives.csv file
myfile<<"velo(m/s)"<<","<<"theta0(deg)"<<","<<"thetaC(deg)"<<","<<"xu"<<","
<<"xw"<<","<<"xq"<<","<<"zu"<<","<<"zw"<<","<<"zq"<<","<<"mup"<<","<<"mwp"
<<","<<"mqp"<<","<<"mud(mu)"<<","<<"mw"<<","<<"mq"<<","<<"xB1"<<","<<"zB1"
<<","<<"mB1p"<<","<<"xT0"<<","<<"zT0"<<","<<"mT0p"<<endl;
d0=SFP/(s*A);
nu0 = sqrt(W/(2*rho*A)); //Hover induced inflow
for(V=0.0;V<100.0;) //cycle through helicopter velocity
{
Vcap = V/Vtip;
Vbar=V/nu0;
wC=W/(rho*s*A*Vtip*Vtip);
tcD=wC;
tc=wC;
mu=V/Vtip; //first approximation
hcD=0.25*mu*d;
nui0bar=sqrt(-0.5*Vbar*Vbar+sqrt(0.25*Vbar*Vbar*Vbar*Vbar+1));
nuibar=nui0bar;
lambdai = nui0bar*nu0/Vtip;
alfaD=(-0.5*Vcap*Vcap*d0+hcD)/tcD;
lambdaD=Vcap*sin(alfaD)-lambdai;
mu=Vcap*cos(alfaD);
theta0=((4*tcD/a)-lambdaD*(1-0.5*mu*mu)/
(1+1.5*mu*mu))*1.5*(1+1.5*mu*mu)/(1-mu*mu+2.25*mu*mu*mu*mu);
a1=2*mu*(1.33*theta0+lambdaD)/(1+1.5*mu*mu);
hcD=0.25*mu*d; //recalculation of hcD with improved mu
B1=a1+hcD/wC;
a1s=a1-B1;
//determination of mu derivatives
//da1_dmu
dlambdai_dmu=(2*mu*theta0+alfaNF-((4*tc)/(a*lambdai))
*Vbar*nuibar*nuibar*nuibar)/(1+(4/a)*(tc/lambdai)*
(1+nuibar*nuibar*nuibar*nuibar)); //eq 5.60
dlambda_dmu=alfaNF-dlambdai_dmu; //eq 5.57
da1_dmu=a1/mu-(2*mu*dlambda_dmu)/(1-0.5*mu*mu); //eq 5.64
//dtc_dmu
dtc_dmu=(2*mu*theta0+alfaNF+(Vbar*nuibar*nuibar*nuibar)/
(1+nuibar*nuibar*nuibar*nuibar))/((4/a)+(lambdai/tc)/
//dhcd_dmu
dhcd_dmu=0.25*d; //eq 5.66
//determination of w derivatives
//da1_dw
da1_dw=2*mu/((1-0.5*mu*mu)*
(1+0.25*a*lambdai/tc+nuibar*nuibar*nuibar*nuibar)); //eq 5.75
//dtc_dw

COURSE CODE: AE4314
dtc_dw=0.25*a/(1+0.25*a*lambdai/tc+nuibar*nuibar*nuibar*nuibar);
//eq 5.74
//dhcd_dw
dhcd_dw=dtc_dw*(0.5*a1-mu*theta0+mu*lambdaD/(1-0.5*mu*mu)); //eq 5.77
//determination of q derivatives
//da1_dq
da1_dq=(-16/gamma)/(1-0.5*mu*mu); //eq 5.82
//dtc_dq
dtc_dq=0.0;
//dhcd_dq
dhcd_dq=0.25*a*(0.5*lambdaD+mu*a1-mu*mu*theta0)*da1_dq; //eq 5.87
// equations
xu=-tc*da1_dmu-alfaD*dtc_dmu-dhcd_dmu; //eq 5.41
xw=-tc*da1_dw-alfaD*dtc_dw-dhcd_dw; //eq 5.43
xq=-tc*da1_dq-alfaD*dtc_dq-dhcd_dq;
zu=-dtc_dmu; //eq 5.42
zw=-dtc_dw; //eq 5.44
zq=-dtc_dq; //eq 5.46
mup=-(l-h*a1s)*dtc_dmu+h*(tc*da1_dmu+dhcd_dmu); //eq 5.53
mwp=-(l-h*a1s)*dtc_dw+h*(tc*da1_dw+dhcd_dw); //eq 5.54
mqp=-(l-h*a1s)*dtc_dq+h*(tc*da1_dq+dhcd_dq); //eq 5.55
mud=mus*mup/iB; //page 150 here mud is Mu
mw=mus*mwp/iB;
mq=mqp/iB;
//B1 control derivatives
da1_dB1=-mu*da1_dw; //eq 5.144
dtc_dB1=-mu*dtc_dw; //eq 5.142
dhcd_dB1=-mu*dhcd_dw; //eq 5.143
//Theta0 T0 control derivatives
dtc_dT0=(a/6.0)*(1+1.5*mu*mu)/(1+(0.25*a*lambdai/tc)*
dlambdai_dT0=((lambdai/tc)*dtc_dT0)/(1+nuibar*nuibar*nuibar*nuibar);
//eq 5.151
da1_dT0=((2*mu)/(1-0.5*mu*mu))*(1.33-dlambdai_dT0); //page 182
dlambdaD_dT0=mu*da1_dT0-dlambdai_dT0; //page 183
dhcd_dT0=(0.125*a)*((a1*dlambdaD_dT0+lambdaD*da1_dT0)-
2*mu*(lambdaD+theta0*dlambdaD_dT0)); //eq 5.157
//equations
xB1=dtc_dB1*alfaD+tc*(1+mu*da1_dw)-dhcd_dB1; //eq 5.147
zB1=-dtc_dB1; //eq 5.148
mB1p=-(l-h*a1s)*dtc_dB1-(tc*h)*(1+mu*da1_dw)+h*dhcd_dB1; //eq 5.150
mB1=mus*mB1p/iB;
//equations
xT0=-tc*da1_dT0-alfaD*dtc_dT0-dhcd_dT0; //eq 5.158
zT0=-dtc_dT0; //eq 5.159
mT0p=-(l-h*a1s)*dtc_dT0+(tc*h)*da1_dT0+h*dhcd_dT0; //eq 5.161

COURSE CODE: AE4314
mT0=mus*mT0p/iB;
myfile<<V<<","<<theta0*57.2958<<","<<B1*57.2958<<","<<xu<<","<<xw<<","
<<xq<<","<<zu<<","<<zw<<","<<zq<<","<<mup<<","<<mwp<<","<<mqp
<<","<<mud<<","<<mw<<","<<mq<<","<<xB1<<","<<zB1<<","<<mB1p
<<","<<xT0<<","<<zT0<<","<<mT0p<<endl;
V=V+0.2; //velocity increment by 0.2 m/s
}
myfile.close(); //close stabilityderivatives.csv file
printf("n STABILITY AND CONTROL DERIVATIVES:n");
printf("n stabilityderivatives.csv file generated");
getch();
return 0;
}
/*************************************************************************/
STABILITY DERIVATIVE PLOTS:
The results of stability derivative calculations are plotted below.
Fig.15 Plot of 𝑥 𝑢 , 𝑥 𝑤 , 𝑥 𝑞
Fig.16 Plot of 𝑧 𝑢 , 𝑧 𝑤 , 𝑧 𝑞
Fig.17 Plot of 𝑚 𝑢
′
, 𝑚 𝑤
′
, 𝑚 𝑞
′
Fig.18 Plot of 𝑚 𝑢 , 𝑚 𝑤 , 𝑚 𝑞
Fig.19 Plot of 𝑥 𝐵1 , 𝑧 𝐵1 , 𝑚 𝐵1́
Fig.20 Plot of 𝑥 𝑇0 , 𝑧 𝑇0 , 𝑚 𝑇0́

COURSE CODE: AE4314
Fig.15 Plot of 𝒙 𝒖 , 𝒙 𝒘 , 𝒙 𝒒
Fig.16 Plot of 𝒛 𝒖 , 𝒛 𝒘 , 𝒛 𝒒

COURSE CODE: AE4314
Fig.17 Plot of 𝒎 𝒖
′
, 𝒎 𝒘
′
, 𝒎 𝒒
′
Fig.18 Plot of 𝒎 𝒖 , 𝒎 𝒘 , 𝒎 𝒒

COURSE CODE: AE4314
Fig.19 Plot of 𝒙 𝑩𝟏 , 𝒛 𝑩𝟏 , 𝒎 𝑩𝟏́
Fig.20 Plot of 𝒙 𝑻𝟎 , 𝒛 𝑻𝟎 , 𝒎 𝑻𝟎́
HOVER PHUGOID APPROXIMATION:
State space form of equation [ref memo M-756]
Ẋ = AX + BU
U = KX
Ẋ = AX + BKX
Ẋ = [A + BK]X

COURSE CODE: AE4314
Where
𝐴 = [
𝑥 𝑢 −𝑤𝑐 𝑐𝑜𝑠𝜏 𝑐 𝑥 𝑞
0 0 1
𝑚 𝑢 + 𝑧 𝑢 𝑚 𝑤̇ −𝑚 𝑤̇ 𝑤𝑐 𝑠𝑖𝑛𝜏 𝑐 𝑚 𝑞 + 𝑚 𝑤̇ (𝑉̂ + 𝑧 𝑞)
]
𝐵 = [
𝑥 𝐵1
𝑥 𝜃0
0 0
𝑚 𝐵1
+ 𝑚 𝑤̇ 𝑧 𝐵1
𝑚 𝜃0
+ 𝑚 𝑤̇ 𝑧 𝜃0
]
𝐾 = [0 𝑘 𝜃
𝑘 𝑞
𝑡̂
0 0 0
]
Stability derivative data for Bo105 helicopter for Hover:
𝑥 𝑢 = −0.02375 𝑥 𝑤 = 0.00 𝑥 𝑞 = 0.108849
𝑧 𝑢 = 0.00 𝑧 𝑤 = −0.47537 𝑧 𝑞 = 0.00
𝑚 𝑢
′
= 0.00457 𝑚 𝑤
′
= 0.00 𝑚 𝑞
′
= −0.02094
𝑚 𝑢 = 3.3624 𝑚 𝑤 = 0.00 𝑚 𝑞 = −0.22336
𝑥 𝐵1 = 0.069925 𝑧 𝐵1 = 0.00 𝑚 𝐵1 = −9.899204
𝑥 𝜃0
= 0.0 𝑧 𝜃0
= −0.3155 𝑚 𝜃0
= 0.0
𝑤𝑐 = 0.069925
𝑡̂ = 1.554674
𝐴 = [
−0.02375 −0.069925 0.108849
0 0 1
3.3624 0 −0.22336
]
𝐵 = [
0.069925 0
0 0
−9.899204 0
]
𝐾 = [
0 . 890
0.60
1.554674
0 0 0
]
EIGENVALUE CALCULATION:
Eigenvalue calculation using phugoid mode approximation
Program CC Version 5.0 1/1/2002
Copyright(c) Systems Technology Inc. and Peter M. Thompson
CC>A=[-.02375 -.069925 0.108849;0 0 1;3.3624 0 -.22336]
CC>A
A =
-0.0237500 -0.0699250 0.1088490
0 0 1

COURSE CODE: AE4314
3.3624000 0 -0.2233600
CC>B=[0.069925 0;0 0;-9.899204 0]
CC>B
B =
0.0699250 0
0 0
-9.8992040 0
CC>K=[0 .89 .6/1.554674;0 0 0]
CC>K
K =
0 0.8900000 0.3859330
0 0 0
CC>B*K
ans =
0 0.0622333 0.0269864
0 0 0
0 -8.8102916 -3.8204295
CC>eig(A+B*K)
ans =
-2.0196673 + 2.0631562j
-2.0196673 - 2.0631562j
-0.0282050 + 0j
CC>A
A =
-0.0237500 -0.0699250 0.1088490
0 0 1
3.3624000 0 -0.2233600
CC>eig(A)
ans =
-0.9184975 + 0j
0.3356938 + 0.3785346j
0.3356938 - 0.3785346j
Eigenvalue calculation for phugoid mode using full state matrix
Using scilab 5.5.2
-->A=[-0.02375 0.00 -0.069925 0.108849;0.00 -0.47537 0.00 0.00;0.00
0.00 0.00 1;3.3642 0.00 0.00 -0.223355]
A =
- 0.02375 0. - 0.069925 0.108849
0. - 0.47537 0. 0.
0. 0. 0. 1.
3.3642 0. 0. - 0.223355
-->spec(A)
ans =

COURSE CODE: AE4314
- 0.9186733
0.3357842 + 0.3785707i
0.3357842 - 0.3785707i
- 0.47537
-->B=[0.069925 0;0 -0.3155;0 0;- 9.899204 0]
B =
0.069925 0.
0. - 0.3155
0. 0.
- 9.899204 0.
-->K=[0 0 0.89 0.6/1.554674;0 0 0 0]
K =
0. 0. 0.89 0.385933
0. 0. 0. 0.
-->spec(A+B*K)
ans =
- 0.0282075
- 2.0196635 + 2.0630982i
- 2.0196635 - 2.0630982i
- 0.47537
The phugoid eigenvalue obtained by using phugoid approximation and by using full state matrix give
nearly identical results.
The damped natural frequency 𝜔0 = Im(λ)
The amount of damping 𝜈 = −Re(λ)
The undamped natural frequency 𝜔 𝑛 = √𝜈2 + 𝜔0
2
The damping ratio 𝜁 = −
Re(λ)
𝜔 𝑛
HOVER PHUGOID MODE CHARACTERISTICS
Hover phugoid eigenvalue 0.3357842 ± 0.3785707i
𝜔0 = 0.3785707
𝜈 = −0.3357842
𝜔 𝑛 = √(−0.3357842)2 + (0.3785707)2 = 0.50603
𝜁 =
−0.3357842
0.256066804
= −0.66357

COURSE CODE: AE4314
EFFECT OF PID ON HOVER PHUGOID MODE CHARACTERISTICS
Hover phugoid eigenvalue with PID -2.0196635 ± 2.0630982i
𝜔0 = 2.0630982
𝜈 = 2.0196635
𝜔 𝑛 = √(2.0196635)2 + (2.0630982)2 = 2.887112
𝜁 =
2.0196635
2.887112
=0.699545
CONCLUSION: Hover phugoid mode is an unstable mode. With the implementation of PID pilot
control, the helicopter motion becomes stable in hover phugoid mode.

3DoF Helicopter Trim , Deceleration manouver simulation, Stability

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (7)

Similar to 3DoF Helicopter Trim , Deceleration manouver simulation, Stability

Similar to 3DoF Helicopter Trim , Deceleration manouver simulation, Stability (20)

Recently uploaded

Recently uploaded (20)

3DoF Helicopter Trim , Deceleration manouver simulation, Stability