----------------------------------------------------------------------
- REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
- Flight Controls, Part I. Lawrence, KS: DARcorporation,
- 1995.
+ REFERENCES:
----------------------------------------------------------------------
function from CLfade, CDfade, Cmfade,
CYfada, CYfbetadr, Clfada, Clfbetadr,
Cnfada, and Cnfbetadr switches
-
+ 04/15/2000 (JS) broke up into multiple
+ uiuc_coef_xxx functions
+ 06/18/2001 (RD) Added initialization of Std_Alpha and
+ Std_Beta. Added aileron_input and rudder_input.
+ Added pilot_elev_no, pilot_ail_no, and
+ pilot_rud_no.
+ 07/05/2001 (RD) Added pilot_(elev,ail,rud)_no=false
+ 01/11/2002 (AP) Added call to uiuc_iceboot()
+ 12/02/2002 (RD) Moved icing demo interpolations to its
+ own function
+
----------------------------------------------------------------------
AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
Jeff Scott <jscott@mail.com>
-
+ Robert Deters <rdeters@uiuc.edu>
+ Ann Peedikayil <peedikay@uiuc.edu>
----------------------------------------------------------------------
VARIABLES:
----------------------------------------------------------------------
- INPUTS: -Alpha
- -aileron
- -elevator
- -rudder
- -coefficient components
+ INPUTS: -V_rel_wind (or U_body)
+ -dyn_on_speed
+ -ice on/off
+ -phugoid on/off
----------------------------------------------------------------------
----------------------------------------------------------------------
- CALLED BY: ?
+ CALLED BY: uiuc_wrapper
----------------------------------------------------------------------
- CALLS TO: uiuc_1Dinterpolation
- uiuc_2Dinterpolation
- uiuc_ice
+ CALLS TO: uiuc_coef_lift
+ uiuc_coef_drag
+ uiuc_coef_pitch
+ uiuc_coef_sideforce
+ uiuc_coef_roll
+ uiuc_coef_yaw
+ uiuc_controlInput
----------------------------------------------------------------------
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
- USA or view http://www.gnu.org/copyleft/gpl.html.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**********************************************************************/
#include "uiuc_coefficients.h"
+void uiuc_coefficients(double dt)
+{
+ static string uiuc_coefficients_error = " (from uiuc_coefficients.cpp) ";
+ double l_trim, l_defl;
+ double V_rel_wind_dum, U_body_dum;
-/* set speed at which dynamic pressure terms will be accounted for
- since if velocity is too small, coefficients will go to infinity */
+ if (Alpha_init_true && Simtime==0)
+ Std_Alpha = Alpha_init;
-#define ON_VELOCITY 33 /* 20 kts */
+ if (Beta_init_true && Simtime==0)
+ Std_Beta = Beta_init;
+ // calculate rate derivative nondimensionalization factors
+ // check if speed is sufficient to compute dynamic pressure terms
+ if (dyn_on_speed==0)
+ {
+ uiuc_warnings_errors(5, uiuc_coefficients_error);
+ }
+ if (nondim_rate_V_rel_wind || use_V_rel_wind_2U) // c172_aero uses V_rel_wind
+ {
+ if (V_rel_wind > dyn_on_speed)
+ {
+ cbar_2U = cbar / (2.0 * V_rel_wind);
+ b_2U = bw / (2.0 * V_rel_wind);
+ // chord_h is the horizontal tail chord
+ ch_2U = chord_h / (2.0 * V_rel_wind);
+ }
+ else if (use_dyn_on_speed_curve1)
+ {
+ V_rel_wind_dum = dyn_on_speed_zero + V_rel_wind * (dyn_on_speed - dyn_on_speed_zero)/dyn_on_speed;
+ cbar_2U = cbar / (2.0 * V_rel_wind_dum);
+ b_2U = bw / (2.0 * V_rel_wind_dum);
+ ch_2U = chord_h / (2.0 * V_rel_wind_dum);
+ Std_Alpha_dot = 0.0;
+ }
+ else
+ {
+ cbar_2U = 0.0;
+ b_2U = 0.0;
+ ch_2U = 0.0;
+ Std_Alpha_dot = 0.0;
+ }
+ }
+ else if(use_abs_U_body_2U) // use absolute(U_body)
+ {
+ if (fabs(U_body) > dyn_on_speed)
+ {
+ cbar_2U = cbar / (2.0 * fabs(U_body));
+ b_2U = bw / (2.0 * fabs(U_body));
+ ch_2U = chord_h / (2.0 * fabs(U_body));
+ }
+ else if (use_dyn_on_speed_curve1)
+ {
+ U_body_dum = dyn_on_speed_zero + fabs(U_body) * (dyn_on_speed - dyn_on_speed_zero)/dyn_on_speed;
+ cbar_2U = cbar / (2.0 * U_body_dum);
+ b_2U = bw / (2.0 * U_body_dum);
+ ch_2U = chord_h / (2.0 * U_body_dum);
+ Std_Alpha_dot = 0.0;
+ }
+ else
+ {
+ cbar_2U = 0.0;
+ b_2U = 0.0;
+ ch_2U = 0.0;
+ Std_Alpha_dot = 0.0;
+ }
+ }
+ else // use U_body
+ {
+ if (U_body > dyn_on_speed)
+ {
+ cbar_2U = cbar / (2.0 * U_body);
+ b_2U = bw / (2.0 * U_body);
+ ch_2U = chord_h / (2.0 * U_body);
+ }
+ else if (use_dyn_on_speed_curve1)
+ {
+ U_body_dum = dyn_on_speed_zero + U_body * (dyn_on_speed - dyn_on_speed_zero)/dyn_on_speed;
+ cbar_2U = cbar / (2.0 * U_body_dum);
+ b_2U = bw / (2.0 * U_body_dum);
+ ch_2U = chord_h / (2.0 * U_body_dum);
+ Std_Alpha_dot = 0.0;
+ beta_flow_clean_tail = cbar_2U;
+ }
+ else
+ {
+ cbar_2U = 0.0;
+ b_2U = 0.0;
+ ch_2U = 0.0;
+ Std_Alpha_dot = 0.0;
+ }
+ }
-void uiuc_coefficients()
-{
- string linetoken1;
- string linetoken2;
- stack command_list;
- double cbar_2U = 0, b_2U = 0;
- double slope = 0;
- bool ice_on = false;
-
- // determine if speed is sufficient to compute dynamic pressure
- if (U_body > ON_VELOCITY)
+ // check if speed is sufficient to "trust" Std_Alpha_dot value
+ if (use_Alpha_dot_on_speed)
{
- cbar_2U = cbar / (2.0 * U_body);
- b_2U = bw / (2.0 * U_body);
+ if (V_rel_wind < Alpha_dot_on_speed)
+ Std_Alpha_dot = 0.0;
}
- else
+
+
+ // check to see if icing model engaged
+ if (ice_model)
+ {
+ uiuc_iceboot(dt);
+ uiuc_ice_eta();
+ }
+
+ // check to see if data files are used for control deflections
+ if (outside_control == false)
+ {
+ pilot_elev_no = false;
+ pilot_ail_no = false;
+ pilot_rud_no = false;
+ }
+ if (elevator_step || elevator_singlet || elevator_doublet || elevator_input || aileron_input || rudder_input || flap_pos_input)
{
- cbar_2U = 0.0;
- b_2U = 0.0;
+ uiuc_controlInput();
}
- //check to see if icing model engaged and set flag
- if (Simtime >= iceTime)
+ //if (Simtime >=10.0)
+ // {
+ // ap_hh_on = 1;
+ // ap_Psi_ref_rad = 0*DEG_TO_RAD;
+ // }
+
+ if (ap_pah_on || ap_alh_on || ap_rah_on || ap_hh_on)
+ {
+ uiuc_auto_pilot(dt);
+ }
+
+ CD = CX = CL = CZ = Cm = CY = Cl = Cn = 0.0;
+ CLclean_wing = CLiced_wing = CLclean_tail = CLiced_tail = 0.0;
+ CZclean_wing = CZiced_wing = CZclean_tail = CZiced_tail = 0.0;
+ CXclean_wing = CXiced_wing = CXclean_tail = CXiced_tail = 0.0;
+ CL_clean = CL_iced = 0.0;
+ CY_clean = CY_iced = 0.0;
+ CD_clean = CD_iced = 0.0;
+ Cm_iced = Cm_clean = 0.0;
+ Cl_iced = Cl_clean = 0.0;
+ Cn_iced = Cn_clean = 0.0;
+
+ uiuc_coef_lift();
+ uiuc_coef_drag();
+ uiuc_coef_pitch();
+ uiuc_coef_sideforce();
+ uiuc_coef_roll();
+ uiuc_coef_yaw();
+
+ //uncomment next line to always run icing functions
+ //nonlin_ice_case = 1;
+
+ if (nonlin_ice_case)
{
- ice_on = true;
+ if (eta_from_file)
+ {
+ if (eta_tail_input) {
+ double time = Simtime - eta_tail_input_startTime;
+ eta_tail = uiuc_1Dinterpolation(eta_tail_input_timeArray,
+ eta_tail_input_daArray,
+ eta_tail_input_ntime,
+ time);
+ }
+ if (eta_wing_left_input) {
+ double time = Simtime - eta_wing_left_input_startTime;
+ eta_wing_left = uiuc_1Dinterpolation(eta_wing_left_input_timeArray,
+ eta_wing_left_input_daArray,
+ eta_wing_left_input_ntime,
+ time);
+ }
+ if (eta_wing_right_input) {
+ double time = Simtime - eta_wing_right_input_startTime;
+ eta_wing_right = uiuc_1Dinterpolation(eta_wing_right_input_timeArray,
+ eta_wing_right_input_daArray,
+ eta_wing_right_input_ntime,
+ time);
+ }
+ }
+
+ delta_CL = delta_CD = delta_Cm = delta_Cl = delta_Cn = 0.0;
+ Calc_Iced_Forces();
+ add_ice_effects();
+ tactilefadefI = 0.0;
+ if (eta_tail == 0.2 && tactile_pitch && tactilefadef)
+ {
+ if (tactilefadef_nice == 1)
+ tactilefadefI = uiuc_3Dinterp_quick(tactilefadef_fArray,
+ tactilefadef_aArray_nice,
+ tactilefadef_deArray_nice,
+ tactilefadef_tactileArray,
+ tactilefadef_na_nice,
+ tactilefadef_nde_nice,
+ tactilefadef_nf,
+ flap_pos,
+ Std_Alpha,
+ elevator);
+ else
+ tactilefadefI = uiuc_3Dinterpolation(tactilefadef_fArray,
+ tactilefadef_aArray,
+ tactilefadef_deArray,
+ tactilefadef_tactileArray,
+ tactilefadef_nAlphaArray,
+ tactilefadef_nde,
+ tactilefadef_nf,
+ flap_pos,
+ Std_Alpha,
+ elevator);
+ }
+ else if (demo_tactile)
+ {
+ double time = Simtime - demo_tactile_startTime;
+ tactilefadefI = uiuc_1Dinterpolation(demo_tactile_timeArray,
+ demo_tactile_daArray,
+ demo_tactile_ntime,
+ time);
+ }
+ if (icing_demo)
+ uiuc_icing_demo();
}
- // slowly increase icing severity over period of transientTime
- if (Simtime >= iceTime && Simtime < (iceTime + transientTime))
+ if (pilot_ail_no)
{
- slope = eta_final / transientTime;
- eta = slope * (Simtime - iceTime);
+ if (aileron <=0)
+ Lat_control = - aileron / damax * RAD_TO_DEG;
+ else
+ Lat_control = - aileron / damin * RAD_TO_DEG;
}
- else
+
+ // can go past real limits
+ // add flag to behave like trim_case2 later
+ if (pilot_elev_no)
{
- eta = eta_final;
+ if (outside_control == false)
+ {
+ l_trim = elevator_tab;
+ l_defl = elevator - elevator_tab;
+ if (l_trim <=0 )
+ Long_trim = l_trim / demax * RAD_TO_DEG;
+ else
+ Long_trim = l_trim / demin * RAD_TO_DEG;
+ if (l_defl <= 0)
+ Long_control = l_defl / demax * RAD_TO_DEG;
+ else
+ Long_control = l_defl / demin * RAD_TO_DEG;
+ }
}
- CL = CD = Cm = CY = Cl = Cn = 0.0;
- command_list = aeroParts -> getCommands();
-
-
- for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ if (pilot_rud_no)
{
- linetoken1 = aeroParts -> getToken(*command_line, 1); // function parameters gettoken(string,tokenNo);
- linetoken2 = aeroParts -> getToken(*command_line, 2); // 2 represents token No 2
-
- switch (Keyword_map[linetoken1])
- {
- case CD_flag:
- {
- switch(CD_map[linetoken2])
- {
- case CDo_flag:
- {
- if (ice_on == true)
- {
- CDo = uiuc_ice(CDo_clean,kCDo,eta);
- }
- CD += CDo;
- break;
- }
- case CDK_flag:
- {
- if (ice_on == true)
- {
- CDK = uiuc_ice(CDK_clean,kCDK,eta);
- }
- CD += CDK * CL * CL;
- break;
- }
- case CD_a_flag:
- {
- if (ice_on == true)
- {
- CD_a = uiuc_ice(CD_a_clean,kCD_a,eta);
- }
- CD += CD_a * Alpha;
- break;
- }
- case CD_de_flag:
- {
- if (ice_on == true)
- {
- CD_de = uiuc_ice(CD_de_clean,kCD_de,eta);
- }
- CD += CD_de * elevator;
- break;
- }
- case CDfa_flag:
- {
- CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
- CDfa_CDArray,
- CDfa_nAlpha,
- Alpha);
- CD += CDfaI;
- break;
- }
- case CDfade_flag:
- {
- CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
- CDfade_deArray,
- CDfade_CDArray,
- CDfade_nAlphaArray,
- CDfade_nde,
- Alpha,
- elevator);
- CD += CDfadeI;
- break;
- }
- };
- break;
- } // end CD map
- case CL_flag:
- {
- switch(CL_map[linetoken2])
- {
- case CLo_flag:
- {
- if (ice_on == true)
- {
- CLo = uiuc_ice(CLo_clean,kCLo,eta);
- }
- CL += CLo;
- break;
- }
- case CL_a_flag:
- {
- if (ice_on == true)
- {
- CL_a = uiuc_ice(CL_a_clean,kCL_a,eta);
- }
- CL += CL_a * Alpha;
- break;
- }
- case CL_adot_flag:
- {
- if (ice_on == true)
- {
- CL_adot = uiuc_ice(CL_adot_clean,kCL_a,eta);
- }
- /* CL_adot must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- CL += CL_adot * Alpha_dot * cbar_2U;
- break;
- }
- case CL_q_flag:
- {
- if (ice_on == true)
- {
- CL_q = uiuc_ice(CL_q_clean,kCL_q,eta);
- }
- /* CL_q must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- /* why multiply by Theta_dot instead of Q_body?
- that is what is done in c172_aero.c; assume it
- has something to do with axes systems */
- CL += CL_q * Theta_dot * cbar_2U;
- break;
- }
- case CL_de_flag:
- {
- if (ice_on == true)
- {
- CL_de = uiuc_ice(CL_de_clean,kCL_de,eta);
- }
- CL += CL_de * elevator;
- break;
- }
- case CLfa_flag:
- {
- CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
- CLfa_CLArray,
- CLfa_nAlpha,
- Alpha);
- CL += CLfaI;
- break;
- }
- case CLfade_flag:
- {
- CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
- CLfade_deArray,
- CLfade_CLArray,
- CLfade_nAlphaArray,
- CLfade_nde,
- Alpha,
- elevator);
- CL += CLfadeI;
- break;
- }
- };
- break;
- } // end CL map
- case Cm_flag:
- {
- switch(Cm_map[linetoken2])
- {
- case Cmo_flag:
- {
- if (ice_on == true)
- {
- Cmo = uiuc_ice(Cmo_clean,kCmo,eta);
- }
- Cm += Cmo;
- break;
- }
- case Cm_a_flag:
- {
- if (ice_on == true)
- {
- Cm_a = uiuc_ice(Cm_a_clean,kCm_a,eta);
- }
- Cm += Cm_a * Alpha;
- break;
- }
- case Cm_adot_flag:
- {
- if (ice_on == true)
- {
- Cm_adot = uiuc_ice(Cm_adot_clean,kCm_a,eta);
- }
- /* Cm_adot must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cm += Cm_adot * Alpha_dot * cbar_2U;
- break;
- }
- case Cm_q_flag:
- {
- if (ice_on == true)
- {
- Cm_q = uiuc_ice(Cm_q_clean,kCm_q,eta);
- }
- /* Cm_q must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cm += Cm_q * Q_body * cbar_2U;
- break;
- }
- case Cm_de_flag:
- {
- if (ice_on == true)
- {
- Cm_de = uiuc_ice(Cm_de_clean,kCm_de,eta);
- }
- Cm += Cm_de * elevator;
- break;
- }
- case Cmfade_flag:
- {
- CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
- Cmfade_deArray,
- Cmfade_CmArray,
- Cmfade_nAlphaArray,
- Cmfade_nde,
- Alpha,
- elevator);
- Cm += CmfadeI;
- break;
- }
- };
- break;
- } // end Cm map
- case CY_flag:
- {
- switch(CY_map[linetoken2])
- {
- case CYo_flag:
- {
- if (ice_on == true)
- {
- CYo = uiuc_ice(CYo_clean,kCYo,eta);
- }
- CY += CYo;
- break;
- }
- case CY_beta_flag:
- {
- if (ice_on == true)
- {
- CY_beta = uiuc_ice(CY_beta_clean,kCY_beta,eta);
- }
- CY += CY_beta * Beta;
- break;
- }
- case CY_p_flag:
- {
- if (ice_on == true)
- {
- CY_p = uiuc_ice(CY_p_clean,kCY_p,eta);
- }
- /* CY_p must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- CY += CY_p * P_body * b_2U;
- break;
- }
- case CY_r_flag:
- {
- if (ice_on == true)
- {
- CY_r = uiuc_ice(CY_r_clean,kCY_r,eta);
- }
- /* CY_r must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- CY += CY_r * R_body * b_2U;
- break;
- }
- case CY_da_flag:
- {
- if (ice_on == true)
- {
- CY_da = uiuc_ice(CY_da_clean,kCY_da,eta);
- }
- CY += CY_da * aileron;
- break;
- }
- case CY_dr_flag:
- {
- if (ice_on == true)
- {
- CY_dr = uiuc_ice(CY_dr_clean,kCY_dr,eta);
- }
- CY += CY_dr * rudder;
- break;
- }
- case CYfada_flag:
- {
- CYfadaI = uiuc_2Dinterpolation(CYfada_aArray,
- CYfada_daArray,
- CYfada_CYArray,
- CYfada_nAlphaArray,
- CYfada_nda,
- Alpha,
- aileron);
- CY += CYfadaI;
- break;
- }
- case CYfbetadr_flag:
- {
- CYfbetadrI = uiuc_2Dinterpolation(CYfbetadr_betaArray,
- CYfbetadr_drArray,
- CYfbetadr_CYArray,
- CYfbetadr_nBetaArray,
- CYfbetadr_ndr,
- Beta,
- rudder);
- CY += CYfbetadrI;
- break;
- }
- };
- break;
- } // end CY map
- case Cl_flag:
- {
- switch(Cl_map[linetoken2])
- {
- case Clo_flag:
- {
- if (ice_on == true)
- {
- Clo = uiuc_ice(Clo_clean,kClo,eta);
- }
- Cl += Clo;
- break;
- }
- case Cl_beta_flag:
- {
- if (ice_on == true)
- {
- Cl_beta = uiuc_ice(Cl_beta_clean,kCl_beta,eta);
- }
- Cl += Cl_beta * Beta;
- break;
- }
- case Cl_p_flag:
- {
- if (ice_on == true)
- {
- Cl_p = uiuc_ice(Cl_p_clean,kCl_p,eta);
- }
- /* Cl_p must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cl += Cl_p * P_body * b_2U;
- break;
- }
- case Cl_r_flag:
- {
- if (ice_on == true)
- {
- Cl_r = uiuc_ice(Cl_r_clean,kCl_r,eta);
- }
- /* Cl_r must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cl += Cl_r * R_body * b_2U;
- break;
- }
- case Cl_da_flag:
- {
- if (ice_on == true)
- {
- Cl_da = uiuc_ice(Cl_da_clean,kCl_da,eta);
- }
- Cl += Cl_da * aileron;
- break;
- }
- case Cl_dr_flag:
- {
- if (ice_on == true)
- {
- Cl_dr = uiuc_ice(Cl_dr_clean,kCl_dr,eta);
- }
- Cl += Cl_dr * rudder;
- break;
- }
- case Clfada_flag:
- {
- ClfadaI = uiuc_2Dinterpolation(Clfada_aArray,
- Clfada_daArray,
- Clfada_ClArray,
- Clfada_nAlphaArray,
- Clfada_nda,
- Alpha,
- aileron);
- Cl += ClfadaI;
- break;
- }
- case Clfbetadr_flag:
- {
- ClfbetadrI = uiuc_2Dinterpolation(Clfbetadr_betaArray,
- Clfbetadr_drArray,
- Clfbetadr_ClArray,
- Clfbetadr_nBetaArray,
- Clfbetadr_ndr,
- Beta,
- rudder);
- Cl += ClfbetadrI;
- break;
- }
- };
- break;
- } // end Cl map
- case Cn_flag:
- {
- switch(Cn_map[linetoken2])
- {
- case Cno_flag:
- {
- if (ice_on == true)
- {
- Cno = uiuc_ice(Cno_clean,kCno,eta);
- }
- Cn += Cno;
- break;
- }
- case Cn_beta_flag:
- {
- if (ice_on == true)
- {
- Cn_beta = uiuc_ice(Cn_beta_clean,kCn_beta,eta);
- }
- Cn += Cn_beta * Beta;
- break;
- }
- case Cn_p_flag:
- {
- if (ice_on == true)
- {
- Cn_p = uiuc_ice(Cn_p_clean,kCn_p,eta);
- }
- /* Cn_p must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cn += Cn_p * P_body * b_2U;
- break;
- }
- case Cn_r_flag:
- {
- if (ice_on == true)
- {
- Cn_r = uiuc_ice(Cn_r_clean,kCn_r,eta);
- }
- /* Cn_r must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cn += Cn_r * R_body * b_2U;
- break;
- }
- case Cn_da_flag:
- {
- if (ice_on == true)
- {
- Cn_da = uiuc_ice(Cn_da_clean,kCn_da,eta);
- }
- Cn += Cn_da * aileron;
- break;
- }
- case Cn_dr_flag:
- {
- if (ice_on == true)
- {
- Cn_dr = uiuc_ice(Cn_dr_clean,kCn_dr,eta);
- }
- Cn += Cn_dr * rudder;
- break;
- }
- case Cnfada_flag:
- {
- CnfadaI = uiuc_2Dinterpolation(Cnfada_aArray,
- Cnfada_daArray,
- Cnfada_CnArray,
- Cnfada_nAlphaArray,
- Cnfada_nda,
- Alpha,
- aileron);
- Cn += CnfadaI;
- break;
- }
- case Cnfbetadr_flag:
- {
- CnfbetadrI = uiuc_2Dinterpolation(Cnfbetadr_betaArray,
- Cnfbetadr_drArray,
- Cnfbetadr_CnArray,
- Cnfbetadr_nBetaArray,
- Cnfbetadr_ndr,
- Beta,
- rudder);
- Cn += CnfbetadrI;
- break;
- }
- };
- break;
- } // end Cn map
- };
- } // end keyword map
+ if (rudder <=0)
+ Rudder_pedal = - rudder / drmax * RAD_TO_DEG;
+ else
+ Rudder_pedal = - rudder / drmin * RAD_TO_DEG;
+ }
return;
}
projects / flightgear.git / blobdiff