src/Environment/realwx_ctrl.cxx

   1 // realwx_ctrl.cxx -- Process real weather data
   2 //
   3 // Written by David Megginson, started February 2002.
   4 // Rewritten by Torsten Dreyer, August 2010
   5 //
   6 // Copyright (C) 2002  David Megginson - david@megginson.com
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License as
  10 // published by the Free Software Foundation; either version 2 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21 //
  22
  23 #ifdef HAVE_CONFIG_H
  24 #  include "config.h"
  25 #endif
  26
  27 #include "realwx_ctrl.hxx"
  28 #include "tiedpropertylist.hxx"
  29 #include "metarproperties.hxx"
  30 #include "metarairportfilter.hxx"
  31 #include "fgmetar.hxx"
  32
  33 #include <Main/fg_props.hxx>
  34
  35 #include <simgear/structure/exception.hxx>
  36 #include <simgear/misc/strutils.hxx>
  37 #include <algorithm>
  38 #if defined(ENABLE_THREADS)
  39 #include <OpenThreads/Thread>
  40 #include <simgear/threads/SGQueue.hxx>
  41 #endif
  42
  43
  44 namespace Environment {
  45
  46 /* -------------------------------------------------------------------------------- */
  47
  48 class LiveMetarProperties : public MetarProperties {
  49 public:
  50     LiveMetarProperties( SGPropertyNode_ptr rootNode );
  51     virtual ~LiveMetarProperties();
  52     virtual void update( double dt );
  53
  54     virtual double getTimeToLive() const { return _timeToLive; }
  55     virtual void setTimeToLive( double value ) { _timeToLive = value; }
  56 private:
  57     double _timeToLive;
  58
  59 };
  60
  61 typedef SGSharedPtr<LiveMetarProperties> LiveMetarProperties_ptr;
  62
  63 LiveMetarProperties::LiveMetarProperties( SGPropertyNode_ptr rootNode ) :
  64     MetarProperties( rootNode ),
  65     _timeToLive(0.0)
  66 {
  67     _tiedProperties.Tie("time-to-live", &_timeToLive );
  68 }
  69
  70 LiveMetarProperties::~LiveMetarProperties()
  71 {
  72 }
  73
  74 void LiveMetarProperties::update( double dt )
  75 {
  76     _timeToLive -= dt;
  77     if( _timeToLive < 0.0 ) _timeToLive = 0.0;
  78 }
  79
  80 /* -------------------------------------------------------------------------------- */
  81
  82 class BasicRealWxController : public RealWxController
  83 {
  84 public:
  85     BasicRealWxController( SGPropertyNode_ptr rootNode );
  86     virtual ~BasicRealWxController ();
  87
  88     virtual void init ();
  89     virtual void reinit ();
  90
  91 protected:
  92     void bind();
  93     void unbind();
  94     void update( double dt );
  95
  96     virtual void update( bool first, double dt ) = 0;
  97
  98     long getMetarMaxAgeMin() const { return _max_age_n == NULL ? 0 : _max_age_n->getLongValue(); }
  99
 100     SGPropertyNode_ptr _rootNode;
 101     SGPropertyNode_ptr _longitude_n;
 102     SGPropertyNode_ptr _latitude_n;
 103     SGPropertyNode_ptr _ground_elevation_n;
 104     SGPropertyNode_ptr _max_age_n;
 105
 106     bool _enabled;
 107     bool __enabled;
 108     TiedPropertyList _tiedProperties;
 109  ;   typedef std::vector<LiveMetarProperties_ptr> MetarPropertiesList;
 110     MetarPropertiesList _metarProperties;
 111 };
 112
 113 /* -------------------------------------------------------------------------------- */
 114 /*
 115 Properties
 116  ~/enabled: bool              Enables/Disables the realwx controller
 117  ~/metar[1..n]: string        Target property path for metar data
 118  */
 119
 120 BasicRealWxController::BasicRealWxController( SGPropertyNode_ptr rootNode ) :
 121   _rootNode(rootNode),
 122   _longitude_n( fgGetNode( "/position/longitude-deg", true )),
 123   _latitude_n( fgGetNode( "/position/latitude-deg", true )),
 124   _ground_elevation_n( fgGetNode( "/position/ground-elev-m", true )),
 125   _max_age_n( fgGetNode( "/environment/params/metar-max-age-min", false ) ),
 126   _enabled(true),
 127   __enabled(false)
 128 {
 129     // at least instantiate MetarProperties for /environment/metar
 130     _metarProperties.push_back( new LiveMetarProperties(
 131             fgGetNode( rootNode->getStringValue("metar", "/environment/metar"), true ) ) );
 132
 133     PropertyList metars = rootNode->getChildren("metar");
 134     for( PropertyList::size_type i = 1; i < metars.size(); i++ ) {
 135        SG_LOG( SG_ALL, SG_INFO, "Adding metar properties at " << metars[i]->getStringValue() );
 136         _metarProperties.push_back( new LiveMetarProperties(
 137             fgGetNode( metars[i]->getStringValue(), true )));
 138     }
 139 }
 140
 141 BasicRealWxController::~BasicRealWxController()
 142 {
 143 }
 144
 145 void BasicRealWxController::init()
 146 {
 147     __enabled = false;
 148     update(0); // fetch data ASAP
 149 }
 150
 151 void BasicRealWxController::reinit()
 152 {
 153     __enabled = false;
 154 }
 155
 156 void BasicRealWxController::bind()
 157 {
 158     _tiedProperties.setRoot( _rootNode );
 159     _tiedProperties.Tie( "enabled", &_enabled );
 160 }
 161
 162 void BasicRealWxController::unbind()
 163 {
 164     _tiedProperties.Untie();
 165 }
 166
 167 void BasicRealWxController::update( double dt )
 168 {
 169   if( _enabled ) {
 170     bool firstIteration = !__enabled; // first iteration after being enabled?
 171
 172     // clock tick for every METAR in stock
 173     for( MetarPropertiesList::iterator it = _metarProperties.begin();
 174           it != _metarProperties.end(); it++ ) {
 175       // first round? All received METARs are outdated
 176       if( firstIteration ) (*it)->setTimeToLive( 0.0 );
 177       (*it)->update(dt);
 178     }
 179
 180     update( firstIteration, dt );
 181     __enabled = true;
 182   } else {
 183     __enabled = false;
 184   }
 185 }
 186
 187 /* -------------------------------------------------------------------------------- */
 188
 189 class NoaaMetarRealWxController : public BasicRealWxController {
 190 public:
 191     NoaaMetarRealWxController( SGPropertyNode_ptr rootNode );
 192     virtual ~NoaaMetarRealWxController();
 193     virtual void update (bool first, double delta_time_sec);
 194
 195     class MetarLoadRequest {
 196     public:
 197         MetarLoadRequest( const string & stationId ) {
 198             _stationId = stationId;
 199             _proxyHost = fgGetNode("/sim/presets/proxy/host", true)->getStringValue();
 200             _proxyPort = fgGetNode("/sim/presets/proxy/port", true)->getStringValue();
 201             _proxyAuth = fgGetNode("/sim/presets/proxy/authentication", true)->getStringValue();
 202         }
 203         MetarLoadRequest( const MetarLoadRequest & other ) {
 204             _stationId = other._stationId;
 205             _proxyHost = other._proxyAuth;
 206             _proxyPort = other._proxyPort;
 207             _proxyAuth = other._proxyAuth;
 208         }
 209         string _stationId;
 210         string _proxyHost;
 211         string _proxyPort;
 212         string _proxyAuth;
 213     private:
 214     };
 215
 216     class MetarLoadResponse {
 217     public:
 218         MetarLoadResponse( const string & stationId, const string metar ) {
 219             _stationId = stationId;
 220             _metar = metar;
 221         }
 222         MetarLoadResponse( const MetarLoadResponse & other ) {
 223             _stationId = other._stationId;
 224             _metar = other._metar;
 225         }
 226         string _stationId;
 227         string _metar;
 228     };
 229 private:
 230     double _positionTimeToLive;
 231     double _requestTimer;
 232
 233 #if defined(ENABLE_THREADS)
 234      class MetarLoadThread : public OpenThreads::Thread {
 235      public:
 236         MetarLoadThread( long maxAge );
 237         void requestMetar( const MetarLoadRequest & metarRequest, bool background = true );
 238         bool hasMetar() { return _responseQueue.size() > 0; }
 239         MetarLoadResponse getMetar() { return _responseQueue.pop(); }
 240         virtual void run();
 241      private:
 242         void fetch( const MetarLoadRequest & );
 243         long _maxAge;
 244         long _minRequestInterval;
 245         SGBlockingQueue <MetarLoadRequest> _requestQueue;
 246         SGBlockingQueue <MetarLoadResponse> _responseQueue;
 247      };
 248
 249      MetarLoadThread * _metarLoadThread;
 250 #endif
 251 };
 252
 253 NoaaMetarRealWxController::NoaaMetarRealWxController( SGPropertyNode_ptr rootNode ) :
 254   BasicRealWxController(rootNode),
 255   _positionTimeToLive(0.0),
 256   _requestTimer(0.0)
 257 {
 258 #if defined(ENABLE_THREADS)
 259     _metarLoadThread = new MetarLoadThread(getMetarMaxAgeMin());
 260     _metarLoadThread->start();
 261 #endif
 262 }
 263
 264 NoaaMetarRealWxController::~NoaaMetarRealWxController()
 265 {
 266 #if defined(ENABLE_THREADS)
 267     if( _metarLoadThread ) {
 268         MetarLoadRequest request("");
 269         _metarLoadThread->requestMetar(request);
 270         _metarLoadThread->join();
 271         delete _metarLoadThread;
 272     }
 273 #endif // ENABLE_THREADS
 274 }
 275
 276 void NoaaMetarRealWxController::update( bool first, double dt )
 277 {
 278     _positionTimeToLive -= dt;
 279     _requestTimer -= dt;
 280
 281     if( _positionTimeToLive <= 0.0 ) {
 282         // check nearest airport
 283         SG_LOG(SG_ALL, SG_INFO, "NoaaMetarRealWxController::update(): (re) checking nearby airport with METAR" );
 284         _positionTimeToLive = 60.0;
 285
 286         SGGeod pos = SGGeod::fromDeg(_longitude_n->getDoubleValue(), _latitude_n->getDoubleValue());
 287
 288         FGAirport * nearestAirport = FGAirport::findClosest(pos, 10000.0, MetarAirportFilter::instance() );
 289         if( nearestAirport == NULL ) {
 290             SG_LOG(SG_ALL,SG_WARN,"RealWxController::update can't find airport with METAR within 10000NM"  );
 291             return;
 292         }
 293
 294         SG_LOG(SG_ALL, SG_INFO,
 295             "NoaaMetarRealWxController::update(): nearest airport with METAR is: " << nearestAirport->ident() );
 296
 297         // if it has changed, invalidate the associated METAR
 298         if( _metarProperties[0]->getStationId() != nearestAirport->ident() ) {
 299             SG_LOG(SG_ALL, SG_INFO,
 300                 "NoaaMetarRealWxController::update(): nearest airport with METAR has changed. Old: '" <<
 301                 _metarProperties[0]->getStationId() <<
 302                 "', new: '" << nearestAirport->ident() << "'" );
 303             _metarProperties[0]->setStationId( nearestAirport->ident() );
 304             _metarProperties[0]->setTimeToLive( 0.0 );
 305         }
 306     }
 307
 308     if( _requestTimer <= 0.0 ) {
 309         _requestTimer = 10.0;
 310
 311         for( MetarPropertiesList::iterator it = _metarProperties.begin();
 312             it != _metarProperties.end(); it++ ) {
 313
 314                 if( (*it)->getTimeToLive() > 0.0 ) continue;
 315                 const std::string & stationId = (*it)->getStationId();
 316                 if( stationId.empty() ) continue;
 317
 318                 SG_LOG(SG_ALL, SG_INFO,
 319                     "NoaaMetarRealWxController::update(): spawning load request for station-id '" << stationId << "'" );
 320
 321                 MetarLoadRequest request( stationId );
 322                 // load the metar for the neares airport in the foreground if the fdm is uninitialized
 323                 // to make sure a metar is received
 324                 // before the automatic runway selection code runs. All subsequent calls
 325                 // run in the background
 326                 bool background = fgGetBool("/sim/fdm-initialized", false ) || it != _metarProperties.begin();
 327                 _metarLoadThread->requestMetar( request, background );
 328         }
 329     }
 330
 331     // pick all the received responses from the result queue and update the associated
 332     // property tree
 333     while( _metarLoadThread->hasMetar() ) {
 334         MetarLoadResponse metar = _metarLoadThread->getMetar();
 335         SG_LOG( SG_ALL, SG_INFO, "NoaaMetarRwalWxController::update() received METAR for " << metar._stationId << ": " << metar._metar );
 336         for( MetarPropertiesList::iterator it = _metarProperties.begin();
 337             it != _metarProperties.end(); it++ ) {
 338                 if( (*it)->getStationId() != metar._stationId )
 339                     continue;
 340                 (*it)->setTimeToLive(900);
 341                 (*it)->setMetar( metar._metar );
 342         }
 343     }
 344 }
 345
 346 /* -------------------------------------------------------------------------------- */
 347
 348 #if defined(ENABLE_THREADS)
 349 NoaaMetarRealWxController::MetarLoadThread::MetarLoadThread( long maxAge ) :
 350   _maxAge(maxAge),
 351   _minRequestInterval(2000)
 352 {
 353 }
 354
 355 void NoaaMetarRealWxController::MetarLoadThread::requestMetar( const MetarLoadRequest & metarRequest, bool background )
 356 {
 357     if( background ) {
 358         if( _requestQueue.size() > 10 ) {
 359             SG_LOG(SG_ALL,SG_ALERT,
 360                 "NoaaMetarRealWxController::MetarLoadThread::requestMetar() more than 10 outstanding METAR requests, dropping "
 361                 << metarRequest._stationId );
 362             return;
 363         }
 364
 365         _requestQueue.push( metarRequest );
 366     } else {
 367         fetch( metarRequest );
 368     }
 369 }
 370
 371 void NoaaMetarRealWxController::MetarLoadThread::run()
 372 {
 373     SGTimeStamp lastRun = SGTimeStamp::fromSec(0);
 374     for( ;; ) {
 375         SGTimeStamp dt = SGTimeStamp::now() - lastRun;
 376
 377         if( dt.getSeconds() * 1000 < _minRequestInterval )
 378             microSleep( (_minRequestInterval - dt.getSeconds() * 1000 ) * 1000 );
 379
 380         lastRun = SGTimeStamp::now();
 381
 382         const MetarLoadRequest request = _requestQueue.pop();
 383
 384         if( request._stationId.size() == 0 )
 385             break;
 386
 387         fetch( request );
 388
 389     }
 390 }
 391
 392 void NoaaMetarRealWxController::MetarLoadThread::fetch( const MetarLoadRequest & request )
 393 {
 394    SGSharedPtr<FGMetar> result = NULL;
 395
 396     try {
 397         result = new FGMetar( request._stationId, request._proxyHost, request._proxyPort, request._proxyAuth );
 398         _minRequestInterval = 2000;
 399     } catch (const sg_io_exception& e) {
 400         SG_LOG( SG_GENERAL, SG_WARN, "NoaaMetarRealWxController::fetchMetar(): can't get METAR for "
 401                                     << request._stationId << ":" << e.getFormattedMessage().c_str() );
 402         _minRequestInterval += _minRequestInterval/2;
 403         if( _minRequestInterval > 30000 )
 404             _minRequestInterval = 30000;
 405         return;
 406     }
 407
 408     string reply = result->getData();
 409     std::replace(reply.begin(), reply.end(), '\n', ' ');
 410     string metar = simgear::strutils::strip( reply );
 411
 412     if( metar.empty() ) {
 413         SG_LOG( SG_GENERAL, SG_WARN, "NoaaMetarRealWxController::fetchMetar(): dropping empty METAR for "
 414                                     << request._stationId );
 415         return;
 416     }
 417
 418     if( _maxAge && result->getAge_min() > _maxAge ) {
 419         SG_LOG( SG_GENERAL, SG_ALERT, "NoaaMetarRealWxController::fetchMetar(): dropping outdated METAR "
 420                                      << metar );
 421         return;
 422     }
 423
 424     MetarLoadResponse response( request._stationId, metar );
 425     _responseQueue.push( response );
 426 }
 427 #endif
 428
 429 /* -------------------------------------------------------------------------------- */
 430
 431 RealWxController * RealWxController::createInstance( SGPropertyNode_ptr rootNode )
 432 {
 433 //    string dataSource = rootNode->getStringValue("data-source", "noaa" );
 434 //    if( dataSource == "nwx" ) {
 435 //      return new NwxMetarRealWxController( rootNode );
 436 //    } else {
 437       return new NoaaMetarRealWxController( rootNode );
 438 //    }
 439 }
 440
 441 /* -------------------------------------------------------------------------------- */
 442
 443 } // namespace Environment