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.




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;




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;

/*************************************************************************/




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




𝜈𝑖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




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);




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




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 𝜃𝑓𝑑𝑒𝑠𝑖




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()




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




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);




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;




/*************************************************************************/

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)




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.




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.




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]




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





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;




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");




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;




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;

/******************************************************************/




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.




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




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




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;




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




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




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




Fig.15 Plot of 𝒙𝒖 , 𝒙𝒘 , 𝒙𝒒

Fig.16 Plot of 𝒛𝒖 , 𝒛𝒘 , 𝒛𝒒




Fig.17 Plot of 𝒎𝒖

′, 𝒎𝒘′, 𝒎𝒒

′

Fig.18 Plot of 𝒎𝒖 , 𝒎𝒘 , 𝒎𝒒




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




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 13.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




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 =




- 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 + 𝜔02

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




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

Engineering

Transcript of 3DoF Helicopter Trim , Deceleration manouver simulation, Stability