1 // environment_ctrl.cxx -- manager for natural environment information.
3 // Written by David Megginson, started February 2002.
5 // Copyright (C) 2002 David Megginson - david@megginson.com
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.
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.
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.
27 #include <simgear/debug/logstream.hxx>
32 #include <simgear/structure/commands.hxx>
33 #include <simgear/structure/exception.hxx>
35 #include <Airports/simple.hxx>
36 #include <Main/fg_props.hxx>
37 #include <Main/util.hxx>
39 #include "environment_mgr.hxx"
40 #include "environment_ctrl.hxx"
46 ////////////////////////////////////////////////////////////////////////
47 // Implementation of FGEnvironmentCtrl abstract base class.
48 ////////////////////////////////////////////////////////////////////////
50 FGEnvironmentCtrl::FGEnvironmentCtrl ()
58 FGEnvironmentCtrl::~FGEnvironmentCtrl ()
63 FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
65 _environment = environment;
69 FGEnvironmentCtrl::setLongitudeDeg (double lon_deg)
75 FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
81 FGEnvironmentCtrl::setElevationFt (double elev_ft)
87 FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
96 ////////////////////////////////////////////////////////////////////////
97 // Implementation of FGUserDefEnvironmentCtrl.
98 ////////////////////////////////////////////////////////////////////////
100 FGUserDefEnvironmentCtrl::FGUserDefEnvironmentCtrl ()
101 : _base_wind_speed_node(0),
102 _gust_wind_speed_node(0),
103 _current_wind_speed_kt(0),
104 _delta_wind_speed_kt(0)
108 FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
113 FGUserDefEnvironmentCtrl::init ()
115 // Fill in some defaults.
116 if (!fgHasNode("/environment/params/base-wind-speed-kt"))
117 fgSetDouble("/environment/params/base-wind-speed-kt",
118 fgGetDouble("/environment/wind-speed-kt"));
119 if (!fgHasNode("/environment/params/gust-wind-speed-kt"))
120 fgSetDouble("/environment/params/gust-wind-speed-kt",
121 fgGetDouble("/environment/params/base-wind-speed-kt"));
123 _base_wind_speed_node =
124 fgGetNode("/environment/params/base-wind-speed-kt", true);
125 _gust_wind_speed_node =
126 fgGetNode("/environment/params/gust-wind-speed-kt", true);
128 _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
129 _delta_wind_speed_kt = 0.1;
133 FGUserDefEnvironmentCtrl::update (double dt)
135 double base_wind_speed = _base_wind_speed_node->getDoubleValue();
136 double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
138 if (gust_wind_speed < base_wind_speed) {
139 gust_wind_speed = base_wind_speed;
140 _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
143 if (base_wind_speed == gust_wind_speed) {
144 _current_wind_speed_kt = base_wind_speed;
146 int rn = rand() % 128;
147 int sign = (_delta_wind_speed_kt < 0 ? -1 : 1);
148 double gust = _current_wind_speed_kt - base_wind_speed;
149 double incr = gust / 50;
152 _delta_wind_speed_kt = - _delta_wind_speed_kt;
154 _delta_wind_speed_kt -= incr * sign;
156 _delta_wind_speed_kt += incr * sign;
158 _current_wind_speed_kt += _delta_wind_speed_kt;
160 if (_current_wind_speed_kt < base_wind_speed) {
161 _current_wind_speed_kt = base_wind_speed;
162 _delta_wind_speed_kt = 0.01;
163 } else if (_current_wind_speed_kt > gust_wind_speed) {
164 _current_wind_speed_kt = gust_wind_speed;
165 _delta_wind_speed_kt = -0.01;
169 if (_environment != 0)
170 _environment->set_wind_speed_kt(_current_wind_speed_kt);
175 ////////////////////////////////////////////////////////////////////////
176 // Implementation of FGInterpolateEnvironmentCtrl.
177 ////////////////////////////////////////////////////////////////////////
179 FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl ()
183 FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl ()
186 for (i = 0; i < _boundary_table.size(); i++)
187 delete _boundary_table[i];
188 for (i = 0; i < _aloft_table.size(); i++)
189 delete _aloft_table[i];
195 FGInterpolateEnvironmentCtrl::init ()
197 read_table(fgGetNode("/environment/config/boundary", true),
199 read_table(fgGetNode("/environment/config/aloft", true),
204 FGInterpolateEnvironmentCtrl::reinit ()
207 for (i = 0; i < _boundary_table.size(); i++)
208 delete _boundary_table[i];
209 for (i = 0; i < _aloft_table.size(); i++)
210 delete _aloft_table[i];
211 _boundary_table.clear();
212 _aloft_table.clear();
217 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node,
218 vector<bucket *> &table)
220 for (int i = 0; i < node->nChildren(); i++) {
221 const SGPropertyNode * child = node->getChild(i);
222 if ( strcmp(child->getName(), "entry") == 0
223 && child->getStringValue("elevation-ft", "")[0] != '\0'
224 && ( child->getDoubleValue("elevation-ft") > 0.1 || i == 0 ) )
226 bucket * b = new bucket;
228 b->environment.copy(table[i-1]->environment);
229 b->environment.read(child);
230 b->altitude_ft = b->environment.get_elevation_ft();
234 sort(table.begin(), table.end());
238 FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
241 double altitude_ft = fgGetDouble("/position/altitude-ft");
242 double altitude_agl_ft = fgGetDouble("/position/altitude-agl-ft");
243 double boundary_transition =
244 fgGetDouble("/environment/config/boundary-transition-ft", 500);
246 // double ground_elevation_ft = altitude_ft - altitude_agl_ft;
248 int length = _boundary_table.size();
252 double boundary_limit = _boundary_table[length-1]->altitude_ft;
253 if (boundary_limit >= altitude_agl_ft) {
254 do_interpolate(_boundary_table, altitude_agl_ft,
257 } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
259 do_interpolate(_boundary_table, altitude_agl_ft, &env1);
260 do_interpolate(_aloft_table, altitude_ft, &env2);
262 (altitude_agl_ft - boundary_limit) / boundary_transition;
263 interpolate(&env1, &env2, fraction, _environment);
269 do_interpolate(_aloft_table, altitude_ft, _environment);
273 FGInterpolateEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
275 FGEnvironment * environment)
277 int length = table.size();
281 // Boundary conditions
282 if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) {
283 environment->copy(table[0]->environment);
285 } else if (table[length-1]->altitude_ft <= altitude_ft) {
286 environment->copy(table[length-1]->environment);
290 // Search the interpolation table
291 for (int i = 0; i < length - 1; i++) {
292 if ((i == length - 1) || (table[i]->altitude_ft <= altitude_ft)) {
293 FGEnvironment * env1 = &(table[i]->environment);
294 FGEnvironment * env2 = &(table[i+1]->environment);
296 if (table[i]->altitude_ft == table[i+1]->altitude_ft)
300 ((altitude_ft - table[i]->altitude_ft) /
301 (table[i+1]->altitude_ft - table[i]->altitude_ft));
302 interpolate(env1, env2, fraction, environment);
310 FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const
312 return (altitude_ft < b.altitude_ft);
317 ////////////////////////////////////////////////////////////////////////
318 // Implementation of FGMetarEnvironmentCtrl.
319 ////////////////////////////////////////////////////////////////////////
321 FGMetarEnvironmentCtrl::FGMetarEnvironmentCtrl ()
322 : env( new FGInterpolateEnvironmentCtrl ),
324 search_interval_sec( 60.0 ), // 1 minute
325 same_station_interval_sec( 900.0 ), // 15 minutes
326 search_elapsed( 9999.0 ),
327 fetch_elapsed( 9999.0 ),
328 proxy_host( fgGetNode("/sim/presets/proxy/host", true) ),
329 proxy_port( fgGetNode("/sim/presets/proxy/port", true) ),
330 proxy_auth( fgGetNode("/sim/presets/proxy/authentication", true) ),
331 metar_max_age( fgGetNode("/environment/params/metar-max-age-min", true) ),
338 #if defined(ENABLE_THREADS)
339 thread = new MetarThread(this);
341 #endif // ENABLE_THREADS
344 FGMetarEnvironmentCtrl::~FGMetarEnvironmentCtrl ()
346 #if defined(ENABLE_THREADS)
348 #endif // ENABLE_THREADS
355 // use a "command" to set station temp at station elevation
356 static void set_temp_at_altitude( float temp_degc, float altitude_ft ) {
358 SGPropertyNode *node = args.getNode("temp-degc", 0, true);
359 node->setFloatValue( temp_degc );
360 node = args.getNode("altitude-ft", 0, true);
361 node->setFloatValue( altitude_ft );
362 globals->get_commands()->execute("set-outside-air-temp-degc", &args);
366 static void set_dewpoint_at_altitude( float dewpoint_degc, float altitude_ft ) {
368 SGPropertyNode *node = args.getNode("dewpoint-degc", 0, true);
369 node->setFloatValue( dewpoint_degc );
370 node = args.getNode("altitude-ft", 0, true);
371 node->setFloatValue( altitude_ft );
372 globals->get_commands()->execute("set-dewpoint-temp-degc", &args);
377 FGMetarEnvironmentCtrl::update_env_config ()
379 fgSetupWind( fgGetDouble("/environment/metar/base-wind-range-from"),
380 fgGetDouble("/environment/metar/base-wind-range-to"),
381 fgGetDouble("/environment/metar/base-wind-speed-kt"),
382 fgGetDouble("/environment/metar/gust-wind-speed-kt") );
384 fgDefaultWeatherValue( "visibility-m",
385 fgGetDouble("/environment/metar/min-visibility-m") );
386 set_temp_at_altitude( fgGetDouble("/environment/metar/temperature-degc"),
387 station_elevation_ft );
388 set_dewpoint_at_altitude( fgGetDouble("/environment/metar/dewpoint-degc"),
389 station_elevation_ft );
390 fgDefaultWeatherValue( "pressure-sea-level-inhg",
391 fgGetDouble("/environment/metar/pressure-inhg") );
395 FGMetarEnvironmentCtrl::init ()
397 const SGPropertyNode *longitude
398 = fgGetNode( "/position/longitude-deg", true );
399 const SGPropertyNode *latitude
400 = fgGetNode( "/position/latitude-deg", true );
402 bool found_metar = false;
403 long max_age = metar_max_age->getLongValue();
404 // Don't check max age during init so that we don't loop over a lot
405 // of airports metar if there is a problem.
406 // The update() calls will find a correct metar if things went wrong here
407 metar_max_age->setLongValue(0);
409 while ( !found_metar && (_error_count < 3) ) {
410 const FGAirport* a = globals->get_airports()
411 ->search( longitude->getDoubleValue(),
412 latitude->getDoubleValue(),
415 FGMetarResult result = fetch_data( a->getId() );
416 if ( result.m != NULL ) {
417 SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = "
421 search_elapsed = 0.0;
423 update_metar_properties( result.m );
428 // mark as no metar so it doesn't show up in subsequent
430 SG_LOG( SG_GENERAL, SG_INFO, "no metar at metar = "
432 globals->get_airports()->no_metar( a->getId() );
436 metar_max_age->setLongValue(max_age);
440 FGMetarEnvironmentCtrl::reinit ()
453 FGMetarEnvironmentCtrl::update(double delta_time_sec)
456 _dt += delta_time_sec;
457 if (_error_count >= 3)
460 FGMetarResult result;
462 static const SGPropertyNode *longitude
463 = fgGetNode( "/position/longitude-deg", true );
464 static const SGPropertyNode *latitude
465 = fgGetNode( "/position/latitude-deg", true );
466 search_elapsed += delta_time_sec;
467 fetch_elapsed += delta_time_sec;
469 // if time for a new search request, push it onto the request
471 if ( search_elapsed > search_interval_sec ) {
472 const FGAirport* a = globals->get_airports()
473 ->search( longitude->getDoubleValue(),
474 latitude->getDoubleValue(),
477 if ( !last_apt || last_apt->getId() != a->getId()
478 || fetch_elapsed > same_station_interval_sec )
480 SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = "
482 request_queue.push( a->getId() );
485 search_elapsed = 0.0;
488 search_elapsed = 0.0;
489 SG_LOG( SG_GENERAL, SG_INFO, "same station, waiting = "
490 << same_station_interval_sec - fetch_elapsed );
493 SG_LOG( SG_GENERAL, SG_WARN,
494 "Unable to find any airports with metar" );
498 #if !defined(ENABLE_THREADS)
499 // No loader thread running so manually fetch the data
501 while ( !request_queue.empty() ) {
502 id = request_queue.front();
507 SG_LOG( SG_GENERAL, SG_INFO, "inline fetching = " << id );
508 result = fetch_data( id );
509 result_queue.push( result );
511 #endif // ENABLE_THREADS
513 // process any results from the loader.
514 while ( !result_queue.empty() ) {
515 result = result_queue.front();
517 if ( result.m != NULL ) {
518 update_metar_properties( result.m );
523 // mark as no metar so it doesn't show up in subsequent
524 // searches, and signal an immediate re-search.
525 SG_LOG( SG_GENERAL, SG_WARN,
526 "no metar at station = " << result.icao );
527 globals->get_airports()->no_metar( result.icao );
528 search_elapsed = 9999.0;
532 env->update(delta_time_sec);
537 FGMetarEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
539 env->setEnvironment(environment);
543 FGMetarEnvironmentCtrl::fetch_data( const string &icao )
545 FGMetarResult result;
548 // if the last error was more than three seconds ago,
549 // then pretent nothing happened.
558 // fetch station elevation if exists
559 const FGAirport* a = globals->get_airports()->search( icao );
561 station_elevation_ft = a->getElevation();
564 // fetch current metar data
566 string host = proxy_host->getStringValue();
567 string auth = proxy_auth->getStringValue();
568 string port = proxy_port->getStringValue();
569 result.m = new FGMetar( icao, host, port, auth);
571 long max_age = metar_max_age->getLongValue();
572 long age = result.m->getAge_min();
573 if (max_age && age > max_age) {
574 SG_LOG( SG_GENERAL, SG_WARN, "METAR data too old (" << age << " min).");
578 if (++_stale_count > 10) {
580 throw sg_io_exception("More than 10 stale METAR messages in a row."
581 " Check your system time!");
586 } catch (const sg_io_exception& e) {
587 SG_LOG( SG_GENERAL, SG_WARN, "Error fetching live weather data: "
588 << e.getFormattedMessage().c_str() );
589 #if defined(ENABLE_THREADS)
590 if (_error_count++ >= 3) {
591 SG_LOG( SG_GENERAL, SG_WARN, "Stop fetching data permanently.");
606 FGMetarEnvironmentCtrl::update_metar_properties( const FGMetar *m )
612 fgSetString("/environment/metar/real-metar", m->getData());
613 // don't update with real weather when we use a custom weather scenario
614 const char *current_scenario = fgGetString("/environment/weather-scenario", "METAR");
615 if( strcmp(current_scenario, "METAR") && strcmp(current_scenario, "none"))
617 fgSetString("/environment/metar/last-metar", m->getData());
618 fgSetString("/environment/metar/station-id", m->getId());
619 fgSetDouble("/environment/metar/min-visibility-m",
620 m->getMinVisibility().getVisibility_m() );
621 fgSetDouble("/environment/metar/max-visibility-m",
622 m->getMaxVisibility().getVisibility_m() );
624 const SGMetarVisibility *dirvis = m->getDirVisibility();
625 for (i = 0; i < 8; i++, dirvis++) {
626 const char *min = "/environment/metar/visibility[%d]/min-m";
627 const char *max = "/environment/metar/visibility[%d]/max-m";
629 d = dirvis->getVisibility_m();
631 snprintf(s, 128, min, i);
633 snprintf(s, 128, max, i);
637 fgSetInt("/environment/metar/base-wind-range-from",
638 m->getWindRangeFrom() );
639 fgSetInt("/environment/metar/base-wind-range-to",
640 m->getWindRangeTo() );
641 fgSetDouble("/environment/metar/base-wind-speed-kt",
642 m->getWindSpeed_kt() );
643 fgSetDouble("/environment/metar/gust-wind-speed-kt",
644 m->getGustSpeed_kt() );
645 fgSetDouble("/environment/metar/temperature-degc",
646 m->getTemperature_C() );
647 fgSetDouble("/environment/metar/dewpoint-degc",
648 m->getDewpoint_C() );
649 fgSetDouble("/environment/metar/rel-humidity-norm",
650 m->getRelHumidity() );
651 fgSetDouble("/environment/metar/pressure-inhg",
652 m->getPressure_inHg() );
654 vector<SGMetarCloud> cv = m->getClouds();
655 vector<SGMetarCloud>::const_iterator cloud;
657 const char *cl = "/environment/clouds/layer[%i]";
658 for (i = 0, cloud = cv.begin(); cloud != cv.end(); cloud++, i++) {
659 const char *coverage_string[5] =
660 { "clear", "few", "scattered", "broken", "overcast" };
661 const double thickness[5] = { 0, 65, 600,750, 1000};
664 snprintf(s, 128, cl, i);
665 strncat(s, "/coverage", 128);
666 q = cloud->getCoverage();
667 fgSetString(s, coverage_string[q] );
669 snprintf(s, 128, cl, i);
670 strncat(s, "/elevation-ft", 128);
671 fgSetDouble(s, cloud->getAltitude_ft() + station_elevation_ft);
673 snprintf(s, 128, cl, i);
674 strncat(s, "/thickness-ft", 128);
675 fgSetDouble(s, thickness[q]);
677 snprintf(s, 128, cl, i);
678 strncat(s, "/span-m", 128);
679 fgSetDouble(s, 40000.0);
682 for (; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
683 snprintf(s, 128, cl, i);
684 strncat(s, "/coverage", 128);
685 fgSetString(s, "clear");
687 snprintf(s, 128, cl, i);
688 strncat(s, "/elevation-ft", 128);
689 fgSetDouble(s, -9999);
691 snprintf(s, 128, cl, i);
692 strncat(s, "/thickness-ft", 128);
695 snprintf(s, 128, cl, i);
696 strncat(s, "/span-m", 128);
697 fgSetDouble(s, 40000.0);
700 fgSetDouble("/environment/metar/rain-norm", m->getRain());
701 fgSetDouble("/environment/metar/hail-norm", m->getHail());
702 fgSetDouble("/environment/metar/snow-norm", m->getSnow());
703 fgSetBool("/environment/metar/snow-cover", m->getSnowCover());
707 #if defined(ENABLE_THREADS)
709 FGMetarEnvironmentCtrl::thread_stop()
711 request_queue.push( string() ); // ask thread to terminate
716 FGMetarEnvironmentCtrl::MetarThread::run()
720 string icao = fetcher->request_queue.pop();
723 SG_LOG( SG_GENERAL, SG_INFO, "Thread: fetch metar data = " << icao );
724 FGMetarResult result = fetcher->fetch_data( icao );
725 fetcher->result_queue.push( result );
728 #endif // ENABLE_THREADS
731 // end of environment_ctrl.cxx