1 // FGGround - a class to provide ground control at larger airports.
3 // Written by David Luff, started March 2002.
5 // Copyright (C) 2002 David C. Luff - david.luff@nottingham.ac.uk
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., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <simgear/misc/sg_path.hxx>
22 #include <simgear/math/sg_random.h>
23 #include <simgear/debug/logstream.hxx>
24 #include <simgear/misc/sgstream.hxx>
25 #include <simgear/constants.h>
26 #include <Main/globals.hxx>
33 SG_USING_STD(ifstream);
35 FGGround::FGGround() {
37 networkLoadOK = false;
40 FGGround::~FGGround() {
43 void FGGround::ParseRwyExits(node* np, char* es) {
47 const char delimiters[] = "-";
48 token = strtok(estr, delimiters);
49 while(token != NULL) {
51 //cout << "token = " << token << endl;
52 //cout << "rwy number = " << i << endl;
53 //runways[(atoi(token))].exits.push_back(np);
54 runways[i].exits.push_back(np);
55 //cout << "token = " << token << '\n';
56 token = strtok(NULL, delimiters);
61 // Load the ground logical network of the current instances airport
62 // Return true if successfull.
63 // TODO - currently the file is assumed to reside in the base/ATC directory.
64 // This might change to something more thought out in the future.
65 bool FGGround::LoadNetwork() {
71 SGPath path = globals->get_fg_root();
72 //string taxiPath = "ATC/" + ident + ".taxi";
73 string taxiPath = "ATC/KEMT.taxi"; // FIXME - HARDWIRED FOR TESTING
74 path.append(taxiPath);
76 SG_LOG(SG_GENERAL, SG_INFO, "Trying to read taxiway data for " << ident << "...");
77 //cout << "Trying to read taxiway data for " << ident << "..." << endl;
78 fin.open(path.c_str(), ios::in);
80 SG_LOG(SG_GENERAL, SG_ALERT, "Unable to open taxiway data input file " << path.c_str());
81 //cout << "Unable to open taxiway data input file " << path.c_str() << endl;
89 // Node, arc, or [End]?
90 //cout << "Read in ground network element type = " << buf << endl;
91 if(!strcmp(buf, "[End]")) { // TODO - maybe make this more robust to spelling errors by just looking for '['
92 cout << "Done reading " << path.c_str() << endl;
94 } else if(!strcmp(buf, "N")) {
97 np->struct_type = NODE;
99 np->nodeID = atoi(buf);
101 np->pos.setlon(atof(buf));
103 np->pos.setlat(atof(buf));
105 np->pos.setelev(atof(buf));
106 fin >> buf; // node type
107 if(!strcmp(buf, "J")) {
109 } else if(!strcmp(buf, "T")) {
110 np->type = TJUNCTION;
111 } else if(!strcmp(buf, "H")) {
114 cout << "**** ERROR ***** Unknown node type in taxi network...\n";
118 fin >> buf; // rwy exit information - gets parsed later - FRAGILE - will break if buf is reused.
122 fin.unsetf(ios::skipws);
125 if((ch == '"') || (ch == 0x0A)) {
127 } // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
129 fin.setf(ios::skipws);
130 network.push_back(np);
131 // FIXME - fragile - replies on buf not getting modified from exits read to here
132 // see if we also need to push it onto the runway exit list
133 cout << "strlen(buf) = " << strlen(buf) << endl;
134 if(strlen(buf) > 2) {
135 cout << "Calling ParseRwyExits for " << buf << endl;
136 ParseRwyExits(np, buf);
138 } else if(!strcmp(buf, "A")) {
140 ap->struct_type = ARC;
146 if(!strcmp(buf, "R")) {
148 } else if(!strcmp(buf, "T")) {
151 cout << "**** ERROR ***** Unknown arc type in taxi network...\n";
157 if(!strcmp(buf, "Y")) {
159 } else if(!strcmp(buf, "N")) {
160 ap->directed = false;
162 cout << "**** ERROR ***** Unknown arc directed value in taxi network - should be Y/N !!!\n";
169 fin.unsetf(ios::skipws);
172 if((ch == '"') || (ch == 0x0A)) {
174 } // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
176 fin.setf(ios::skipws);
177 network[ap->n1]->arcs.push_back(ap);
178 network[ap->n2]->arcs.push_back(ap);
179 } else if(!strcmp(buf, "G")) {
181 gp->struct_type = NODE;
184 gp->nodeID = atoi(buf);
186 gp->pos.setlon(atof(buf));
188 gp->pos.setlat(atof(buf));
190 gp->pos.setelev(atof(buf));
191 fin >> buf; // gate type - ignore this for now
192 fin >> buf; // gate heading
193 gp->heading = atoi(buf);
197 fin.unsetf(ios::skipws);
200 if((ch == '"') || (ch == 0x0A)) {
202 } // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
204 fin.setf(ios::skipws);
205 network.push_back(gp);
207 // Something has gone seriously pear-shaped
208 cout << "********* ERROR - unknown ground network element type... aborting read of " << path.c_str() << '\n';
217 void FGGround::Init() {
220 // For now we'll hardwire the threshold end
221 Point3D P010(-118.037483, 34.081358, 296 * SG_FEET_TO_METER);
223 ortho.Init(P010, hdg);
225 networkLoadOK = LoadNetwork();
228 void FGGround::Update() {
229 // Each time step, what do we need to do?
230 // We need to go through the list of outstanding requests and acknowedgements
231 // and process at least one of them.
232 // We need to go through the list of planes under our control and check if
233 // any need to be addressed.
234 // We need to check for planes not under our control coming within our
235 // control area and address if necessary.
237 // Lets take the example of a plane which has just contacted ground
238 // following landing - presumably requesting where to go?
239 // First we need to establish the position of the plane within the logical network.
240 // Next we need to decide where its going.
243 // FIXME - at the moment this assumes there is at least one gate and crashes if none
244 // FIXME - In fact, at the moment this routine doesn't work at all and hence is munged to always return Gate 1 !!!!
245 int FGGround::GetRandomGateID() {
246 //cout << "GetRandomGateID called" << endl;
249 gate_vec_type gateVec;
250 //gate_vec_iterator gateVecItr;
255 gatesItr = gates.begin();
256 while(gatesItr != gates.end()) {
257 if(gatesItr->second.used == false) {
258 gateVec.push_back(gatesItr->second);
264 // Randomly select one from the list
265 thenum = (int)(sg_random() * gateVec.size());
266 ID = gateVec[thenum].id;
267 //cout << "Returning gate ID " << ID << " from GetRandomGateID" << endl;
271 // Return a pointer to a gate node based on the gate ID
272 Gate* FGGround::GetGateNode(int gateID) {
273 //TODO - ought to add some sanity checking here - ie does a gate of this ID exist?!
274 return(&(gates[gateID]));
277 // Get a path from a point on a runway to a gate
279 // Get a path from a node to another node
280 // Eventually we will need complex algorithms for this taking other traffic,
281 // shortest path and suitable paths into accout. For now we're going to hardwire for KEMT!!!!
282 ground_network_path_type FGGround::GetPath(node* A, node* B) {
283 ground_network_path_type path;
284 //arc_array_iterator arcItr;
287 // VERY HARDWIRED - this hardwires a path from the far end of R01 to Gate 1.
288 // In fact in real life the area between R01/19 and Taxiway Alpha at KEMT is tarmaced and planes
289 // are supposed to exit the rwy asap.
290 // OK - for now very hardwire this for testing
291 path.push_back(network[1]);
292 path.push_back(network[1]->arcs[1]); // ONLY BECAUSE WE KNOW THIS IS THE ONE !!!!!
293 path.push_back(network[3]);
294 path.push_back(network[3]->arcs[1]);
295 path.push_back(network[5]);
296 path.push_back(network[5]->arcs[0]);
297 path.push_back(network[4]);
298 path.push_back(network[4]->arcs[2]);
299 path.push_back(network[6]);
300 path.push_back(network[6]->arcs[2]);
301 path.push_back(network[7]); // THE GATE!! Note that for now we're not even looking at the requested exit and gate passed in !!!!!
304 // In this hardwired scheme there are two possibilities - taxiing from rwy to gate or gate to rwy.
305 if(B->type == GATE) {
306 //return an inward path
308 // In this hardwired scheme we know A is a rwy exit and should have one taxiway arc only
309 // THIS WILL NOT HOLD TRUE IN THE GENERAL CASE
310 arcItr = A->arcs.begin();
312 while(arcItr != A->arcs.end()) {
313 if(arcItr->type == TAXIWAY) {
314 path.push_back(&(*arcItr));
320 //cout << "AI/ATC SUBSYSTEM ERROR - no taxiway from runway exit in airport.cxx" << endl;
322 // Then push back the start of taxiway node
323 // Then push back the taxiway arc
324 arcItr = A->arcs.begin();
326 while(arcItr != A->arcs.end()) {
327 if(arcItr->type == TAXIWAY) { // FIXME - OOPS - two taxiways go off this node
328 // How are we going to differentiate, apart from one called Alpha.
329 // I suppose eventually the traversal algorithms will select.
330 path.push_back(&(*arcItr));
336 //cout << "AI/ATC SUBSYSTEM ERROR - no taxiway from runway exit in airport.cxx" << endl;
338 // Then push back the junction node
339 // Planes always face one way in the parking, so depending on which parking exit we have either take it or push back another taxiway node
340 // Repeat if necessary
341 // Then push back the gate B
344 //return an outward path
347 // WARNING TODO FIXME - this is VERY FRAGILE - eg taxi to apron!!! but should be enough to
348 // see an AI plane physically taxi.
355 // Randomly or otherwise populate some of the gates with parked planes
356 // (might eventually be done by the AIMgr if and when lots of AI traffic is generated)
358 // Return a list of exits from a given runway
359 // It is up to the calling function to check for non-zero size of returned array before use
360 node_array_type FGGround::GetExits(int rwyID) {
361 return(runways[rwyID].exits);
365 void FGGround::NewArrival(plane_rec plane) {
366 // What are we going to do here?
367 // We need to start a new ground_rec and add the plane_rec to it
368 // We need to decide what gate we are going to clear it to.
369 // Then we need to add clearing it to that gate to the pending transmissions queue? - or simply transmit?
370 // Probably simply transmit for now and think about a transmission queue later if we need one.
371 // We might need one though in order to add a little delay for response time.
372 ground_rec* g = new ground_rec;
373 g->plane_rec = plane;
374 g->current_pos = ConvertWGS84ToXY(plane.pos);
375 g->node = GetNode(g->current_pos); // TODO - might need to sort out node/arc here
378 ground_traffic.push_back(g);
382 void FGGround::NewContact(plane_rec plane) {
383 // This is a bit of a convienience function at the moment and is likely to change.
384 if(at a gate or apron)
390 void FGGround::NextClearance(ground_rec &g) {
391 // Need to work out where we can clear g to.
392 // Assume the pilot doesn't need progressive instructions
393 // We *should* already have a gate or holding point assigned by the time we get here
394 // but it wouldn't do any harm to check.
396 // For now though we will hardwire it to clear to the final destination.
399 void FGGround::AssignGate(ground_rec &g) {
400 // We'll cheat for now - since we only have the user's aircraft and a couple of airports implemented
401 // we'll hardwire the gate!
402 // In the long run the logic of which gate or area to send the plane to could be somewhat non-trivial.