src/FDM/UIUCModel/uiuc_menu_controlSurface.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu_controlSurface.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  reads input data for specified aircraft and creates
   8                approporiate data storage space
   9
  10 ----------------------------------------------------------------------
  11
  12  STATUS:       alpha version
  13
  14 ----------------------------------------------------------------------
  15
  16  REFERENCES:   based on "menu reader" format of Michael Selig
  17
  18 ----------------------------------------------------------------------
  19
  20  HISTORY:      04/04/2003   initial release
  21                06/30/2003   (RD) replaced istrstream with istringstream
  22                             to get rid of the annoying warning about
  23                             using the strstream header
  24
  25 ----------------------------------------------------------------------
  26
  27  AUTHOR(S):    Robert Deters      <rdeters@uiuc.edu>
  28                Michael Selig      <m-selig@uiuc.edu>
  29
  30 ----------------------------------------------------------------------
  31
  32  VARIABLES:
  33
  34 ----------------------------------------------------------------------
  35
  36  INPUTS:       n/a
  37
  38 ----------------------------------------------------------------------
  39
  40  OUTPUTS:      n/a
  41
  42 ----------------------------------------------------------------------
  43
  44  CALLED BY:    uiuc_menu()
  45
  46 ----------------------------------------------------------------------
  47
  48  CALLS TO:     check_float() if needed
  49                d_2_to_3() if needed
  50                d_1_to_2() if needed
  51                i_1_to_2() if needed
  52                d_1_to_1() if needed
  53
  54  ----------------------------------------------------------------------
  55
  56  COPYRIGHT:    (C) 2003 by Michael Selig
  57
  58  This program is free software; you can redistribute it and/or
  59  modify it under the terms of the GNU General Public License
  60  as published by the Free Software Foundation.
  61
  62  This program is distributed in the hope that it will be useful,
  63  but WITHOUT ANY WARRANTY; without even the implied warranty of
  64  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  65  GNU General Public License for more details.
  66
  67  You should have received a copy of the GNU General Public License
  68  along with this program; if not, write to the Free Software
  69  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  70
  71 **********************************************************************/
  72
  73 #include <simgear/compiler.h>
  74
  75 #if defined( __MWERKS__ )
  76 // -dw- optimizer chokes (big-time) trying to optimize humongous
  77 // loop/switch statements
  78 #pragma optimization_level 0
  79 #endif
  80
  81 #include <cstdlib>
  82 #include <string>
  83 #include STL_IOSTREAM
  84
  85 #include "uiuc_menu_controlSurface.h"
  86
  87 SG_USING_STD(cerr);
  88 SG_USING_STD(cout);
  89 SG_USING_STD(endl);
  90
  91 #ifndef _MSC_VER
  92 SG_USING_STD(exit);
  93 #endif
  94
  95 void parse_controlSurface( const string& linetoken2, const string& linetoken3,
  96                            const string& linetoken4, const string& linetoken5,
  97                            const string& linetoken6, const string& linetoken7,
  98                            const string& linetoken8, const string& linetoken9,
  99                            const string& linetoken10,
 100                            const string& aircraft_directory,
 101                            LIST command_line ) {
 102     double token_value;
 103     int token_value_convert1, token_value_convert2;
 104     istringstream token3(linetoken3.c_str());
 105     istringstream token4(linetoken4.c_str());
 106     istringstream token5(linetoken5.c_str());
 107     istringstream token6(linetoken6.c_str());
 108     istringstream token7(linetoken7.c_str());
 109     istringstream token8(linetoken8.c_str());
 110     istringstream token9(linetoken9.c_str());
 111     istringstream token10(linetoken10.c_str());
 112
 113     switch(controlSurface_map[linetoken2])
 114       {
 115       case de_flag:
 116         {
 117           if (check_float(linetoken3))
 118             token3 >> token_value;
 119           else
 120             uiuc_warnings_errors(1, *command_line);
 121
 122           demax = token_value;
 123
 124           if (check_float(linetoken4))
 125             token4 >> token_value;
 126           else
 127             uiuc_warnings_errors(1, *command_line);
 128
 129           demin = token_value;
 130           break;
 131         }
 132       case da_flag:
 133         {
 134           if (check_float(linetoken3))
 135             token3 >> token_value;
 136           else
 137             uiuc_warnings_errors(1, *command_line);
 138
 139           damax = token_value;
 140
 141           if (check_float(linetoken4))
 142             token4 >> token_value;
 143           else
 144             uiuc_warnings_errors(1, *command_line);
 145
 146           damin = token_value;
 147           break;
 148         }
 149       case dr_flag:
 150         {
 151           if (check_float(linetoken3))
 152             token3 >> token_value;
 153           else
 154             uiuc_warnings_errors(1, *command_line);
 155
 156           drmax = token_value;
 157
 158           if (check_float(linetoken4))
 159             token4 >> token_value;
 160           else
 161             uiuc_warnings_errors(1, *command_line);
 162
 163           drmin = token_value;
 164           break;
 165         }
 166       case set_Long_trim_flag:
 167         {
 168           if (check_float(linetoken3))
 169             token3 >> token_value;
 170           else
 171             uiuc_warnings_errors(1, *command_line);
 172
 173           set_Long_trim = true;
 174           elevator_tab = token_value;
 175           break;
 176         }
 177       case set_Long_trim_deg_flag:
 178         {
 179           if (check_float(linetoken3))
 180             token3 >> token_value;
 181           else
 182             uiuc_warnings_errors(1, *command_line);
 183
 184           set_Long_trim = true;
 185           elevator_tab = token_value * DEG_TO_RAD;
 186           break;
 187         }
 188       case zero_Long_trim_flag:
 189         {
 190           zero_Long_trim = true;
 191           break;
 192         }
 193       case elevator_step_flag:
 194         {
 195           // set step input flag
 196           elevator_step = true;
 197
 198           // read in step angle in degrees and convert
 199           if (check_float(linetoken3))
 200             token3 >> token_value;
 201           else
 202             uiuc_warnings_errors(1, *command_line);
 203
 204           elevator_step_angle = token_value * DEG_TO_RAD;
 205
 206           // read in step start time
 207           if (check_float(linetoken4))
 208             token4 >> token_value;
 209           else
 210             uiuc_warnings_errors(1, *command_line);
 211
 212           elevator_step_startTime = token_value;
 213           break;
 214         }
 215       case elevator_singlet_flag:
 216         {
 217           // set singlet input flag
 218           elevator_singlet = true;
 219
 220           // read in singlet angle in degrees and convert
 221           if (check_float(linetoken3))
 222             token3 >> token_value;
 223           else
 224             uiuc_warnings_errors(1, *command_line);
 225
 226           elevator_singlet_angle = token_value * DEG_TO_RAD;
 227
 228           // read in singlet start time
 229           if (check_float(linetoken4))
 230             token4 >> token_value;
 231           else
 232             uiuc_warnings_errors(1, *command_line);
 233
 234           elevator_singlet_startTime = token_value;
 235
 236           // read in singlet duration
 237           if (check_float(linetoken5))
 238             token5 >> token_value;
 239           else
 240             uiuc_warnings_errors(1, *command_line);
 241
 242           elevator_singlet_duration = token_value;
 243           break;
 244         }
 245       case elevator_doublet_flag:
 246         {
 247           // set doublet input flag
 248           elevator_doublet = true;
 249
 250           // read in doublet angle in degrees and convert
 251           if (check_float(linetoken3))
 252             token3 >> token_value;
 253           else
 254             uiuc_warnings_errors(1, *command_line);
 255
 256           elevator_doublet_angle = token_value * DEG_TO_RAD;
 257
 258           // read in doublet start time
 259           if (check_float(linetoken4))
 260             token4 >> token_value;
 261           else
 262             uiuc_warnings_errors(1, *command_line);
 263
 264           elevator_doublet_startTime = token_value;
 265
 266           // read in doublet duration
 267           if (check_float(linetoken5))
 268             token5 >> token_value;
 269           else
 270             uiuc_warnings_errors(1, *command_line);
 271
 272           elevator_doublet_duration = token_value;
 273           break;
 274         }
 275       case elevator_input_flag:
 276         {
 277           elevator_input = true;
 278           elevator_input_file = aircraft_directory + linetoken3;
 279           token4 >> token_value_convert1;
 280           token5 >> token_value_convert2;
 281           convert_y = uiuc_convert(token_value_convert1);
 282           convert_x = uiuc_convert(token_value_convert2);
 283           uiuc_1DdataFileReader(elevator_input_file,
 284                                 elevator_input_timeArray,
 285                                 elevator_input_deArray,
 286                                 elevator_input_ntime);
 287           token6 >> token_value;
 288           elevator_input_startTime = token_value;
 289           break;
 290         }
 291       case aileron_input_flag:
 292         {
 293           aileron_input = true;
 294           aileron_input_file = aircraft_directory + linetoken3;
 295           token4 >> token_value_convert1;
 296           token5 >> token_value_convert2;
 297           convert_y = uiuc_convert(token_value_convert1);
 298           convert_x = uiuc_convert(token_value_convert2);
 299           uiuc_1DdataFileReader(aileron_input_file,
 300                                 aileron_input_timeArray,
 301                                 aileron_input_daArray,
 302                                 aileron_input_ntime);
 303           token6 >> token_value;
 304           aileron_input_startTime = token_value;
 305           break;
 306         }
 307       case rudder_input_flag:
 308         {
 309           rudder_input = true;
 310           rudder_input_file = aircraft_directory + linetoken3;
 311           token4 >> token_value_convert1;
 312           token5 >> token_value_convert2;
 313           convert_y = uiuc_convert(token_value_convert1);
 314           convert_x = uiuc_convert(token_value_convert2);
 315           uiuc_1DdataFileReader(rudder_input_file,
 316                                 rudder_input_timeArray,
 317                                 rudder_input_drArray,
 318                                 rudder_input_ntime);
 319           token6 >> token_value;
 320           rudder_input_startTime = token_value;
 321           break;
 322         }
 323       case flap_pos_input_flag:
 324         {
 325           flap_pos_input = true;
 326           flap_pos_input_file = aircraft_directory + linetoken3;
 327           token4 >> token_value_convert1;
 328           token5 >> token_value_convert2;
 329           convert_y = uiuc_convert(token_value_convert1);
 330           convert_x = uiuc_convert(token_value_convert2);
 331           uiuc_1DdataFileReader(flap_pos_input_file,
 332                                 flap_pos_input_timeArray,
 333                                 flap_pos_input_dfArray,
 334                                 flap_pos_input_ntime);
 335           token6 >> token_value;
 336           flap_pos_input_startTime = token_value;
 337           break;
 338         }
 339       case pilot_elev_no_flag:
 340         {
 341           pilot_elev_no_check = true;
 342           break;
 343         }
 344       case pilot_ail_no_flag:
 345         {
 346           pilot_ail_no_check = true;
 347           break;
 348         }
 349       case pilot_rud_no_flag:
 350         {
 351           pilot_rud_no_check = true;
 352           break;
 353         }
 354       case flap_max_flag:
 355         {
 356           if (check_float(linetoken3))
 357             token3 >> token_value;
 358           else
 359             uiuc_warnings_errors(1, *command_line);
 360
 361           use_flaps = true;
 362           flap_max = token_value;
 363           break;
 364         }
 365       case flap_rate_flag:
 366         {
 367           if (check_float(linetoken3))
 368             token3 >> token_value;
 369           else
 370             uiuc_warnings_errors(1, *command_line);
 371
 372           use_flaps = true;
 373           flap_rate = token_value;
 374           break;
 375         }
 376       case spoiler_max_flag:
 377         {
 378           if (check_float(linetoken3))
 379             token3 >> token_value;
 380           else
 381             uiuc_warnings_errors(1, *command_line);
 382
 383           use_spoilers = true;
 384           spoiler_max = token_value;
 385           break;
 386         }
 387       case spoiler_rate_flag:
 388         {
 389           if (check_float(linetoken3))
 390             token3 >> token_value;
 391           else
 392             uiuc_warnings_errors(1, *command_line);
 393
 394           use_spoilers = true;
 395           spoiler_rate = token_value;
 396           break;
 397         }
 398       case aileron_sas_KP_flag:
 399         {
 400           if (check_float(linetoken3))
 401             token3 >> token_value;
 402           else
 403             uiuc_warnings_errors(1, *command_line);
 404
 405           aileron_sas_KP = token_value;
 406           break;
 407         }
 408       case aileron_sas_max_flag:
 409         {
 410           if (check_float(linetoken3))
 411             token3 >> token_value;
 412           else
 413             uiuc_warnings_errors(1, *command_line);
 414           aileron_sas_max = token_value;
 415           use_aileron_sas_max = true;
 416           break;
 417         }
 418       case aileron_stick_gain_flag:
 419         {
 420           if (check_float(linetoken3))
 421             token3 >> token_value;
 422           else
 423             uiuc_warnings_errors(1, *command_line);
 424           aileron_stick_gain = token_value;
 425           use_aileron_stick_gain = true;
 426           break;
 427         }
 428       case elevator_sas_KQ_flag:
 429         {
 430           if (check_float(linetoken3))
 431             token3 >> token_value;
 432           else
 433             uiuc_warnings_errors(1, *command_line);
 434           elevator_sas_KQ = token_value;
 435           break;
 436         }
 437       case elevator_sas_max_flag:
 438         {
 439           if (check_float(linetoken3))
 440             token3 >> token_value;
 441           else
 442             uiuc_warnings_errors(1, *command_line);
 443           elevator_sas_max = token_value;
 444           use_elevator_sas_max = true;
 445           break;
 446         }
 447       case elevator_sas_min_flag:
 448         {
 449           if (check_float(linetoken3))
 450             token3 >> token_value;
 451           else
 452             uiuc_warnings_errors(1, *command_line);
 453           elevator_sas_min = token_value;
 454           use_elevator_sas_min = true;
 455           break;
 456         }
 457       case elevator_stick_gain_flag:
 458         {
 459           if (check_float(linetoken3))
 460             token3 >> token_value;
 461           else
 462             uiuc_warnings_errors(1, *command_line);
 463           elevator_stick_gain = token_value;
 464           use_elevator_stick_gain = true;
 465           break;
 466         }
 467       case rudder_sas_KR_flag:
 468         {
 469           if (check_float(linetoken3))
 470             token3 >> token_value;
 471           else
 472             uiuc_warnings_errors(1, *command_line);
 473           rudder_sas_KR = token_value;
 474           break;
 475         }
 476       case rudder_sas_max_flag:
 477         {
 478           if (check_float(linetoken3))
 479             token3 >> token_value;
 480           else
 481             uiuc_warnings_errors(1, *command_line);
 482           rudder_sas_max = token_value;
 483           use_rudder_sas_max = true;
 484           break;
 485         }
 486       case rudder_stick_gain_flag:
 487         {
 488           if (check_float(linetoken3))
 489             token3 >> token_value;
 490           else
 491             uiuc_warnings_errors(1, *command_line);
 492           rudder_stick_gain = token_value;
 493           use_rudder_stick_gain = true;
 494           break;
 495         }
 496       case use_aileron_sas_type1_flag:
 497         {
 498           use_aileron_sas_type1 = true;
 499           break;
 500         }
 501       case use_elevator_sas_type1_flag:
 502         {
 503           use_elevator_sas_type1 = true;
 504           break;
 505         }
 506       case use_rudder_sas_type1_flag:
 507         {
 508           use_rudder_sas_type1 = true;
 509           break;
 510         }
 511       case ap_pah_flag:
 512         {
 513           if (check_float(linetoken3))
 514             token3 >> token_value;
 515           else
 516             uiuc_warnings_errors(1, *command_line);
 517
 518           ap_pah_start_time=token_value;
 519           ap_pah_on = 1;
 520           break;
 521         }
 522       case ap_alh_flag:
 523         {
 524           if (check_float(linetoken3))
 525             token3 >> token_value;
 526           else
 527             uiuc_warnings_errors(1, *command_line);
 528
 529           ap_alh_start_time=token_value;
 530           ap_alh_on = 1;
 531           break;
 532         }
 533       case ap_rah_flag:
 534         {
 535           if (check_float(linetoken3))
 536             token3 >> token_value;
 537           else
 538             uiuc_warnings_errors(1, *command_line);
 539
 540           ap_rah_start_time=token_value;
 541           ap_rah_on = 1;
 542           break;
 543         }
 544       case ap_hh_flag:
 545         {
 546           if (check_float(linetoken3))
 547             token3 >> token_value;
 548           else
 549             uiuc_warnings_errors(1, *command_line);
 550
 551           ap_hh_start_time=token_value;
 552           ap_hh_on = 1;
 553           break;
 554         }
 555       case ap_Theta_ref_flag:
 556         {
 557           if (check_float(linetoken3))
 558             token3 >> token_value;
 559           else
 560             uiuc_warnings_errors(1, *command_line);
 561           token4 >> token_value_convert1;
 562           convert_y = uiuc_convert(token_value_convert1);
 563
 564           ap_Theta_ref_rad = token_value * convert_y;
 565           break;
 566         }
 567       case ap_alt_ref_flag:
 568         {
 569           if (check_float(linetoken3))
 570             token3 >> token_value;
 571           else
 572             uiuc_warnings_errors(1, *command_line);
 573
 574           ap_alt_ref_ft = token_value;
 575           break;
 576         }
 577       case ap_Phi_ref_flag:
 578         {
 579           if (check_float(linetoken3))
 580             token3 >> token_value;
 581           else
 582             uiuc_warnings_errors(1, *command_line);
 583           token4 >> token_value_convert1;
 584           convert_y = uiuc_convert(token_value_convert1);
 585
 586           ap_Phi_ref_rad = token_value * convert_y;
 587           break;
 588         }
 589       case ap_Psi_ref_flag:
 590         {
 591           if (check_float(linetoken3))
 592             token3 >> token_value;
 593           else
 594             uiuc_warnings_errors(1, *command_line);
 595           token4 >> token_value_convert1;
 596           convert_y = uiuc_convert(token_value_convert1);
 597
 598           ap_Psi_ref_rad = token_value * convert_y;
 599           break;
 600         }
 601       default:
 602         {
 603           if (ignore_unknown_keywords) {
 604             // do nothing
 605           } else {
 606             // print error message
 607             uiuc_warnings_errors(2, *command_line);
 608           }
 609           break;
 610         }
 611       };
 612 }