home *** CD-ROM | disk | FTP | other *** search
/ Hacker Chronicles 2 / HACKER2.BIN / 283.WING.PAS < prev    next >
Pascal/Delphi Source File  |  1986-05-13  |  24KB  |  486 lines
  1.  
  2. Program Bootstrap_SailPlane;
  3.  (*************************************************************************)
  4.  (* Loosely Derived from articles in Soar Tech # 2, 1983, by Armin Saxer, *)
  5.  (* pgs 38..42, Chuck Anderson, pgs 130..191, and the Schlosser Brothers, *)
  6.  (* pgs 16..22, and Soar Tech # 1, 1982, the article by Martin Simons.    *)
  7.  (* Converted from BASIC, TI-59 and HP-41 Languages to Turbo Pascal.      *)
  8.  (*   Program Source Code By Ed Karns with help from Rolf Unternaehrer    *)
  9.  (*                  VERSION 2.06 May 1986. CopyRight 1986                *)
  10.  (*                                                                       *)
  11.  (*      This program source code is offered on a "free ware" basis.      *)
  12.  (*        If you find the WING PROGRAM of value, send $25.00 to :        *)
  13.  (*         Departure Company, 16 Jess Ave., Petaluma, Ca. 94952          *)
  14.  (* In return we will send a copy of Soar Tech #2 an excellent sailplane  *)
  15.  (* publication and the source for much of this program's documentation   *)
  16.  (* and latest version of this program.                                   *)
  17.  (*************************************************************************)
  18.  (*  Compiler Directives for proper modification. All Set for max. speed  *)
  19.  {$C+,D+,F2,I+,K-,R-,V+,U-}
  20. Const                                    (* Constants *)
  21.        Gravity   : Real = 9.80665;       (* Gravitional Pull of the Earth *)
  22.        Gas_Const : Real = 29.27;         (* R , Universal Gas Constant    *)
  23.        FRE       : Real = 68459.6;       (* Reynolds Calculation Factor   *)
  24.        Number_of_Records : Integer = 45; (* Number of air foils in record *)
  25.      (* Pi is predetermined by Turbo Pascal, others > Pi : Real = 3.14159 *)
  26.  
  27. Type    Air_Foil_Record  = Record
  28.                  Name : String [30];   (* like E205 or NACA 2214, etc.  *)
  29.                  R_Number1   : Real;   (* Reynolds assoc. with CD_Array *)
  30.                  R_Number2   : Real;
  31.                  R_Number3   : Real;
  32.                  R_Number4   : Real;
  33.                  Drag_Array1 : Array [1..64] of Real;
  34.                  Drag_Array2 : Array [1..64] of Real;
  35.                  Drag_Array3 : Array [1..64] of Real;
  36.                  Drag_Array4 : Array [1..64] of Real;
  37.                  Rec_Number  : Integer;  (* File Pointer *)
  38.         End;  (* Random access file on disk containing : Foil name, Four  *)
  39.      (* Reynolds numbers, C/D arrays related to R #'s, and record number. *)
  40.  
  41.      (* Variables For Diminsions, Weights, Coefficents, Ratios, Etc...    *)
  42. Var   Root_Chord, RC           : Real;    (* Root Chord of Wing, mm *)
  43.       Root_Foil_Thickness, RFT : Real;
  44.       Tip_Chord, TC            : Real;    (* Tip Chord of Wing, mm *)
  45.       Tip_Foil_Thickness, TFT  : Real;
  46.       Mean_Chord, TM           : Real;    (* Mean Chord of Wing, millimeters *)
  47.       Percent_Thickness        : Real;    (* Airfoil thickness in Percent, % *)
  48.       Wing_Span, S             : Real;    (* Wing Span in millmeters *)
  49.       Wing_Area, WA            : Real;    (* Wing Surface Area, m^2 *)
  50.       Wing_Sweep, WW           : Real;    (* Wing Root/Tip LE Difference *)
  51. (**)  Stab_Root, SR            : Real;    (* Stabalizer Root Chord *)
  52.       Stab_Tip, ST             : Real;    (* Stab Tip Chord *)
  53.       Stab_Span, SS            : Real;    (* Stab Span *)
  54.       Stab_Area, SA            : Real;    (* Stab Area *)
  55.       Stab_Sweep, SW           : Real;    (* Stab Root/Tip LE Difference *)
  56. (**)  Fin_Root, FR             : Real;    (* Fin Root Chord *)
  57.       Fin_Tip, FT              : Real;    (* Fin Tip Chord *)
  58.       Fin_Height, HT           : Real;    (* Fin Height in Inches *)
  59.       Fin_Area, SV             : Real;    (* Fin Area, Square Inches *)
  60.       Fin_Sweep, FW            : Real;    (* Fin Root/Tip LE Difference *)
  61. (**)  Wing_Stab, WS            : Real;    (* Wing Root LE to Stab Root LE *)
  62.       Wing_Fin, WF             : Real;    (* Distance WLE/FLE *)
  63.       Fin_Distance, FD         : Real;    (* Geo. Aero. Center Dist., W / F *)
  64.       L_Distance, L            : Real;    (* Intermediate Result *)
  65.       CG_Distance, P           : Real;    (* Distance from wing LE to CG *)
  66.       F_Distance, F            : Real;    (* Intermediate Result *)
  67.       Wing_GAC, WG             : Real;    (* Wing Geo. Aero. Center *)
  68.       Stab_GAC, SG             : Real;    (* Stab Geo. Aero. Center *)
  69.       Fin_GAC, FG              : Real;    (* Fin Geo. Aero. Center *)
  70. (**)  Aspect_Ratio             : Real;    (* LAM, Aspect ( span/cord ) Ratio *)
  71.       Glide_Ratio              : Real;    (* Glide ( lift to drag ) Ratio *)
  72.       Fin_Ratio                : Real;    (* AV, Fin Aspect Ratio *)
  73.       Stab_Ratio               : Real;    (* Horiz. Stab. Aspect Ratio *)
  74.       Wing_Load, FB            : Real;    (* Wing Loading, kg/m^2 *)
  75.       Wing_Dihedral            : Real;    (* Dihedral in Degrees *)
  76.       Stability_Factor         : Real;    (* Stability Factor, Negative # *)
  77. (**)  Lift_Coef                : Real;    (* CA, Lift Coefficent *)
  78.       Air_Force_Coef           : Real;    (* CR, Resultant Air Force Coeff. *)
  79.       Total_Drag_Coef          : Real;    (* CW, Total Drag Coefficent *)
  80.       Induced_Drag_Coef        : Real;    (* CWI, Induced Drag Coefficent *)
  81.       Profile_Drag_Coef        : Real;    (* CWP, Profile Drag Coefficent *)
  82.       Parasite_Drag_Coef       : Real;    (* CWZ, Parasitic Drag Coefficent *)
  83.       Tail_Drag_Coef           : Real;    (* Tail & Fuse Drag Coefficent *)
  84.       Tail_Vol_Coef            : Real;    (* Tail Volume Coefficent *)
  85. (**)  Speed, V                 : Real;    (* Flight Speed of Plane, m/s *)
  86.       Horiz_Speed, VX          : Real;    (* Horizontal Component of Speed *)
  87.       Vert_Speed, VY           : Real;    (* Vertical Component of Speed *)
  88. (**)  Weight, GM, B_Weight, BGM: Real;    (* Actual SailPlane Weight, kgrams *)
  89.       Temperature, T           : Real;    (* Temperature, C degrees *)
  90.       Atmos_Density, DL        : Real;    (* Atmospheric Density, kps/m^2 *)
  91.       Air_Press, Pr            : Real;    (* Air Pressure, kg/m^2 *)
  92.  Reynolds, Reynolds1, Reynolds2, Reynolds3, Reynolds4 : Real;
  93.  Foil, Foil1, Foil2, Foil3, Foil4 : Array [1 .. 64] of Real; (* AIRFOIL.DAT *)
  94.  Result, Result1, Result2, Result3, Result4, Result5, Result6 : Real;
  95.  Foil_File : File of Air_Foil_Record; (* Turbo needs it this way *)
  96.  Foil_Record       : Air_Foil_Record; (* These name the File on Disk *)
  97.  Units, Foil_Name      : String [30]; (* Display string *)
  98.  Ans, Wing_Position        : Char;    (* Keyboard Answer, Wing Position *)
  99.  I, J, X, Y, File_Pointer  : Integer; (* Counters for Program Control *)
  100.  Metric, T_Tail, Stall     : Boolean; (* Units, T Tail, True or False *)
  101.  
  102.    (* The following are all the key formulae functions for the program *)
  103.  
  104. Function Fixed_Calc : Real;  Begin (* Does All Fixed Dimension Calculations *)
  105.  
  106.    Atmos_Density :=
  107.     ( Air_Press / ( Gas_Const * ( Temperature + 273.00 ))) / Gravity;
  108.        (*    DL = GA / g   *)    (*    GA = Pr / ( R * ( T + 273 ))   *)
  109.  
  110.    Mean_Chord := (( Root_Chord + Tip_Chord ) / 2 ) / 100;
  111.     TM := ( RC + TC ) / 2; (* in Inches *)
  112.        (* Mean Chord = ( Root Chord + Tip Chord ) / 2 in Meters *)
  113.  
  114.    Wing_Area :=  Wing_Span * Mean_Chord;    (* in Square Meters *)
  115.     WA := S * TM;                           (* in Square Inches *)
  116.        (*   WA = S * TM   *)
  117.  
  118.    Wing_GAC :=
  119. (( Root_Chord * Root_Chord + Root_Chord * Tip_Chord + Tip_Chord * Tip_Chord )
  120.            / ( Root_Chord + Tip_Chord ) / 6 )   +
  121.         (( Wing_Sweep / 3 ) * ( Root_Chord + 2 * Tip_Chord )
  122.            / ( Root_Chord + Tip_Chord ));
  123.     WG := Wing_GAC / 2.540; (* Converts to Inches *)
  124.  
  125.    Aspect_Ratio := Wing_Span / Mean_Chord;
  126.        (*   LAM = S / TM   *)
  127.  
  128.    Wing_Load := ( Weight + B_Weight ) / Wing_Area;
  129.     FB := ( ( GM + BGM ) / WA ) * 16; (* Converts to Oz. per Sq. Inch *)
  130.        (*    FB = GM / WA    *)
  131.  
  132.    Stab_Area := (( Stab_Root + Stab_Tip ) / 2 ) * Stab_Span; (* in C.Meters *)
  133.     SA := (( SR + ST ) / 2 ) * SS; (* in Square Inches *)
  134.  
  135.    Stab_GAC :=
  136.    (( Stab_Root * Stab_Root + Stab_Root * Stab_Tip + Stab_Tip * Stab_Tip )
  137.             / ( Stab_Root + Stab_Tip ) / 6 )   +
  138.         (( Stab_Sweep / 3 ) * ( Stab_Root + 2 * Stab_Tip )
  139.            / ( Stab_Root + Stab_Tip ));
  140.     SG := Stab_GAC / 2.540; (* Converts to Inches *)
  141.  
  142.    Stab_Ratio := ( (SR + ST) * (SR + ST) / 2 ) / SS;
  143.        (*  Horiz. Stab Aspect Ratio  *)
  144.  
  145.    Fin_Area := (( Fin_Root + Fin_Tip ) / 2 ) * Fin_Height; (* in Sq. CM's *)
  146.     SV := (( FR + FT ) / 2 ) * HT; (* in Square Inches *)
  147.  
  148.    Fin_GAC :=
  149.    (( Fin_Root * Fin_Root + Fin_Root * Fin_Tip + Fin_Tip * Fin_Tip )
  150.             / ( Fin_Root + Fin_Tip ) / 6 )   +
  151.         (( Fin_Sweep / 3 ) * ( Fin_Root + 2 * Fin_Tip )
  152.            / ( Fin_Root + Fin_Tip ));
  153.     FG := Fin_GAC / 2.540; (* Converts to Inches *)
  154.  
  155.    Fin_Ratio := ( HT * HT ) / SV;
  156.     If  T_Tail = True  Then  Fin_Ratio := 1.500 * Fin_Ratio;
  157.        (*  Fin Aspect Ratio  *)
  158.  
  159.    L_Distance := Wing_GAC - Stab_GAC + Wing_Stab + Stab_Root;
  160.     L := L_Distance / 2.540;
  161.  
  162.    CG_Distance :=
  163.      (( L_Distance * (Stab_Area/2) ) / ( 3 * (Wing_Area/2)
  164.    - ( Root_Chord * Root_Chord+ Root_Chord * Tip_Chord + Tip_Chord*Tip_Chord))
  165.              / ( 15 * (Tip_Chord + Root_Chord) ));
  166.     P := CG_Distance / 2.540;
  167.  
  168.    F_Distance := CG_Distance + Wing_Fin - Wing_GAC + Fin_GAC;
  169.     F := F_Distance / 2.540;
  170.  
  171.    Fin_Distance := Wing_Fin - Wing_GAC + Fin_GAC;
  172.     FD := Fin_Distance / 2.540;
  173.  
  174.    Tail_Vol_Coef := ( SV * FD ) / ( WA * S );
  175.  (* T_V_C = ( Fin Area * Fin Distance ) / ( Wing Surface Area * Wing Span ) *)
  176.  
  177.    Result1 := 0.0188 + ( 0.0222 * Fin_Ratio ) - ( 0.0026 * Sqr ( Fin_Ratio ));
  178.        (*  Calculation of A, See Page 42, line 130 and 210 *)
  179.  
  180.     If  Wing_Position = 'H'  Then  Result2 := 0.0  Else Result2 := 0.0001;
  181.      If  Wing_Position = 'M'  Then  Result2 := 0.0002;
  182.        (* Mid, Shoulder (Default = 0.0001) or High *)
  183.  
  184.    Stability_Factor := Result2 - ( Result1 * Tail_Vol_Coef );
  185.        (* Stability Factor = Position Constant - Tail Volume Coef * Constant *)
  186.  
  187.    Wing_Dihedral := 10 + ( 3300 * Stability_Factor );
  188.        (*   Wing Dihedral = 10 + ( 3300 * Stability Factor )   *)
  189.  
  190. End; (* of Function Fixed_Calc *)
  191.  
  192.  
  193. Function Flight_Speed : Real;  Begin
  194.      (*  Returns Velocity Through the Air and all related calcs. *)
  195.  
  196.    Induced_Drag_Coef := (( 1 + ( 0.03 * Aspect_Ratio)) *
  197.                        ( Sqr ( Lift_Coef ))) / ( Pi * Aspect_Ratio );
  198.      (*   CWI = ( 1 + FI * LAM ) * CA ^ 2 / ( Pie * LAM )   *)
  199.  
  200.    Parasite_Drag_Coef :=
  201.               Tail_Drag_Coef + ( 0.004 * ( Sqr ( Lift_Coef )));
  202.      (* Changes here as per Herk Stokely : Removal of 0.005 to account *)
  203.      (* for tail drag coef. calculated below. Tail_Drag_Coef initially *)
  204.      (* = 0.005 and CWZ = CD(tail) + ( 0.004 * CA^2 ).                 *)
  205.  
  206.    Total_Drag_Coef :=
  207.          Profile_Drag_Coef + Induced_Drag_Coef + Parasite_Drag_Coef;
  208.      (*   CW = CWP + CWI + CWZ   *)
  209.  
  210.    Air_Force_Coef := Sqrt ( Sqr ( Lift_Coef ) + Sqr (Total_Drag_Coef ));
  211.      (*   CR = Sqrt ( CA^2 + CW^2 )   *)
  212.  
  213.    Speed := Sqrt (( ( Weight + B_Weight ) * 2 ) /
  214.                ( Atmos_Density * Wing_Area * Air_Force_Coef ));
  215.      (*   V = Sqrt (( GM * 2 ) / ( WA * DL * CR ))    *)
  216.  
  217.    Vert_Speed := ( Speed * Total_Drag_Coef ) / Air_Force_Coef;
  218.      (*   VY = V * VW / CR   *)
  219.  
  220.    Horiz_Speed := ( Speed * Lift_Coef ) / Air_Force_Coef;
  221.      (*   VX = V * CA / CR    *)
  222.  
  223.    Glide_Ratio := Horiz_Speed / Vert_Speed;
  224.      (*   G = VX / VY   *)
  225.  
  226.    Reynolds :=  FRE * Mean_Chord * Speed ;
  227.      (*   Reynolds Calculation Factor = FRE = 68459.6   *)
  228.  
  229.    Tail_Drag_Coef := (( 3.75615 / Sqrt ( Reynolds )) / Wing_Area );
  230.      (* Note changes made here upon advice of Herk Stokely to correct CD *)
  231.      (*  CD ( Tail & Fuse ) = (( 3.75615 / R^1/2 ) * 1/S )  where S is WA *)
  232.      (*   From Soar Tech # 1 article and TI 59 program by Martin Simons   *)
  233.      (*   This gets added in above on next round of calculations          *)
  234.  
  235. End; (* of Function Flight_Speed *)
  236.  
  237.  
  238. Function Calc_CD : Real;  Begin
  239.    (* Calculates the Coef. of Drag for all Coef. of Lift.              *)
  240.    (* Using a rise / run approximation, fills in the blanks in arrays. *)
  241.    (* This effectively connects the points on the CL/CD graph with     *)
  242.    (* Straight lines. The more valid points entered, the better the    *)
  243.    (* curviture of the graph. Don't enter points that are not results  *)
  244.    (* from real wind tunnel tests. Guestimates are worse than nothing. *)
  245.      Foil1 [64] := 1.000;  Foil2 [64] := 1.000; (* Enters end point *)
  246.      Foil3 [64] := 1.000;  Foil4 [64] := 1.000; (* Enters end point *)
  247.      Foil [64]  := 1.000;  (* This insures end of calculations *)
  248.  
  249.   (* Fills Array of Foil1 *)
  250.      I := 1;  J := 1;                (* Initialize Counters *)
  251.  Repeat                                             (* Until I > 63 *)
  252.     Repeat                                          (* Until Foil1 > 0 *)
  253.       J := J + 1;
  254.     Until Foil1 [J] > 0.0;           (* Finds next entered point *)
  255.      Result1 := ( Foil1 [J] - Foil1 [I] ) / ( J - I ); (* Finds differential *)
  256.  (* Next adds difference to intermediate array cells *)
  257.     While I < ( J - 1 )  Do  Begin
  258.      I := I + 1;
  259.      Foil1 [I] := Foil1 [ I - 1 ] + Result1;
  260.     End; (* of while I < J - 1 *)
  261.      I := J;                         (* Points to next valid point *)
  262.  Until I > 63;                       (* Arrays are filled *)
  263.  
  264.   (* Fills Array of Foil2 *)
  265.      I := 1;  J := 1;                (* Initialize Counters *)
  266.  Repeat                                             (* Until I > 63 *)
  267.     Repeat                                           (* Until Foil2 > 0 *)
  268.       J := J + 1;
  269.     Until Foil2 [J] > 0.0;           (* Finds next entered point *)
  270.      Result1 := ( Foil2 [J] - Foil2 [I] ) / ( J - I );
  271.  (* Next add differential to previous array cell *)
  272.     While I < ( J - 1 )  Do  Begin
  273.      I := I + 1;
  274.      Foil2 [I] := Foil2 [ I - 1 ] + Result1;
  275.     End; (* of while I < J - 1 *)
  276.      I := J;                         (* Points to next valid point *)
  277.  Until I > 63;                       (* Arrays are filled *)
  278.  
  279.   (* Fills Array of Foil3 *)
  280.      I := 1;  J := 1;                (* Initialize Counters *)
  281.  Repeat                                             (* Until I > 63 *)
  282.     Repeat                                           (* Until Foil3 > 0 *)
  283.       J := J + 1;
  284.     Until Foil3 [J] > 0.0;           (* Finds next entered point *)
  285.      Result1 := ( Foil3 [J] - Foil3 [I] ) / ( J - I );
  286.             (* Determines differential for sumations *)
  287.  (* Next add differential to previous array cell *)
  288.     While I < ( J - 1 )  Do  Begin
  289.      I := I + 1;     Foil3 [I] := Foil3 [ I - 1 ] + Result1;
  290.     End; (* of while I < J - 1 *)
  291.      I := J;                         (* Points to next valid point *)
  292.  Until I > 63;                       (* Arrays are filled *)
  293.  
  294.   (* Fills Array of Foil4 *)
  295.      I := 1;  J := 1;                (* Initialize Counters *)
  296.  Repeat                                             (* Until I > 63 *)
  297.     Repeat                                           (* Until Foil4 > 0 *)
  298.       J := J + 1;
  299.     Until Foil4 [J] > 0.0;           (* Finds next entered point *)
  300.    Result1 := ( Foil4 [J] - Foil4 [I] ) / ( J - I ); (* Finds Differential *)
  301.  (* Next adds differential to previous array cell *)
  302.     While I < ( J - 1 )  Do  Begin
  303.       I := I + 1;      Foil4 [I] := Foil4 [ I - 1 ] + Result1;
  304.     End; (* of while I < J - 1 *)
  305.      I := J;                         (* Points to next valid point *)
  306.  Until I > 63;                       (* Arrays are filled *)
  307.  
  308.  (* Next Takes the Foil arrays and runs them past the Flight_Speed  *)
  309.  (* Function to produce a curve used in displaying close to real    *)
  310.  (* data in Run Procedure. Interpolations based on Soar Tech # 1    *)
  311.  (* article in TI 59 program language by Martin Simons.             *)
  312.     Lift_Coef := 0.00;    (* Init Lift Coef. for calculations of R #, etc. *)
  313.     Profile_Drag_Coef := Foil1 [1];     (* Setup for first calculation *)
  314.  
  315.  For I := 1 to 63  Do  Begin
  316.     Result := Flight_Speed;  (* Calls Function that returns new Reynolds *)
  317.   If Reynolds >= Reynolds4  Then
  318.       Foil [I] := Foil4 [I] * ( Sqrt ( Reynolds4 / Reynolds ));
  319.       (* Note that if R4 is set greater than 3 or 4 million then this    *)
  320.       (* If statement is Ignored, as requires very high speed to reach   *)
  321.       (* and displayed results are obtained using only 3 Reynolds arrays *)
  322.   If Reynolds < Reynolds4  Then
  323.    If Reynolds >= Reynolds3  Then
  324.       Foil [I] := Foil3 [I] * ( Sqrt ( Reynolds3 / Reynolds ));
  325.   If Reynolds < Reynolds3  Then
  326.    If Reynolds >= Reynolds2  Then
  327.       Foil [I] := Foil2 [I] * ( Sqrt ( Reynolds2 / Reynolds ));
  328.   If Reynolds < Reynolds2  Then
  329.       Foil [I] := Foil1 [I] * ( Sqrt ( Reynolds1 / Reynolds ));
  330.     Profile_Drag_Coef := Foil [I]; (* Previous Foil [I] used for next R # *)
  331.     Lift_Coef := Lift_Coef + 0.020; (* Increment Lift Coef for next calc. *)
  332.  End; (* of For I = 1 to 63, I Indexes automatically, end of Interpolations *)
  333. End; (* of Function Calc_CD *)
  334.  
  335.                     (* End of Functions,  Begining of Procedures *)
  336. {$I WINGIT.INC}     (* Include Files - Including many Procedures *)
  337.  
  338. Procedure ReSet_Defaults;  Begin
  339.      (* Initialization of Variables, F3B Glider at Reasonable Weight    *)
  340.      (* Using E 387 Air Foil, 3.0 Meter Span, 25 Centimeter Chord, 10 % *)
  341.      (* Mid Wing Mount, 2.5 Kilos All Up, Std. Temp. & Pressure.        *)
  342.    X := 1;   Y := 3;   Foil_Name := '';   I := 1;
  343.  T_Tail := False;    Metric:= True;  Stall := False;
  344.  Temperature         := 15.0;     T   := (( 9 / 5 ) * Temperature ) + 32.0;
  345.  Air_Press           := 10132.0;  Pr  := ( 2116.0 / 10132.0 ) * Air_Press;
  346.  Root_Chord          := 22.0;     RC  := Root_Chord / 2.540;
  347.  Root_Foil_Thickness := 2.20;     RFT := Root_Foil_Thickness / 2.540;
  348.  Tip_Chord           := 22.0;     TC  := Tip_Chord / 2.540;
  349.  Tip_Foil_Thickness  := 2.20;     TFT := Tip_Foil_Thickness / 2.540;
  350.  Percent_Thickness   := 10.0;
  351.  Wing_Span  := 2.74;               S  := Wing_Span * ( 36 / 0.9144 ); (* " *)
  352.  Wing_Sweep := 9.00;               WW := Wing_Sweep / 2.540; (* CM & " *)
  353.  Stab_Root  := 10.00;              SR := Stab_Root / 2.540;
  354.  Stab_Tip   := 10.00;              ST := Stab_Tip / 2.540;
  355.  Stab_Span  := 60.00;              SS := Stab_Span / 2.540;
  356.  Stab_Sweep := 2.50;               SW := Stab_Sweep / 2.540;
  357.  Wing_Stab  := 95.00;              WS := Wing_Stab / 2.540;
  358.  Fin_Root   := 22.00;              FR := Fin_Root / 2.540;
  359.  Fin_Tip    := 6.00;               FT := Fin_Tip / 2.540;
  360.  Fin_Height := 22.00;              HT := Fin_Height / 2.540;
  361.  Fin_Sweep  := 18.00;              FW := Fin_Sweep / 2.540;
  362.  Wing_Fin   := 90.00;              WF := Wing_Fin / 2.540;
  363.  Weight     := 1.90;               GM := Weight / 0.45359237; (* # to Kilos *)
  364.  B_Weight    := 0.00;             BGM := B_Weight / 0.45359237;(* # to Kilos *)
  365.  Wing_Position := 'M';             (* M is for Mid Position *)
  366.  Tail_Drag_Coef := 0.005;
  367.  (* Initial value of Tail_Drag_Coef changed after first run of Functions *)
  368. End; (* of Procedure ReSet_Defaults *)
  369.  
  370.  
  371. Procedure Double_Check;  Begin
  372.     ClrScr; (* Clears the Screen *)  GotoXY ( 10, 10 );
  373.     Write ('Are You Sure That You Want to RESET ALL VARIABLES  ??');
  374.      Read ( Kbd, Ans );
  375.    If UpCase ( Ans ) = 'Y'  Then  ReSet_Defaults;
  376. End; (* of Procedure Double_Check *)
  377.  
  378.  
  379. Procedure Menu;  Begin     (* Displays Menu, Menu of Choises *)
  380.     ClrScr;  (* Clears the Screen *)
  381.  GotoXY ( 1, 3 );                                            LowVideo;
  382.  Writeln ('      * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *');
  383.  Writeln;                                                    NormVideo;
  384.  Writeln ('           A =  Changes  Air Foils');
  385.  Writeln ('           E =  Edits Air Foils in storage files');
  386.  Writeln;
  387.  Writeln ('           W =  Changes  Wing Chord, Thickness and Span');
  388.  Writeln ('           F =  Changes  Fin and Rudder Dimensions');
  389.  Writeln ('           S =  Changes  Horiz. Stabilizer Dimensions');
  390.  Writeln ('           U =  Changes  Units, Temp., Press, & Flying Mass');
  391.  Writeln;
  392.  Writeln ('           R =  Reset   ALL   Variables to Original Values');
  393.  Writeln;
  394.  Writeln ('           T =  Display  Tail Fixed Dimension Results');
  395.  Writeln ('           D =  Display  Wing Fixed Dimension Results');
  396.  Writeln ('           X =  Calculates & Displays Flight Simulation');
  397.  Writeln;
  398.  Writeln ('           Q =  Quit, Exit the Program');
  399.  Writeln;                                                    LowVideo;
  400.  Writeln ('      * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *');
  401.  GotoXY ( 1, 24 );                                           NormVideo;
  402.   Write  ('          Choose :  A E    W F S U    R    T D X      Q uit  ');
  403. End; (* of Procedure Menu *) (* End of all Procedures *)
  404.  
  405.  
  406. Begin   (*   Begining  of  Main  Part  of  Program  Boot_Strap_SailPlane   *)
  407.  ClrScr; Writeln; Writeln; LowVideo;
  408.  Writeln
  409.  ('      The WING PROGRAM is made available on a   Free Ware   basis.');
  410.  Writeln;
  411.  Writeln
  412. (' Feel free to make copies of these files and pass them on to your friends.');
  413.  Writeln;
  414.  Writeln
  415.  ('    If you like this program and wish to have the latest version then');
  416.  Writeln;  NormVideo;
  417.  Writeln
  418.  ('                           Send $ 25.00 to :');
  419.  Writeln;
  420.  Writeln
  421.  ('      Departure Company  16 Jess Avenue, Petaluma, California  94952');
  422.  Writeln;  LowVideo;
  423.  Writeln
  424.  ('  We will send the latest version of the WING PROGRAM and source code and');
  425.  Writeln;
  426.  Writeln
  427.  ('    Soar Tech # 2, the fine publication that this program is based upon.');
  428.  Writeln;
  429.  Writeln
  430.  ('                Versions of the WING PROGRAM are available for :');
  431.  Writeln
  432.  ('        IBM PC, XT & AT and PClones running PC-DOS, MS-DOS and CP/M-86,');
  433.  Writeln
  434.  ('     CompuPro, Eagle, Osborne and other machines running CP/M and CP/M-86');
  435.  Writeln
  436.  ('     and  Apple II and Apple III computers running Apple ( UCSD ) Pascal.');
  437.  Writeln; Writeln;
  438.  Writeln
  439.  ('         Be sure to read the information in the "WINGREAD.ME" file.');
  440.  NormVideo;
  441.  For I := 1 to 200  Do   Begin
  442.        GotoXY ( 47, 3 );
  443.        Write ('\ Free Ware |');  GotoXY ( 75, 4 );
  444.        GotoXY ( 47, 3 );
  445.        Write ('| Free Ware \');  GotoXY ( 75, 4 );
  446.        GotoXY ( 47, 3 );
  447.        Write ('/ Free Ware -');  GotoXY ( 75, 4 );
  448.        GotoXY ( 47, 3 );
  449.        Write ('- Free Ware /');  GotoXY ( 75, 4 );
  450.        End; (* of For *)
  451.   ClrScr;
  452.   ReSet_Defaults; (* Initializes Variables *)
  453. Repeat (* Until UpCase ( Ans ) = Q for Quit *)
  454.   Repeat  (* Until UpCase ( Ans ) = Q, again *)
  455.    Result := Fixed_Calc; (* Does All Fixed Dimension ReCalculations *)
  456.    Menu;  (* Displays Menu of Choices *)
  457.    Read ( Kbd, Ans );
  458.    Case UpCase ( Ans ) of
  459.           'A' :  Change_Foil_Records;
  460.           'D' :  Display;
  461.           'E' :  Edit_AirFoil;
  462.           'F' :  Change_Fin;
  463.           'R' :  Double_Check;
  464.           'S' :  Change_Stab;
  465.           'T' :  Display_Extras;
  466.           'U' :  Change_Units;
  467.           'W' :  Change_Wing;
  468.           'X' :  Calculate_Display;
  469.           Else   Write ( ^G ); (* Bell *)
  470.    End; (* of Case *)
  471.   Until UpCase ( Ans ) = 'Q';
  472.    Ans := ' '; (* Double Q and out, done *)
  473.     ClrScr; (* Clears the Screen *)
  474.       Write ( ^G ); (* Bell *)
  475.     GotoXY ( 5, 10 );
  476.    Write
  477.     ('Entering Q for Quit will Exit the Program, Any Other Key Continues >');
  478.    Read (Kbd, Ans);
  479. Until UpCase ( Ans ) = 'Q'; (* Double Q and out, done *)
  480.  ClrScr; (* Clears the Screen *)  GotoXY ( 1, 10 );
  481.  Writeln ('                        ... the  WING  PROGRAM ...');
  482.  Writeln;
  483.  Writeln ('                CopyRight 1986 by Ed Karns   VERSION 2.06');
  484. End.
  485.   (**********************************************************)
  486.