src/ATC/approach.hxx

   1 // approach.hxx -- Approach class
   2 //
   3 // Written by Alexander Kappes, started March 2002.
   4 //
   5 // Copyright (C) 2002  Alexander Kappes
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21
  22 #ifndef _FG_APPROACH_HXX
  23 #define _FG_APPROACH_HXX
  24
  25 #include <stdio.h>
  26
  27 #include <simgear/compiler.h>
  28 #include <simgear/math/sg_geodesy.hxx>
  29 #include <simgear/misc/sgstream.hxx>
  30 #include <simgear/magvar/magvar.hxx>
  31 #include <simgear/timing/sg_time.hxx>
  32 #include <simgear/bucket/newbucket.hxx>
  33
  34 #include <Main/fg_props.hxx>
  35
  36 #ifdef SG_HAVE_STD_INCLUDES
  37 #  include <istream>
  38 #include <iomanip>
  39 #elif defined( SG_HAVE_NATIVE_SGI_COMPILERS )
  40 #  include <iostream.h>
  41 #elif defined( __BORLANDC__ ) || (__APPLE__)
  42 #  include <iostream>
  43 #else
  44 #  include <istream.h>
  45 #include <iomanip.h>
  46 #endif
  47
  48 #if ! defined( SG_HAVE_NATIVE_SGI_COMPILERS )
  49 SG_USING_STD(istream);
  50 #endif
  51
  52 SG_USING_STD(string);
  53
  54 #include "ATC.hxx"
  55
  56 //DCL - a complete guess for now.
  57 #define FG_APPROACH_DEFAULT_RANGE 100
  58
  59 // Contains all information about a plane that the approach control needs
  60 const int max_planes = 20;  // max number of planes on the stack
  61 const int max_wp = 10;      // max number of waypoints for approach phase
  62 struct PlaneApp {
  63
  64   // variables for plane if it's on the radar
  65   string ident;          // indentification of plane
  66   double lon;            // longitude in degrees
  67   double lat;            // latitude in degrees
  68   double alt;            // Altitute above sea level in feet
  69   double hdg;            // heading of plane in degrees
  70   double dist;           // distance to airport in miles
  71   double brg;            // bearing relative to airport in degrees
  72   double spd;            // speed above ground
  73   int    contact;        // contact with approach established?
  74                          // 0 = no contact yet
  75                          // 1 = in contact
  76                          // 2 = handed off to tower
  77
  78   // additional variables if contact has been established
  79   int    wpn;                 // number of waypoints
  80   double wpts[max_wp][6];     // assigned waypoints for approach phase
  81                               // first wp in list is airport
  82                               // last waypoint point at which contact was established
  83                               // second index: 0 = bearing to airport
  84                               // second index: 1 = distance to aiport
  85                               // second index: 2 = alt
  86                               // second index: 3 = ETA
  87                               // second index: 4 = heading to next waypoint
  88                               // second index: 5 = distance to next waypoint
  89
  90   double dnwp;           // distance to next waypoint
  91   double dcc;            // closest distance to current assigned course
  92   double dnc;            // closest distance to course from next to next to next wp
  93   double aalt;           // assigned alt at next waypoint
  94   double ahdg;           // assigned heading
  95   bool   on_crs;         // is the plane on course?
  96   double tlm;            // time when last message was sent
  97
  98   PlaneApp(void);
  99 };
 100
 101
 102 class FGApproach : public FGATC {
 103
 104   char     type;
 105   double   lon, lat;
 106   double   elev;
 107   double   x, y, z;
 108   int      freq;
 109   int      bucket;
 110   double   range;
 111
 112   string active_runway;
 113   double active_rw_hdg;
 114
 115   bool     display;             // Flag to indicate whether we should be outputting to the display.
 116   bool     displaying;          // Flag to indicate whether we are outputting to the display.
 117   string   ident;               // Code of the airport its at.
 118   string   name;                // Name transmitted in the broadcast.
 119   int      num_planes;          // number of planes on the stack
 120   PlaneApp planes[max_planes];  // Array of planes
 121   string   transmission;
 122   bool     first;
 123
 124   SGPropertyNode *comm1_node;
 125   SGPropertyNode *comm2_node;
 126
 127   // for failure modeling
 128   string trans_ident;   // transmitted ident
 129   bool approach_failed; // approach failed?
 130
 131 public:
 132
 133   FGApproach(void);
 134   ~FGApproach(void);
 135
 136   void Init();
 137
 138   void Update();
 139
 140   // Add new plane to stack if not already registered
 141   // Input:  pid - id of plane (name)
 142   // Output: "true" if added; "false" if already existend
 143   void AddPlane(string pid);
 144
 145   // Remove plane from stack if out of range
 146   int RemovePlane();
 147
 148   //Indicate that this instance should be outputting to the ATC display
 149   inline void SetDisplay(void) {display = true;}
 150
 151   //Indicate that this instance should not be outputting to the ATC display
 152   inline void SetNoDisplay(void) {display = false;}
 153
 154   inline char get_type() const { return type; }
 155   inline double get_lon() const { return lon; }
 156   inline double get_lat() const { return lat; }
 157   inline double get_elev() const { return elev; }
 158   inline double get_x() const { return x; }
 159   inline double get_y() const { return y; }
 160   inline double get_z() const { return z; }
 161   inline double get_bucket() const { return bucket; }
 162   inline int get_freq() const { return freq; }
 163   inline double get_range() const { return range; }
 164   inline int get_pnum() const { return num_planes; }
 165   inline const char* GetIdent() { return ident.c_str(); }
 166   inline string get_trans_ident() { return trans_ident; }
 167   inline string get_name() { return name; }
 168   inline atc_type GetType() { return APPROACH; }
 169
 170 private:
 171
 172   void update_plane_dat();
 173
 174   void get_active_runway();
 175
 176 // ========================================================================
 177 // get heading and distance between two points; point2 ---> point1
 178 // input: point1 = heading in degrees, distance
 179 // input: point2 = heading in degrees, distance
 180 // ouput: course in degrees, distance
 181 // ========================================================================
 182   void calc_hd_course_dist(const double &h1, const double &d1,
 183                            const double &h2, const double &d2,
 184                            double *course, double *dist);
 185
 186 // ========================================================================
 187 // closest distance between a point and a straigt line in 2 dim.
 188 // the input variables are given in (heading, distance)
 189 // relative to a common point
 190 // input:  point        = heading in degrees, distance
 191 // input:  straigt line = anker vector (heading in degrees, distance),
 192 //                        heading of direction vector
 193 // output: distance
 194 // ========================================================================
 195   double calc_psl_dist(const double &h1, const double &d1,
 196                        const double &h2, const double &d2,
 197                        const double &h3);
 198
 199   // Pointers to current users position
 200   SGPropertyNode *lon_node;
 201   SGPropertyNode *lat_node;
 202   SGPropertyNode *elev_node;
 203
 204   //Update the transmission string
 205   void UpdateTransmission(void);
 206
 207   friend istream& operator>> ( istream&, FGApproach& );
 208 };
 209
 210
 211 inline istream&
 212 operator >> ( istream& in, FGApproach& a )
 213 {
 214     double f;
 215     char ch;
 216
 217     static bool first_time = true;
 218     static double julian_date = 0;
 219     static const double MJD0    = 2415020.0;
 220     if ( first_time ) {
 221         julian_date = sgTimeCurrentMJD(0, 0) + MJD0;
 222         first_time = false;
 223     }
 224
 225     in >> a.type;
 226
 227     if ( a.type == '[' )
 228       return in >> skipeol;
 229
 230     in >> a.lat >> a.lon >> a.elev >> f >> a.range
 231        >> a.ident;
 232
 233     a.name = "";
 234     in >> ch;
 235     a.name += ch;
 236     while(1) {
 237         //in >> noskipws
 238         in.unsetf(ios::skipws);
 239         in >> ch;
 240         a.name += ch;
 241         if((ch == '"') || (ch == 0x0A)) {
 242             break;
 243         }   // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
 244     }
 245     in.setf(ios::skipws);
 246     //cout << "approach.name = " << a.name << '\n';
 247
 248     a.freq = (int)(f*100.0 + 0.5);
 249
 250     // generate cartesian coordinates
 251     Point3D geod( a.lon * SGD_DEGREES_TO_RADIANS , a.lat * SGD_DEGREES_TO_RADIANS,
 252                   a.elev * SG_FEET_TO_METER );
 253     Point3D cart = sgGeodToCart( geod );
 254     a.x = cart.x();
 255     a.y = cart.y();
 256     a.z = cart.z();
 257
 258     // get bucket number
 259     SGBucket buck(a.lon, a.lat);
 260     a.bucket = buck.gen_index();
 261
 262     a.trans_ident = a.ident;
 263     a.approach_failed = false;
 264
 265     return in >> skipeol;
 266 }
 267
 268 #endif // _FG_APPROACH_HXX