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
  76 #include <cstdlib>
  77 #include <string>
  78 #include <iostream>
  79
  80 #include "uiuc_menu_controlSurface.h"
  81
  82 using std::cerr;
  83 using std::cout;
  84 using std::endl;
  85
  86 #ifndef _MSC_VER
  87 using std::exit;
  88 #endif
  89
  90 void parse_controlSurface( const string& linetoken2, const string& linetoken3,
  91                            const string& linetoken4, const string& linetoken5,
  92                            const string& linetoken6, const string& linetoken7,
  93                            const string& linetoken8, const string& linetoken9,
  94                            const string& linetoken10,
  95                            const string& aircraft_directory,
  96                            LIST command_line ) {
  97     double token_value;
  98     int token_value_convert1, token_value_convert2;
  99     istringstream token3(linetoken3.c_str());
 100     istringstream token4(linetoken4.c_str());
 101     istringstream token5(linetoken5.c_str());
 102     istringstream token6(linetoken6.c_str());
 103     istringstream token7(linetoken7.c_str());
 104     istringstream token8(linetoken8.c_str());
 105     istringstream token9(linetoken9.c_str());
 106     istringstream token10(linetoken10.c_str());
 107
 108     switch(controlSurface_map[linetoken2])
 109       {
 110       case de_flag:
 111         {
 112           if (check_float(linetoken3))
 113             token3 >> token_value;
 114           else
 115             uiuc_warnings_errors(1, *command_line);
 116
 117           demax = token_value;
 118
 119           if (check_float(linetoken4))
 120             token4 >> token_value;
 121           else
 122             uiuc_warnings_errors(1, *command_line);
 123
 124           demin = token_value;
 125           break;
 126         }
 127       case da_flag:
 128         {
 129           if (check_float(linetoken3))
 130             token3 >> token_value;
 131           else
 132             uiuc_warnings_errors(1, *command_line);
 133
 134           damax = token_value;
 135
 136           if (check_float(linetoken4))
 137             token4 >> token_value;
 138           else
 139             uiuc_warnings_errors(1, *command_line);
 140
 141           damin = token_value;
 142           break;
 143         }
 144       case dr_flag:
 145         {
 146           if (check_float(linetoken3))
 147             token3 >> token_value;
 148           else
 149             uiuc_warnings_errors(1, *command_line);
 150
 151           drmax = token_value;
 152
 153           if (check_float(linetoken4))
 154             token4 >> token_value;
 155           else
 156             uiuc_warnings_errors(1, *command_line);
 157
 158           drmin = token_value;
 159           break;
 160         }
 161       case set_Long_trim_flag:
 162         {
 163           if (check_float(linetoken3))
 164             token3 >> token_value;
 165           else
 166             uiuc_warnings_errors(1, *command_line);
 167
 168           set_Long_trim = true;
 169           elevator_tab = token_value;
 170           break;
 171         }
 172       case set_Long_trim_deg_flag:
 173         {
 174           if (check_float(linetoken3))
 175             token3 >> token_value;
 176           else
 177             uiuc_warnings_errors(1, *command_line);
 178
 179           set_Long_trim = true;
 180           elevator_tab = token_value * DEG_TO_RAD;
 181           break;
 182         }
 183       case zero_Long_trim_flag:
 184         {
 185           zero_Long_trim = true;
 186           break;
 187         }
 188       case elevator_step_flag:
 189         {
 190           // set step input flag
 191           elevator_step = true;
 192
 193           // read in step angle in degrees and convert
 194           if (check_float(linetoken3))
 195             token3 >> token_value;
 196           else
 197             uiuc_warnings_errors(1, *command_line);
 198
 199           elevator_step_angle = token_value * DEG_TO_RAD;
 200
 201           // read in step start time
 202           if (check_float(linetoken4))
 203             token4 >> token_value;
 204           else
 205             uiuc_warnings_errors(1, *command_line);
 206
 207           elevator_step_startTime = token_value;
 208           break;
 209         }
 210       case elevator_singlet_flag:
 211         {
 212           // set singlet input flag
 213           elevator_singlet = true;
 214
 215           // read in singlet angle in degrees and convert
 216           if (check_float(linetoken3))
 217             token3 >> token_value;
 218           else
 219             uiuc_warnings_errors(1, *command_line);
 220
 221           elevator_singlet_angle = token_value * DEG_TO_RAD;
 222
 223           // read in singlet start time
 224           if (check_float(linetoken4))
 225             token4 >> token_value;
 226           else
 227             uiuc_warnings_errors(1, *command_line);
 228
 229           elevator_singlet_startTime = token_value;
 230
 231           // read in singlet duration
 232           if (check_float(linetoken5))
 233             token5 >> token_value;
 234           else
 235             uiuc_warnings_errors(1, *command_line);
 236
 237           elevator_singlet_duration = token_value;
 238           break;
 239         }
 240       case elevator_doublet_flag:
 241         {
 242           // set doublet input flag
 243           elevator_doublet = true;
 244
 245           // read in doublet angle in degrees and convert
 246           if (check_float(linetoken3))
 247             token3 >> token_value;
 248           else
 249             uiuc_warnings_errors(1, *command_line);
 250
 251           elevator_doublet_angle = token_value * DEG_TO_RAD;
 252
 253           // read in doublet start time
 254           if (check_float(linetoken4))
 255             token4 >> token_value;
 256           else
 257             uiuc_warnings_errors(1, *command_line);
 258
 259           elevator_doublet_startTime = token_value;
 260
 261           // read in doublet duration
 262           if (check_float(linetoken5))
 263             token5 >> token_value;
 264           else
 265             uiuc_warnings_errors(1, *command_line);
 266
 267           elevator_doublet_duration = token_value;
 268           break;
 269         }
 270       case elevator_input_flag:
 271         {
 272           elevator_input = true;
 273           elevator_input_file = aircraft_directory + linetoken3;
 274           token4 >> token_value_convert1;
 275           token5 >> token_value_convert2;
 276           convert_y = uiuc_convert(token_value_convert1);
 277           convert_x = uiuc_convert(token_value_convert2);
 278           uiuc_1DdataFileReader(elevator_input_file,
 279                                 elevator_input_timeArray,
 280                                 elevator_input_deArray,
 281                                 elevator_input_ntime);
 282           token6 >> token_value;
 283           elevator_input_startTime = token_value;
 284           break;
 285         }
 286       case aileron_input_flag:
 287         {
 288           aileron_input = true;
 289           aileron_input_file = aircraft_directory + linetoken3;
 290           token4 >> token_value_convert1;
 291           token5 >> token_value_convert2;
 292           convert_y = uiuc_convert(token_value_convert1);
 293           convert_x = uiuc_convert(token_value_convert2);
 294           uiuc_1DdataFileReader(aileron_input_file,
 295                                 aileron_input_timeArray,
 296                                 aileron_input_daArray,
 297                                 aileron_input_ntime);
 298           token6 >> token_value;
 299           aileron_input_startTime = token_value;
 300           break;
 301         }
 302       case rudder_input_flag:
 303         {
 304           rudder_input = true;
 305           rudder_input_file = aircraft_directory + linetoken3;
 306           token4 >> token_value_convert1;
 307           token5 >> token_value_convert2;
 308           convert_y = uiuc_convert(token_value_convert1);
 309           convert_x = uiuc_convert(token_value_convert2);
 310           uiuc_1DdataFileReader(rudder_input_file,
 311                                 rudder_input_timeArray,
 312                                 rudder_input_drArray,
 313                                 rudder_input_ntime);
 314           token6 >> token_value;
 315           rudder_input_startTime = token_value;
 316           break;
 317         }
 318       case flap_pos_input_flag:
 319         {
 320           flap_pos_input = true;
 321           flap_pos_input_file = aircraft_directory + linetoken3;
 322           token4 >> token_value_convert1;
 323           token5 >> token_value_convert2;
 324           convert_y = uiuc_convert(token_value_convert1);
 325           convert_x = uiuc_convert(token_value_convert2);
 326           uiuc_1DdataFileReader(flap_pos_input_file,
 327                                 flap_pos_input_timeArray,
 328                                 flap_pos_input_dfArray,
 329                                 flap_pos_input_ntime);
 330           token6 >> token_value;
 331           flap_pos_input_startTime = token_value;
 332           break;
 333         }
 334       case pilot_elev_no_flag:
 335         {
 336           pilot_elev_no_check = true;
 337           break;
 338         }
 339       case pilot_ail_no_flag:
 340         {
 341           pilot_ail_no_check = true;
 342           break;
 343         }
 344       case pilot_rud_no_flag:
 345         {
 346           pilot_rud_no_check = true;
 347           break;
 348         }
 349       case flap_max_flag:
 350         {
 351           if (check_float(linetoken3))
 352             token3 >> token_value;
 353           else
 354             uiuc_warnings_errors(1, *command_line);
 355
 356           use_flaps = true;
 357           flap_max = token_value;
 358           break;
 359         }
 360       case flap_rate_flag:
 361         {
 362           if (check_float(linetoken3))
 363             token3 >> token_value;
 364           else
 365             uiuc_warnings_errors(1, *command_line);
 366
 367           use_flaps = true;
 368           flap_rate = token_value;
 369           break;
 370         }
 371       case spoiler_max_flag:
 372         {
 373           if (check_float(linetoken3))
 374             token3 >> token_value;
 375           else
 376             uiuc_warnings_errors(1, *command_line);
 377
 378           use_spoilers = true;
 379           spoiler_max = token_value;
 380           break;
 381         }
 382       case spoiler_rate_flag:
 383         {
 384           if (check_float(linetoken3))
 385             token3 >> token_value;
 386           else
 387             uiuc_warnings_errors(1, *command_line);
 388
 389           use_spoilers = true;
 390           spoiler_rate = token_value;
 391           break;
 392         }
 393       case aileron_sas_KP_flag:
 394         {
 395           if (check_float(linetoken3))
 396             token3 >> token_value;
 397           else
 398             uiuc_warnings_errors(1, *command_line);
 399
 400           aileron_sas_KP = token_value;
 401           break;
 402         }
 403       case aileron_sas_max_flag:
 404         {
 405           if (check_float(linetoken3))
 406             token3 >> token_value;
 407           else
 408             uiuc_warnings_errors(1, *command_line);
 409           aileron_sas_max = token_value;
 410           use_aileron_sas_max = true;
 411           break;
 412         }
 413       case aileron_stick_gain_flag:
 414         {
 415           if (check_float(linetoken3))
 416             token3 >> token_value;
 417           else
 418             uiuc_warnings_errors(1, *command_line);
 419           aileron_stick_gain = token_value;
 420           use_aileron_stick_gain = true;
 421           break;
 422         }
 423       case elevator_sas_KQ_flag:
 424         {
 425           if (check_float(linetoken3))
 426             token3 >> token_value;
 427           else
 428             uiuc_warnings_errors(1, *command_line);
 429           elevator_sas_KQ = token_value;
 430           break;
 431         }
 432       case elevator_sas_max_flag:
 433         {
 434           if (check_float(linetoken3))
 435             token3 >> token_value;
 436           else
 437             uiuc_warnings_errors(1, *command_line);
 438           elevator_sas_max = token_value;
 439           use_elevator_sas_max = true;
 440           break;
 441         }
 442       case elevator_sas_min_flag:
 443         {
 444           if (check_float(linetoken3))
 445             token3 >> token_value;
 446           else
 447             uiuc_warnings_errors(1, *command_line);
 448           elevator_sas_min = token_value;
 449           use_elevator_sas_min = true;
 450           break;
 451         }
 452       case elevator_stick_gain_flag:
 453         {
 454           if (check_float(linetoken3))
 455             token3 >> token_value;
 456           else
 457             uiuc_warnings_errors(1, *command_line);
 458           elevator_stick_gain = token_value;
 459           use_elevator_stick_gain = true;
 460           break;
 461         }
 462       case rudder_sas_KR_flag:
 463         {
 464           if (check_float(linetoken3))
 465             token3 >> token_value;
 466           else
 467             uiuc_warnings_errors(1, *command_line);
 468           rudder_sas_KR = token_value;
 469           break;
 470         }
 471       case rudder_sas_max_flag:
 472         {
 473           if (check_float(linetoken3))
 474             token3 >> token_value;
 475           else
 476             uiuc_warnings_errors(1, *command_line);
 477           rudder_sas_max = token_value;
 478           use_rudder_sas_max = true;
 479           break;
 480         }
 481       case rudder_stick_gain_flag:
 482         {
 483           if (check_float(linetoken3))
 484             token3 >> token_value;
 485           else
 486             uiuc_warnings_errors(1, *command_line);
 487           rudder_stick_gain = token_value;
 488           use_rudder_stick_gain = true;
 489           break;
 490         }
 491       case use_aileron_sas_type1_flag:
 492         {
 493           use_aileron_sas_type1 = true;
 494           break;
 495         }
 496       case use_elevator_sas_type1_flag:
 497         {
 498           use_elevator_sas_type1 = true;
 499           break;
 500         }
 501       case use_rudder_sas_type1_flag:
 502         {
 503           use_rudder_sas_type1 = true;
 504           break;
 505         }
 506       case ap_pah_flag:
 507         {
 508           if (check_float(linetoken3))
 509             token3 >> token_value;
 510           else
 511             uiuc_warnings_errors(1, *command_line);
 512
 513           ap_pah_start_time=token_value;
 514           ap_pah_on = 1;
 515           break;
 516         }
 517       case ap_alh_flag:
 518         {
 519           if (check_float(linetoken3))
 520             token3 >> token_value;
 521           else
 522             uiuc_warnings_errors(1, *command_line);
 523
 524           ap_alh_start_time=token_value;
 525           ap_alh_on = 1;
 526           break;
 527         }
 528       case ap_rah_flag:
 529         {
 530           if (check_float(linetoken3))
 531             token3 >> token_value;
 532           else
 533             uiuc_warnings_errors(1, *command_line);
 534
 535           ap_rah_start_time=token_value;
 536           ap_rah_on = 1;
 537           break;
 538         }
 539       case ap_hh_flag:
 540         {
 541           if (check_float(linetoken3))
 542             token3 >> token_value;
 543           else
 544             uiuc_warnings_errors(1, *command_line);
 545
 546           ap_hh_start_time=token_value;
 547           ap_hh_on = 1;
 548           break;
 549         }
 550       case ap_Theta_ref_flag:
 551         {
 552           if (check_float(linetoken3))
 553             token3 >> token_value;
 554           else
 555             uiuc_warnings_errors(1, *command_line);
 556           token4 >> token_value_convert1;
 557           convert_y = uiuc_convert(token_value_convert1);
 558
 559           ap_Theta_ref_rad = token_value * convert_y;
 560           break;
 561         }
 562       case ap_alt_ref_flag:
 563         {
 564           if (check_float(linetoken3))
 565             token3 >> token_value;
 566           else
 567             uiuc_warnings_errors(1, *command_line);
 568
 569           ap_alt_ref_ft = token_value;
 570           break;
 571         }
 572       case ap_Phi_ref_flag:
 573         {
 574           if (check_float(linetoken3))
 575             token3 >> token_value;
 576           else
 577             uiuc_warnings_errors(1, *command_line);
 578           token4 >> token_value_convert1;
 579           convert_y = uiuc_convert(token_value_convert1);
 580
 581           ap_Phi_ref_rad = token_value * convert_y;
 582           break;
 583         }
 584       case ap_Psi_ref_flag:
 585         {
 586           if (check_float(linetoken3))
 587             token3 >> token_value;
 588           else
 589             uiuc_warnings_errors(1, *command_line);
 590           token4 >> token_value_convert1;
 591           convert_y = uiuc_convert(token_value_convert1);
 592
 593           ap_Psi_ref_rad = token_value * convert_y;
 594           break;
 595         }
 596       default:
 597         {
 598           if (ignore_unknown_keywords) {
 599             // do nothing
 600           } else {
 601             // print error message
 602             uiuc_warnings_errors(2, *command_line);
 603           }
 604           break;
 605         }
 606       };
 607 }