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);
36 FGGround::FGGround() {
38 networkLoadOK = false;
41 FGGround::~FGGround() {
44 void FGGround::ParseRwyExits(node* np, char* es) {
48 const char delimiters[] = "-";
49 token = strtok(estr, delimiters);
50 while(token != NULL) {
52 //cout << "token = " << token << endl;
53 //cout << "rwy number = " << i << endl;
54 //runways[(atoi(token))].exits.push_back(np);
55 runways[i].exits.push_back(np);
56 //cout << "token = " << token << '\n';
57 token = strtok(NULL, delimiters);
62 // Load the ground logical network of the current instances airport
63 // Return true if successfull.
64 // TODO - currently the file is assumed to reside in the base/ATC directory.
65 // This might change to something more thought out in the future.
66 bool FGGround::LoadNetwork() {
72 SGPath path = globals->get_fg_root();
73 //string taxiPath = "ATC/" + ident + ".taxi";
74 string taxiPath = "ATC/KEMT.taxi"; // FIXME - HARDWIRED FOR TESTING
75 path.append(taxiPath);
77 SG_LOG(SG_GENERAL, SG_INFO, "Trying to read taxiway data for " << ident << "...");
78 //cout << "Trying to read taxiway data for " << ident << "..." << endl;
79 fin.open(path.c_str(), ios::in);
81 SG_LOG(SG_GENERAL, SG_ALERT, "Unable to open taxiway data input file " << path.c_str());
82 //cout << "Unable to open taxiway data input file " << path.c_str() << endl;
90 // Node, arc, or [End]?
91 //cout << "Read in ground network element type = " << buf << endl;
92 if(!strcmp(buf, "[End]")) { // TODO - maybe make this more robust to spelling errors by just looking for '['
93 SG_LOG(SG_GENERAL, SG_INFO, "Done reading " << path.c_str() << endl);
95 } else if(!strcmp(buf, "N")) {
98 np->struct_type = NODE;
100 np->nodeID = atoi(buf);
102 np->pos.setlon(atof(buf));
104 np->pos.setlat(atof(buf));
106 np->pos.setelev(atof(buf));
107 fin >> buf; // node type
108 if(!strcmp(buf, "J")) {
110 } else if(!strcmp(buf, "T")) {
111 np->type = TJUNCTION;
112 } else if(!strcmp(buf, "H")) {
115 cout << "**** ERROR ***** Unknown node type in taxi network...\n";
119 fin >> buf; // rwy exit information - gets parsed later - FRAGILE - will break if buf is reused.
123 fin.unsetf(ios::skipws);
126 if((ch == '"') || (ch == 0x0A)) {
128 } // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
130 fin.setf(ios::skipws);
131 network.push_back(np);
132 // FIXME - fragile - replies on buf not getting modified from exits read to here
133 // see if we also need to push it onto the runway exit list
134 cout << "strlen(buf) = " << strlen(buf) << endl;
135 if(strlen(buf) > 2) {
136 cout << "Calling ParseRwyExits for " << buf << endl;
137 ParseRwyExits(np, buf);
139 } else if(!strcmp(buf, "A")) {
141 ap->struct_type = ARC;
147 if(!strcmp(buf, "R")) {
149 } else if(!strcmp(buf, "T")) {
152 cout << "**** ERROR ***** Unknown arc type in taxi network...\n";
158 if(!strcmp(buf, "Y")) {
160 } else if(!strcmp(buf, "N")) {
161 ap->directed = false;
163 cout << "**** ERROR ***** Unknown arc directed value in taxi network - should be Y/N !!!\n";
170 fin.unsetf(ios::skipws);
173 if((ch == '"') || (ch == 0x0A)) {
175 } // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
177 fin.setf(ios::skipws);
178 network[ap->n1]->arcs.push_back(ap);
179 network[ap->n2]->arcs.push_back(ap);
180 } else if(!strcmp(buf, "G")) {
182 gp->struct_type = NODE;
185 gp->nodeID = atoi(buf);
187 gp->pos.setlon(atof(buf));
189 gp->pos.setlat(atof(buf));
191 gp->pos.setelev(atof(buf));
192 fin >> buf; // gate type - ignore this for now
193 fin >> buf; // gate heading
194 gp->heading = atoi(buf);
198 fin.unsetf(ios::skipws);
201 if((ch == '"') || (ch == 0x0A)) {
203 } // we shouldn't need the 0x0A but it makes a nice safely in case someone leaves off the "
205 fin.setf(ios::skipws);
206 network.push_back(gp);
208 // Something has gone seriously pear-shaped
209 cout << "********* ERROR - unknown ground network element type... aborting read of " << path.c_str() << '\n';
218 void FGGround::Init() {
221 // For now we'll hardwire the threshold end
222 Point3D P010(-118.037483, 34.081358, 296 * SG_FEET_TO_METER);
224 ortho.Init(P010, hdg);
226 networkLoadOK = LoadNetwork();
229 void FGGround::Update() {
230 // Each time step, what do we need to do?
231 // We need to go through the list of outstanding requests and acknowedgements
232 // and process at least one of them.
233 // We need to go through the list of planes under our control and check if
234 // any need to be addressed.
235 // We need to check for planes not under our control coming within our
236 // control area and address if necessary.
238 // Lets take the example of a plane which has just contacted ground
239 // following landing - presumably requesting where to go?
240 // First we need to establish the position of the plane within the logical network.
241 // Next we need to decide where its going.
244 // FIXME - at the moment this assumes there is at least one gate and crashes if none
245 // FIXME - In fact, at the moment this routine doesn't work at all and hence is munged to always return Gate 1 !!!!
246 int FGGround::GetRandomGateID() {
247 //cout << "GetRandomGateID called" << endl;
250 gate_vec_type gateVec;
251 //gate_vec_iterator gateVecItr;
256 gatesItr = gates.begin();
257 while(gatesItr != gates.end()) {
258 if(gatesItr->second.used == false) {
259 gateVec.push_back(gatesItr->second);
265 // Randomly select one from the list
266 thenum = (int)(sg_random() * gateVec.size());
267 ID = gateVec[thenum].id;
268 //cout << "Returning gate ID " << ID << " from GetRandomGateID" << endl;
272 // Return a pointer to a gate node based on the gate ID
273 Gate* FGGround::GetGateNode(int gateID) {
274 //TODO - ought to add some sanity checking here - ie does a gate of this ID exist?!
275 return(&(gates[gateID]));
278 // Get a path from a point on a runway to a gate
280 // Get a path from a node to another node
281 // Eventually we will need complex algorithms for this taking other traffic,
282 // shortest path and suitable paths into accout. For now we're going to hardwire for KEMT!!!!
283 ground_network_path_type FGGround::GetPath(node* A, node* B) {
284 ground_network_path_type path;
285 //arc_array_iterator arcItr;
288 // VERY HARDWIRED - this hardwires a path from the far end of R01 to Gate 1.
289 // In fact in real life the area between R01/19 and Taxiway Alpha at KEMT is tarmaced and planes
290 // are supposed to exit the rwy asap.
291 // OK - for now very hardwire this for testing
292 path.push_back(network[1]);
293 path.push_back(network[1]->arcs[1]); // ONLY BECAUSE WE KNOW THIS IS THE ONE !!!!!
294 path.push_back(network[3]);
295 path.push_back(network[3]->arcs[1]);
296 path.push_back(network[5]);
297 path.push_back(network[5]->arcs[0]);
298 path.push_back(network[4]);
299 path.push_back(network[4]->arcs[2]);
300 path.push_back(network[6]);
301 path.push_back(network[6]->arcs[2]);
302 path.push_back(network[7]); // THE GATE!! Note that for now we're not even looking at the requested exit and gate passed in !!!!!
305 // In this hardwired scheme there are two possibilities - taxiing from rwy to gate or gate to rwy.
306 if(B->type == GATE) {
307 //return an inward path
309 // In this hardwired scheme we know A is a rwy exit and should have one taxiway arc only
310 // THIS WILL NOT HOLD TRUE IN THE GENERAL CASE
311 arcItr = A->arcs.begin();
313 while(arcItr != A->arcs.end()) {
314 if(arcItr->type == TAXIWAY) {
315 path.push_back(&(*arcItr));
321 //cout << "AI/ATC SUBSYSTEM ERROR - no taxiway from runway exit in airport.cxx" << endl;
323 // Then push back the start of taxiway node
324 // Then push back the taxiway arc
325 arcItr = A->arcs.begin();
327 while(arcItr != A->arcs.end()) {
328 if(arcItr->type == TAXIWAY) { // FIXME - OOPS - two taxiways go off this node
329 // How are we going to differentiate, apart from one called Alpha.
330 // I suppose eventually the traversal algorithms will select.
331 path.push_back(&(*arcItr));
337 //cout << "AI/ATC SUBSYSTEM ERROR - no taxiway from runway exit in airport.cxx" << endl;
339 // Then push back the junction node
340 // 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
341 // Repeat if necessary
342 // Then push back the gate B
345 //return an outward path
348 // WARNING TODO FIXME - this is VERY FRAGILE - eg taxi to apron!!! but should be enough to
349 // see an AI plane physically taxi.
356 // Randomly or otherwise populate some of the gates with parked planes
357 // (might eventually be done by the AIMgr if and when lots of AI traffic is generated)
359 // Return a list of exits from a given runway
360 // It is up to the calling function to check for non-zero size of returned array before use
361 node_array_type FGGround::GetExits(int rwyID) {
362 return(runways[rwyID].exits);
366 void FGGround::NewArrival(plane_rec plane) {
367 // What are we going to do here?
368 // We need to start a new ground_rec and add the plane_rec to it
369 // We need to decide what gate we are going to clear it to.
370 // Then we need to add clearing it to that gate to the pending transmissions queue? - or simply transmit?
371 // Probably simply transmit for now and think about a transmission queue later if we need one.
372 // We might need one though in order to add a little delay for response time.
373 ground_rec* g = new ground_rec;
374 g->plane_rec = plane;
375 g->current_pos = ConvertWGS84ToXY(plane.pos);
376 g->node = GetNode(g->current_pos); // TODO - might need to sort out node/arc here
379 ground_traffic.push_back(g);
383 void FGGround::NewContact(plane_rec plane) {
384 // This is a bit of a convienience function at the moment and is likely to change.
385 if(at a gate or apron)
391 void FGGround::NextClearance(ground_rec &g) {
392 // Need to work out where we can clear g to.
393 // Assume the pilot doesn't need progressive instructions
394 // We *should* already have a gate or holding point assigned by the time we get here
395 // but it wouldn't do any harm to check.
397 // For now though we will hardwire it to clear to the final destination.
400 void FGGround::AssignGate(ground_rec &g) {
401 // We'll cheat for now - since we only have the user's aircraft and a couple of airports implemented
402 // we'll hardwire the gate!
403 // In the long run the logic of which gate or area to send the plane to could be somewhat non-trivial.