src/Environment/environment_ctrl.hxx

   1 // environment-ctrl.hxx -- controller for environment information.
   2 //
   3 // Written by David Megginson, started May 2002.
   4 //
   5 // Copyright (C) 2002  David Megginson - david@megginson.com
   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23 #ifndef _ENVIRONMENT_CTRL_HXX
  24 #define _ENVIRONMENT_CTRL_HXX
  25
  26 #include <simgear/compiler.h>
  27 #include <simgear/structure/subsystem_mgr.hxx>
  28
  29 #if defined(ENABLE_THREADS)
  30 # include <OpenThreads/Thread>
  31 # include <simgear/threads/SGQueue.hxx>
  32 #endif
  33
  34 #include <queue>
  35 #include <vector>
  36
  37 #include <Navaids/positioned.hxx>
  38 #include <Environment/environment.hxx>
  39 #include "fgwind.hxx"
  40
  41 // forward decls
  42 class SGPropertyNode;
  43 class FGMetar;
  44
  45 /**
  46  * Interface to control environment information for a specific location.
  47  */
  48 class FGEnvironmentCtrl : public SGSubsystem
  49 {
  50
  51 public:
  52
  53         FGEnvironmentCtrl ();
  54         virtual ~FGEnvironmentCtrl ();
  55
  56         virtual void setEnvironment (FGEnvironment * environment);
  57
  58         virtual const FGEnvironment * getEnvironment () const { return _environment; }
  59
  60         virtual void setLongitudeDeg (double lon_deg);
  61         virtual void setLatitudeDeg (double lat_deg);
  62         virtual void setElevationFt (double elev_ft);
  63         virtual void setPosition (double lon_deg, double lat_deg, double elev_ft);
  64
  65         virtual double getLongitudeDeg () const { return _lon_deg; }
  66         virtual double getLatitudeDeg () const { return _lat_deg; }
  67         virtual double getElevationFt () const { return _elev_ft; }
  68
  69 protected:
  70
  71         FGEnvironment * _environment;
  72         double _lon_deg;
  73         double _lat_deg;
  74         double _elev_ft;
  75
  76 };
  77
  78
  79 \f
  80 /**
  81  * Interplation controller using user-supplied parameters.
  82  */
  83 class FGInterpolateEnvironmentCtrl : public FGEnvironmentCtrl
  84 {
  85 public:
  86         FGInterpolateEnvironmentCtrl ();
  87         virtual ~FGInterpolateEnvironmentCtrl ();
  88
  89         virtual void init ();
  90         virtual void reinit ();
  91         virtual void update (double delta_time_sec);
  92
  93 private:
  94
  95         struct bucket {
  96                 double altitude_ft;
  97                 FGEnvironment environment;
  98                 bool operator< (const bucket &b) const;
  99                 // LessThan predicate for bucket pointers.
 100                 static bool lessThan(bucket *a, bucket *b);
 101         };
 102
 103         void read_table (const SGPropertyNode * node, std::vector<bucket *> &table);
 104         void do_interpolate (std::vector<bucket *> &table, double altitude_ft,
 105                                                  FGEnvironment * environment);
 106
 107         FGEnvironment env1, env2;        // temporaries
 108
 109         std::vector<bucket *> _boundary_table;
 110         std::vector<bucket *> _aloft_table;
 111
 112         SGPropertyNode_ptr altitude_n;
 113         SGPropertyNode_ptr altitude_agl_n;
 114         SGPropertyNode_ptr boundary_transition_n;
 115         SGPropertyNode_ptr boundary_n;
 116         SGPropertyNode_ptr aloft_n;
 117 };
 118
 119
 120 \f
 121 /**
 122  * Interplation controller using the FGMetar class
 123  */
 124
 125 class FGMetarCtrl : public SGSubsystem
 126 {
 127 public:
 128         FGMetarCtrl (SGSubsystem * environmentCtrl);
 129         virtual ~FGMetarCtrl ();
 130
 131         virtual void init ();
 132         virtual void reinit ();
 133         virtual void update (double delta_time_sec);
 134
 135         void set_metar( const char * metar );
 136         const char * get_metar(void) const;
 137         bool get_valid(void) const { return metar_valid; }
 138         void set_enabled(bool _enabled) { enabled = _enabled; }
 139         bool get_enabled(void) const { return enabled; }
 140         void set_setup_winds_aloft(bool _setup_winds_aloft) { setup_winds_aloft = _setup_winds_aloft; }
 141         bool get_setup_winds_aloft(void) const { return setup_winds_aloft; }
 142
 143 private:
 144         void bind();
 145         void unbind();
 146
 147         SGSharedPtr<FGWindModulator> windModulator;
 148         bool metar_valid;
 149         bool enabled;
 150         bool setup_winds_aloft;
 151         bool first_update;
 152         bool wind_interpolation_required;
 153         double station_elevation_ft;
 154         string metar;
 155         double interpolate_prop(const char * currentname, const char * requiredname, double dvalue);
 156         double interpolate_val(double currentval, double requiredval, double dvalue);
 157         const double EnvironmentUpdatePeriodSec;        // Seconds between interpolations
 158         const double MaxWindChangeKtsSec;                        // Max wind change in kts/sec
 159         const double MaxVisChangePercentSec;            // Max visibility change in %/sec
 160         const double MaxPressureChangeInHgSec;          // Max pressure change in InHg/sec
 161         const double MaxCloudAltitudeChangeFtSec;        // Max cloud altitude change in ft/s
 162         const double MaxCloudThicknessChangeFtSec;      // Max cloud thickness change in ft/s
 163         const double MaxCloudInterpolationHeightFt; // Max distance from aircraft to
 164                                                                                                 // interpolate at. Any cloud
 165                                                                                                 // changes above this height
 166                                                                                                 // difference are not interpolated
 167         const double MaxCloudInterpolationDeltaFt;      // Max difference in altitude to
 168                                                                                                 // interpolate. Any cloud changing height
 169                                                                                                 // by more than this value is not
 170                                                                                                 // interpolated
 171
 172         SGSubsystem * _environmentCtrl;
 173
 174         SGPropertyNode_ptr metar_base_n;
 175         SGPropertyNode_ptr station_id_n;
 176         SGPropertyNode_ptr station_elevation_n;
 177         SGPropertyNode_ptr min_visibility_n;
 178         SGPropertyNode_ptr max_visibility_n;
 179         SGPropertyNode_ptr base_wind_range_from_n;
 180         SGPropertyNode_ptr base_wind_range_to_n;
 181         SGPropertyNode_ptr base_wind_dir_n;
 182         SGPropertyNode_ptr base_wind_speed_n;
 183         SGPropertyNode_ptr gust_wind_speed_n;
 184         SGPropertyNode_ptr temperature_n;
 185         SGPropertyNode_ptr dewpoint_n;
 186         SGPropertyNode_ptr humidity_n;
 187         SGPropertyNode_ptr pressure_n;
 188         SGPropertyNode_ptr clouds_n;
 189         SGPropertyNode_ptr environment_clouds_n;
 190         SGPropertyNode_ptr rain_n;
 191         SGPropertyNode_ptr hail_n;
 192         SGPropertyNode_ptr snow_n;
 193         SGPropertyNode_ptr snow_cover_n;
 194         SGPropertyNode_ptr ground_elevation_n;
 195         SGPropertyNode_ptr longitude_n;
 196         SGPropertyNode_ptr latitude_n;
 197         SGPropertyNode_ptr magnetic_variation_n;
 198
 199         SGPropertyNode_ptr boundary_wind_speed_n;
 200         SGPropertyNode_ptr boundary_wind_from_heading_n;
 201         SGPropertyNode_ptr boundary_visibility_n;
 202         SGPropertyNode_ptr boundary_sea_level_pressure_n;
 203 private:
 204
 205 };
 206
 207 /*
 208  * The subsyste to load real world weather
 209  */
 210 class FGMetarFetcher : public SGSubsystem
 211 {
 212 public:
 213         FGMetarFetcher();
 214         virtual ~FGMetarFetcher();
 215
 216         virtual void init ();
 217         virtual void reinit ();
 218         virtual void update (double delta_time_sec);
 219
 220 private:
 221         friend class MetarThread;
 222 #if defined(ENABLE_THREADS)
 223         /**
 224          * FIFO queue which holds a pointer to the metar requests.
 225          */
 226         SGBlockingQueue <string> request_queue;
 227
 228         OpenThreads::Thread * metar_thread;
 229 #endif
 230
 231         void fetch( const string & id );
 232
 233         SGPropertyNode_ptr enable_n;
 234
 235         SGPropertyNode_ptr longitude_n;
 236         SGPropertyNode_ptr latitude_n;
 237
 238         SGPropertyNode_ptr proxy_host_n;
 239         SGPropertyNode_ptr proxy_port_n;
 240         SGPropertyNode_ptr proxy_auth_n;
 241         SGPropertyNode_ptr max_age_n;
 242
 243         SGPropertyNode_ptr output_n;
 244
 245         string current_airport_id;
 246         double fetch_timer;
 247         double search_timer;
 248         double error_timer;
 249
 250         long _stale_count;
 251         long _error_count;
 252 };
 253
 254
 255 #endif // _ENVIRONMENT_CTRL_HXX