src/ATC/ATCmgr.cxx

   1 // ATCmgr.cxx - Implementation of FGATCMgr - a global Flightgear ATC manager.
   2 //
   3 // Written by David Luff, started February 2002.
   4 //
   5 // Copyright (C) 2002  David C Luff - david.luff@nottingham.ac.uk
   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 //#include <Time/event.hxx>
  22
  23 #include "ATCmgr.hxx"
  24 #include "atislist.hxx"
  25 //#include "groundlist.hxx"
  26 #include "towerlist.hxx"
  27 #include "approachlist.hxx"
  28
  29 /*
  30 // periodic radio station search wrapper
  31 static void fgATCSearch( void ) {
  32     globals->get_ATC_mgr()->Search();
  33 }
  34 */ //This wouldn't compile - including Time/event.hxx breaks it :-(
  35
  36 FGATCMgr::FGATCMgr() {
  37     comm1_ident = "";
  38     comm1_atis_ident = "";
  39     comm1_tower_ident = "";
  40     comm1_approach_ident = "";
  41     last_comm1_ident = "";
  42     last_comm1_atis_ident = "";
  43     last_comm1_tower_ident = "";
  44     last_comm1_approach_ident = "";
  45     approach_ident = "";
  46     last_in_range = false;
  47     comm1_atis_valid = false;
  48     comm1_tower_valid = false;
  49     comm1_approach_valid = false;
  50 }
  51
  52 FGATCMgr::~FGATCMgr() {
  53 }
  54
  55 void FGATCMgr::bind() {
  56 }
  57
  58 void FGATCMgr::unbind() {
  59 }
  60
  61 void FGATCMgr::init() {
  62     comm1_node = fgGetNode("/radios/comm[0]/frequencies/selected-mhz", true);
  63     comm2_node = fgGetNode("/radios/comm[1]/frequencies/selected-mhz", true);
  64     lon_node = fgGetNode("/position/longitude-deg", true);
  65     lat_node = fgGetNode("/position/latitude-deg", true);
  66     elev_node = fgGetNode("/position/altitude-ft", true);
  67     atc_list_itr = atc_list.begin();
  68     // Search for connected ATC stations once per 0.8 seconds or so
  69     // global_events.Register( "fgATCSearch()", fgATCSearch,
  70     //              fgEVENT::FG_EVENT_READY, 800);
  71     // For some reason the above doesn't compile - including Time/event.hxx stops compilation.
  72
  73     // Initialise the airport_atc_map - we'll cheat for now and just hardcode KEMT and any others that may be needed for development
  74     AirportATC *a = new AirportATC;
  75     a->lon = -118.034719;
  76     a->lat = 34.086114;
  77     a->elev = 296.0;
  78     a->atis_freq = 118.75;
  79     a->atis_active = false;
  80     a->tower_freq = 121.2;
  81     a->tower_active = false;
  82     a->ground_freq = 125.9;
  83     a->ground_active = false;
  84
  85     //a->set_by_AI = true;
  86     //a->set_by_comm_search = false;
  87
  88     airport_atc_map[(string)"KEMT"] = a;
  89 }
  90
  91 void FGATCMgr::update(int dt) {
  92     //Traverse the list of active stations.
  93     //Only update one class per update step to avoid the whole ATC system having to calculate between frames.
  94     //Eventually we should only update every so many steps.
  95     //cout << "In FGATCMgr::update - atc_list.size = " << atc_list.size() << '\n';
  96     if(atc_list.size()) {
  97         if(atc_list_itr == atc_list.end()) {
  98             atc_list_itr = atc_list.begin();
  99         }
 100         (*atc_list_itr)->Update();
 101         ++atc_list_itr;
 102     }
 103
 104     // Search the tuned frequencies every now and then - this should be done with the event scheduler
 105     static int i = 0;
 106     if(i == 30) {
 107         Search();
 108         i = 0;
 109     }
 110     ++i;
 111 }
 112 /*
 113 // Remove from list only if not needed by the AI system
 114 void FGATCMgr::CommRemoveFromList(const char* id, atc_type tp) {
 115     AirportATC a;
 116     if(GetAirportATCDetails((string)id, &a)) {
 117         if(a.set_by_AI) {
 118             // Don't remove
 119             a.set_by_comm_search = false;
 120             airport_atc_map[(string)id] = a;
 121             return;
 122         } else {
 123             // remove
 124
 125 */
 126
 127 // Remove from list - should only be called from above or similar
 128 void FGATCMgr::RemoveFromList(const char* id, atc_type tp) {
 129     //cout << "Requested type = " << tp << '\n';
 130     //cout << "id = " << id << '\n';
 131     atc_list_itr = atc_list.begin();
 132     while(atc_list_itr != atc_list.end()) {
 133         //cout << "type = " << (*atc_list_itr)->GetType() << '\n';
 134         //cout << "Ident = " << (*atc_list_itr)->GetIdent() << '\n';
 135         if( (!strcmp((*atc_list_itr)->GetIdent(), id))
 136             && ((*atc_list_itr)->GetType() == tp) ) {
 137             //Before removing it stop it transmitting!!
 138             //cout << "OBLITERATING FROM LIST!!!\n";
 139             (*atc_list_itr)->SetNoDisplay();
 140             (*atc_list_itr)->Update();
 141             delete (*atc_list_itr);
 142             atc_list_itr = atc_list.erase(atc_list_itr);
 143             break;
 144         }  // Note that that can upset where we are in the list but that doesn't really matter
 145         ++atc_list_itr;
 146     }
 147 }
 148
 149 // Returns true if the airport is found in the map
 150 bool FGATCMgr::GetAirportATCDetails(string icao, AirportATC* a) {
 151     if(airport_atc_map.find(icao) != airport_atc_map.end()) {
 152         *a = *airport_atc_map[icao];
 153         return(true);
 154     } else {
 155         return(false);
 156     }
 157 }
 158
 159
 160 // Return a pointer to a given sort of ATC at a given airport and activate if necessary
 161 // ONLY CALL THIS FUNCTION AFTER FIRST CHECKING THE SERVICE EXISTS BY CALLING GetAirportATCDetails
 162 FGATC* FGATCMgr::GetATCPointer(string icao, atc_type type) {
 163     AirportATC *a = airport_atc_map[icao];
 164     //cout << "a->lon = " << a->lon << '\n';
 165     //cout << "a->elev = " << a->elev << '\n';
 166     //cout << "a->tower_freq = " << a->tower_freq << '\n';
 167     switch(type) {
 168     case TOWER:
 169         if(a->tower_active) {
 170             // Get the pointer from the list
 171         } else {
 172             FGTower* t = new FGTower;
 173             if(current_towerlist->query(a->lon, a->lat, a->elev, a->tower_freq, &tower)) {
 174                 *t = tower;
 175                 atc_list.push_back(t);
 176                 a->tower_active = true;
 177                 airport_atc_map[icao] = a;
 178                 return(t);
 179             } else {
 180                 cout << "ERROR - tower that should exist in FGATCMgr::GetATCPointer for airport " << icao << " not found\n";
 181             }
 182         }
 183         break;
 184     // Lets add the rest to get rid of the compiler warnings even though we don't need them yet.
 185     case APPROACH:
 186         break;
 187     case ATIS:
 188         cout << "ERROR - ATIS station should not be requested from FGATCMgr::GetATCPointer" << endl;
 189         break;
 190     case GROUND:
 191         break;
 192     case INVALID:
 193         break;
 194     case ENROUTE:
 195         break;
 196     case DEPARTURE:
 197         break;
 198     }
 199
 200     cout << "ERROR IN FGATCMgr - reached end of GetATCPointer\n";
 201 }
 202
 203
 204
 205 void FGATCMgr::Search() {
 206
 207     ////////////////////////////////////////////////////////////////////////
 208     // Comm1.
 209     ////////////////////////////////////////////////////////////////////////
 210     //cout << "In FGATCMgr::Search() - atc_list.size = " << atc_list.size() << '\n';
 211
 212     comm1_freq = comm1_node->getDoubleValue();
 213     //cout << "************* comm1_freq = " << comm1_freq << '\n';
 214     double lon = lon_node->getDoubleValue();
 215     double lat = lat_node->getDoubleValue();
 216     double elev = elev_node->getDoubleValue() * SG_FEET_TO_METER;
 217
 218     // Store the comm1_type
 219     //atc_type old_comm1_type = comm1_type;
 220
 221 // We must be able to generalise some of the repetetive searching below!
 222
 223     //Search for ATIS first
 224     if(current_atislist->query(lon, lat, elev, comm1_freq, &atis)) {
 225         //cout << "atis found in radiostack search !!!!" << endl;
 226         //cout << "last_comm1_atis_ident = " << last_comm1_atis_ident << '\n';
 227         //cout << "comm1_type " << comm1_type << '\n';
 228         comm1_atis_ident = atis.GetIdent();
 229         comm1_atis_valid = true;
 230         if(last_comm1_atis_ident != comm1_atis_ident) {
 231             if(last_comm1_atis_ident != "") {
 232                 RemoveFromList(last_comm1_atis_ident, ATIS);
 233             }
 234             last_comm1_atis_ident = comm1_atis_ident;
 235             //cout << "last_comm1_atis_ident = " << last_comm1_atis_ident << '\n';
 236             comm1_type = ATIS;
 237             comm1_elev = atis.get_elev();
 238             comm1_range = FG_ATIS_DEFAULT_RANGE;
 239             comm1_effective_range = comm1_range;
 240             comm1_x = atis.get_x();
 241             comm1_y = atis.get_y();
 242             comm1_z = atis.get_z();
 243             FGATIS* a = new FGATIS;
 244             *a = atis;
 245             a->SetDisplay();
 246             atc_list.push_back(a);
 247             //cout << "Found a new atis station in range" << endl;
 248             //cout << " id = " << atis.GetIdent() << endl;
 249             return;  //This rather assumes that we never have more than one type of station in range.
 250         }
 251     } else {
 252         if(comm1_atis_valid) {
 253             //cout << "Removing ATIS " << comm1_atis_ident << " from list\n";
 254             RemoveFromList(comm1_atis_ident, ATIS);
 255             comm1_atis_valid = false;
 256             if(comm1_type == ATIS) {
 257                 comm1_type = INVALID;
 258             }
 259             comm1_atis_ident = "";
 260             //comm1_trans_ident = "";
 261             last_comm1_atis_ident = "";
 262         }
 263         //cout << "not picking up atis" << endl;
 264     }
 265
 266     //Next search for tower
 267     //cout << "comm1_freq = " << comm1_freq << '\n';
 268     if(current_towerlist->query(lon, lat, elev, comm1_freq, &tower)) {
 269         //cout << "tower found in radiostack search !!!!" << endl;
 270         comm1_tower_ident = tower.GetIdent();
 271         //cout << "comm1_tower_ident = " << comm1_tower_ident << '\n';
 272         comm1_tower_valid = true;
 273         if(last_comm1_tower_ident != comm1_tower_ident) {
 274             if(last_comm1_tower_ident != "") {
 275                 RemoveFromList(last_comm1_tower_ident, TOWER);
 276             }
 277             last_comm1_tower_ident = comm1_tower_ident;
 278             comm1_type = TOWER;
 279             comm1_elev = tower.get_elev();
 280             comm1_range = FG_TOWER_DEFAULT_RANGE;
 281             comm1_effective_range = comm1_range;
 282             comm1_x = tower.get_x();
 283             comm1_y = tower.get_y();
 284             comm1_z = tower.get_z();
 285             FGTower* t = new FGTower;
 286             *t = tower;
 287             t->SetDisplay();
 288             atc_list.push_back(t);
 289             //cout << "Found a new tower station in range" << endl;
 290             //cout << " id = " << tower.GetIdent() << endl;
 291             return;  //This rather assumes that we never have more than one type of station in range.
 292         }
 293     } else {
 294         if(comm1_tower_valid) {
 295             //cout << "removing tower\n";
 296             RemoveFromList(comm1_tower_ident, TOWER);
 297             //comm1_valid = false;
 298             if(comm1_type == TOWER) {
 299                 comm1_type = INVALID;   // Only invalidate if we haven't switched it to something else
 300             }
 301             comm1_tower_valid = false;
 302             comm1_tower_ident = "";
 303             last_comm1_tower_ident = "";
 304             //comm1_ident = "";
 305             //comm1_trans_ident = "";
 306             //last_comm1_ident = "";
 307         }
 308         //cout << "not picking up tower" << endl;
 309     }
 310 /*
 311     //Next search for Ground control
 312     if(current_groundlist->query(lon, lat, elev, comm1_freq, &ground)) {
 313         //cout << "Ground Control found in radiostack search !!!!" << endl;
 314         comm1_ident = ground.GetIdent();
 315         comm1_valid = true;
 316         if((last_comm1_ident != comm1_ident) || (comm1_type != GROUND)) {
 317             if(last_comm1_ident != "") {
 318                 RemoveFromList(last_comm1_ident, GROUND);
 319             }
 320             last_comm1_ident = comm1_ident;
 321             comm1_type = GROUND;
 322             comm1_elev = ground.get_elev();
 323             comm1_range = FG_GROUND_DEFAULT_RANGE;
 324             comm1_effective_range = comm1_range;
 325             comm1_x = ground.get_x();
 326             comm1_y = ground.get_y();
 327             comm1_z = ground.get_z();
 328             FGGround* g = new FGGround;
 329             *g = ground;
 330             g->SetDisplay();
 331             atc_list.push_back(g);
 332             // For now we will automatically make contact with ground when the radio is tuned.
 333             // This rather assumes that the user tunes the radio at the appropriate place
 334             // (ie. having just turned off the runway) and only uses ground control on arrival
 335             // but its a start!
 336             g->NewArrival(current_plane);
 337             //cout << "Found a new ground station in range" << endl;
 338             //cout << " id = " << ground.GetIdent() << endl;
 339             return;  //This rather assumes that we never have more than one type of station in range.
 340         }
 341     } else {
 342         if((comm1_valid) && (comm1_type == GROUND)) {
 343             RemoveFromList(comm1_ident, GROUND);
 344             comm1_valid = false;
 345             comm1_type = INVALID;
 346             comm1_ident = "";
 347             //comm1_trans_ident = "";
 348             last_comm1_ident = "";
 349         }
 350         //cout << "not picking up ground control" << endl;
 351     }
 352 */
 353 // ================================================================================
 354 // Search for Approach stations
 355 // ================================================================================
 356     // init number of approach stations reachable by plane
 357     int  num_app = 0;
 358
 359     // search stations in range
 360     current_approachlist->query_bck(lon, lat, elev, approaches, max_app, num_app);
 361     if (num_app != 0) {
 362       //cout << num_app << " approaches found in radiostack search !!!!" << endl;
 363
 364       for ( int i=0; i<num_app; i++ ) {
 365         bool new_app = true;
 366         approach_ident = approaches[i].GetIdent();
 367
 368         // check if station already exists on ATC stack
 369         atc_list_itr = atc_list.begin();
 370         while(atc_list_itr != atc_list.end()) {
 371           //cout << "ATC list: " << (*atc_list_itr)->GetIdent() << endl;
 372           if((!strcmp((*atc_list_itr)->GetIdent(), approach_ident))
 373              && ((*atc_list_itr)->GetType() == APPROACH) ) {
 374             new_app = false;
 375             string pid = "Player";
 376             (*atc_list_itr)->AddPlane(pid);
 377             (*atc_list_itr)->Update();
 378             break;
 379           }
 380           ++atc_list_itr;
 381         }
 382         // generate new Approach on ATC stack
 383         if (new_app) {
 384           FGApproach* a = new FGApproach;
 385           *a = approaches[i];
 386           string pid = "Player";
 387           a->AddPlane(pid);
 388           a->Update();
 389           a->SetDisplay();
 390           atc_list.push_back(a);
 391           //cout << "Found a new approach station in range: Id = "
 392           //     << approaches[i].GetIdent() << endl;
 393         }
 394       }
 395     }
 396
 397     // remove planes which are out of range
 398     atc_list_itr = atc_list.begin();
 399     while(atc_list_itr != atc_list.end()) {
 400       if((*atc_list_itr)->GetType() == APPROACH ) {
 401         int np = (*atc_list_itr)->RemovePlane();
 402         // if approach has no planes left remove it from ATC list
 403         if ( np == 0) {
 404           (*atc_list_itr)->SetNoDisplay();
 405           (*atc_list_itr)->Update();
 406           delete (*atc_list_itr);
 407           atc_list_itr = atc_list.erase(atc_list_itr);
 408           break;     // the other stations will be checked next time
 409         }
 410       }
 411       ++atc_list_itr;
 412     }
 413 }