]> git.mxchange.org Git - flightgear.git/blob - src/ATC/trafficcontrol.hxx
Kill off platformDesktopPath entirely
[flightgear.git] / src / ATC / trafficcontrol.hxx
1 // trafficcontrol.hxx - classes to manage AIModels based air traffic control
2 // Written by Durk Talsma, started September 2006.
3 //
4 // This program is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU General Public License as
6 // published by the Free Software Foundation; either version 2 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful, but
10 // WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 // General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with this program; if not, write to the Free Software
16 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
17 //
18 // $Id$
19
20
21 #ifndef _TRAFFIC_CONTROL_HXX_
22 #define _TRAFFIC_CONTROL_HXX_
23
24 #include <Airports/airports_fwd.hxx>
25
26 #include <osg/Geode>
27 #include <osg/Geometry>
28 #include <osg/MatrixTransform>
29 #include <osg/Shape>
30
31 #include <simgear/compiler.h>
32 // There is probably a better include than sg_geodesy to get the SG_NM_TO_METER...
33 #include <simgear/math/sg_geodesy.hxx>
34 #include <simgear/debug/logstream.hxx>
35 #include <simgear/structure/SGReferenced.hxx>
36 #include <simgear/structure/SGSharedPtr.hxx>
37
38 class FGAIAircraft;
39 typedef std::vector<FGAIAircraft*> AircraftVec;
40 typedef std::vector<FGAIAircraft*>::iterator AircraftVecIterator;
41
42 class FGAIFlightPlan;
43 typedef std::vector<FGAIFlightPlan*>           FlightPlanVec;
44 typedef std::vector<FGAIFlightPlan*>::iterator FlightPlanVecIterator;
45 typedef std::map<std::string, FlightPlanVec>   FlightPlanVecMap;
46
47 class FGTrafficRecord;
48 typedef std::list<FGTrafficRecord> TrafficVector;
49 typedef std::list<FGTrafficRecord>::iterator TrafficVectorIterator;
50
51 class ActiveRunway;
52 typedef std::vector<ActiveRunway> ActiveRunwayVec;
53 typedef std::vector<ActiveRunway>::iterator ActiveRunwayVecIterator;
54
55 typedef std::vector<int> intVec;
56 typedef std::vector<int>::iterator intVecIterator;
57
58 /**************************************************************************************
59  * class FGATCInstruction
60  * like class FGATC Controller, this class definition should go into its own file
61  * and or directory... For now, just testing this stuff out though...
62  *************************************************************************************/
63 class FGATCInstruction
64 {
65 private:
66     bool holdPattern;
67     bool holdPosition;
68     bool changeSpeed;
69     bool changeHeading;
70     bool changeAltitude;
71     bool resolveCircularWait;
72
73     double speed;
74     double heading;
75     double alt;
76 public:
77
78     FGATCInstruction();
79     bool hasInstruction   () const;
80     bool getHoldPattern   () const {
81         return holdPattern;
82     };
83     bool getHoldPosition  () const {
84         return holdPosition;
85     };
86     bool getChangeSpeed   () const {
87         return changeSpeed;
88     };
89     bool getChangeHeading () const {
90         return changeHeading;
91     };
92     bool getChangeAltitude() const {
93         return changeAltitude;
94     };
95
96     double getSpeed       () const {
97         return speed;
98     };
99     double getHeading     () const {
100         return heading;
101     };
102     double getAlt         () const {
103         return alt;
104     };
105
106     bool getCheckForCircularWait() const {
107         return resolveCircularWait;
108     };
109
110     void setHoldPattern   (bool val) {
111         holdPattern    = val;
112     };
113     void setHoldPosition  (bool val) {
114         holdPosition   = val;
115     };
116     void setChangeSpeed   (bool val) {
117         changeSpeed    = val;
118     };
119     void setChangeHeading (bool val) {
120         changeHeading  = val;
121     };
122     void setChangeAltitude(bool val) {
123         changeAltitude = val;
124     };
125
126     void setResolveCircularWait (bool val) {
127         resolveCircularWait = val;
128     };
129
130     void setSpeed       (double val) {
131         speed   = val;
132     };
133     void setHeading     (double val) {
134         heading = val;
135     };
136     void setAlt         (double val) {
137         alt     = val;
138     };
139 };
140
141
142
143
144
145 /**************************************************************************************
146  * class FGTrafficRecord
147  *************************************************************************************/
148 class FGTrafficRecord
149 {
150 private:
151     int id, waitsForId;
152     int currentPos;
153     int leg;
154     int frequencyId;
155     int state;
156     bool allowTransmission;
157     bool allowPushback;
158     int priority;
159     time_t timer;
160     intVec intentions;
161     FGATCInstruction instruction;
162     double latitude, longitude, heading, speed, altitude, radius;
163     std::string runway;
164     //FGAISchedule *trafficRef;
165     FGAIAircraft *aircraft;
166
167
168 public:
169     FGTrafficRecord();
170
171     void setId(int val)  {
172         id = val;
173     };
174     void setRadius(double rad) {
175         radius = rad;
176     };
177     void setPositionAndIntentions(int pos, FGAIFlightPlan *route);
178     void setRunway(const std::string& rwy) {
179         runway = rwy;
180     };
181     void setLeg(int lg) {
182         leg = lg;
183     };
184     int getId() {
185         return id;
186     };
187     int getState() {
188         return state;
189     };
190     void setState(int s) {
191         state = s;
192     }
193     FGATCInstruction getInstruction() {
194         return instruction;
195     };
196     bool hasInstruction() {
197         return instruction.hasInstruction();
198     };
199     void setPositionAndHeading(double lat, double lon, double hdg, double spd, double alt);
200     bool checkPositionAndIntentions(FGTrafficRecord &other);
201     int  crosses                   (FGGroundNetwork *, FGTrafficRecord &other);
202     bool isOpposing                (FGGroundNetwork *, FGTrafficRecord &other, int node);
203     
204     bool isActive(int margin) const;
205
206     bool onRoute(FGGroundNetwork *, FGTrafficRecord &other);
207
208     bool getSpeedAdjustment() const {
209         return instruction.getChangeSpeed();
210     };
211
212     double getLatitude () const {
213         return latitude ;
214     };
215     double getLongitude() const {
216         return longitude;
217     };
218     double getHeading  () const {
219         return heading  ;
220     };
221     double getSpeed    () const {
222         return speed    ;
223     };
224     double getAltitude () const {
225         return altitude ;
226     };
227     double getRadius   () const {
228         return radius   ;
229     };
230
231     int getWaitsForId  () const {
232         return waitsForId;
233     };
234
235     void setSpeedAdjustment(double spd);
236     void setHeadingAdjustment(double heading);
237     void clearSpeedAdjustment  () {
238         instruction.setChangeSpeed  (false);
239     };
240     void clearHeadingAdjustment() {
241         instruction.setChangeHeading(false);
242     };
243
244     bool hasHeadingAdjustment() const {
245         return instruction.getChangeHeading();
246     };
247     bool hasHoldPosition() const {
248         return instruction.getHoldPosition();
249     };
250     void setHoldPosition (bool inst) {
251         instruction.setHoldPosition(inst);
252     };
253
254     void setWaitsForId(int id) {
255         waitsForId = id;
256     };
257
258     void setResolveCircularWait()   {
259         instruction.setResolveCircularWait(true);
260     };
261     void clearResolveCircularWait() {
262         instruction.setResolveCircularWait(false);
263     };
264
265     const std::string& getRunway() const {
266         return runway;
267     };
268     //void setCallSign(string clsgn) { callsign = clsgn; };
269     void setAircraft(FGAIAircraft *ref) {
270         aircraft = ref;
271     };
272     void updateState() {
273         state++;
274         allowTransmission=true;
275     };
276     //string getCallSign() { return callsign; };
277     FGAIAircraft *getAircraft() const {
278         return aircraft;
279     };
280     int getTime() const {
281         return timer;
282     };
283     int getLeg() const {
284         return leg;
285     };
286     void setTime(time_t time) {
287         timer = time;
288     };
289
290     bool pushBackAllowed() const;
291     bool allowTransmissions() const {
292         return allowTransmission;
293     };
294     void allowPushBack() { allowPushback =true;};
295     void denyPushBack () { allowPushback = false;};
296     void suppressRepeatedTransmissions () {
297         allowTransmission=false;
298     };
299     void allowRepeatedTransmissions () {
300         allowTransmission=true;
301     };
302     void nextFrequency() {
303         frequencyId++;
304     };
305     int  getNextFrequency() const {
306         return frequencyId;
307     };
308     intVec& getIntentions() {
309         return intentions;
310     };
311     int getCurrentPosition() const {
312         return currentPos;
313     };
314     void setPriority(int p) { priority = p; };
315     int getPriority() const { return priority; };
316 };
317
318 /***********************************************************************
319  * Active runway, a utility class to keep track of which aircraft has
320  * clearance for a given runway.
321  **********************************************************************/
322 class ActiveRunway
323 {
324 private:
325     std::string rwy;
326     int currentlyCleared;
327     double distanceToFinal;
328     TimeVector estimatedArrivalTimes;
329     AircraftVec departureCue;
330
331 public:
332     ActiveRunway(const std::string& r, int cc) {
333         rwy = r;
334         currentlyCleared = cc;
335         distanceToFinal = 6.0 * SG_NM_TO_METER;
336     };
337
338     std::string getRunwayName() {
339         return rwy;
340     };
341     int    getCleared   () {
342         return currentlyCleared;
343     };
344     double getApproachDistance() {
345         return distanceToFinal;
346     };
347     //time_t getEstApproachTime() { return estimatedArrival; };
348
349     //void setEstApproachTime(time_t time) { estimatedArrival = time; };
350     void addToDepartureCue(FGAIAircraft *ac) {
351         departureCue.push_back(ac);
352     };
353     void setCleared(int number) {
354         currentlyCleared = number;
355     };
356     time_t requestTimeSlot(time_t eta);
357
358     int getDepartureCueSize() {
359         return departureCue.size();
360     };
361     FGAIAircraft* getFirstAircraftInDepartureCue() {
362         return departureCue.size() ? *(departureCue.begin()) : NULL;
363     };
364     FGAIAircraft* getFirstOfStatus(int stat);
365     void updateDepartureCue() {
366         departureCue.erase(departureCue.begin());
367     }
368     void printDepartureCue();
369 };
370
371 /**
372  * class FGATCController
373  * NOTE: this class serves as an abstraction layer for all sorts of ATC controllers.
374  *************************************************************************************/
375 class FGATCController
376 {
377 private:
378
379
380 protected:
381     bool initialized;
382     bool available;
383     time_t lastTransmission;
384
385     double dt_count;
386     osg::Group* group;
387
388     std::string formatATCFrequency3_2(int );
389     std::string genTransponderCode(const std::string& fltRules);
390     bool isUserAircraft(FGAIAircraft*);
391
392 public:
393     typedef enum {
394         MSG_ANNOUNCE_ENGINE_START,
395         MSG_REQUEST_ENGINE_START,
396         MSG_PERMIT_ENGINE_START,
397         MSG_DENY_ENGINE_START,
398         MSG_ACKNOWLEDGE_ENGINE_START,
399         MSG_REQUEST_PUSHBACK_CLEARANCE,
400         MSG_PERMIT_PUSHBACK_CLEARANCE,
401         MSG_HOLD_PUSHBACK_CLEARANCE,
402         MSG_ACKNOWLEDGE_SWITCH_GROUND_FREQUENCY,
403         MSG_INITIATE_CONTACT,
404         MSG_ACKNOWLEDGE_INITIATE_CONTACT,
405         MSG_REQUEST_TAXI_CLEARANCE,
406         MSG_ISSUE_TAXI_CLEARANCE,
407         MSG_ACKNOWLEDGE_TAXI_CLEARANCE,
408         MSG_HOLD_POSITION,
409         MSG_ACKNOWLEDGE_HOLD_POSITION,
410         MSG_RESUME_TAXI,
411         MSG_ACKNOWLEDGE_RESUME_TAXI,
412         MSG_REPORT_RUNWAY_HOLD_SHORT,
413         MSG_ACKNOWLEDGE_REPORT_RUNWAY_HOLD_SHORT,
414         MSG_SWITCH_TOWER_FREQUENCY,
415         MSG_ACKNOWLEDGE_SWITCH_TOWER_FREQUENCY
416     } AtcMsgId;
417
418     typedef enum {
419         ATC_AIR_TO_GROUND,
420         ATC_GROUND_TO_AIR
421     } AtcMsgDir;
422     FGATCController();
423     virtual ~FGATCController();
424     void init();
425
426     virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
427                                   double lat, double lon,
428                                   double hdg, double spd, double alt, double radius, int leg,
429                                   FGAIAircraft *aircraft) = 0;
430     virtual void             signOff(int id) = 0;
431     virtual void             updateAircraftInformation(int id, double lat, double lon,
432             double heading, double speed, double alt, double dt) = 0;
433     virtual bool             hasInstruction(int id) = 0;
434     virtual FGATCInstruction getInstruction(int id) = 0;
435
436     double getDt() {
437         return dt_count;
438     };
439     void   setDt(double dt) {
440         dt_count = dt;
441     };
442     void transmit(FGTrafficRecord *rec, FGAirportDynamics *parent, AtcMsgId msgId, AtcMsgDir msgDir, bool audible);
443     std::string getGateName(FGAIAircraft *aircraft);
444     virtual void render(bool) = 0;
445     virtual std::string getName()  = 0;
446
447     virtual void update(double) = 0;
448
449
450 private:
451
452     AtcMsgDir lastTransmissionDirection;
453 };
454
455 /******************************************************************************
456  * class FGTowerControl
457  *****************************************************************************/
458 class FGTowerController : public FGATCController
459 {
460 private:
461     TrafficVector activeTraffic;
462     ActiveRunwayVec activeRunways;
463     FGAirportDynamics *parent;
464
465 public:
466     FGTowerController(FGAirportDynamics *parent);
467     virtual ~FGTowerController() {};
468     virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
469                                   double lat, double lon,
470                                   double hdg, double spd, double alt, double radius, int leg,
471                                   FGAIAircraft *aircraft);
472     virtual void             signOff(int id);
473     virtual void             updateAircraftInformation(int id, double lat, double lon,
474             double heading, double speed, double alt, double dt);
475     virtual bool             hasInstruction(int id);
476     virtual FGATCInstruction getInstruction(int id);
477
478     virtual void render(bool);
479     virtual std::string getName();
480     virtual void update(double dt);
481     bool hasActiveTraffic() {
482         return activeTraffic.size() != 0;
483     };
484     TrafficVector &getActiveTraffic() {
485         return activeTraffic;
486     };
487 };
488
489 /******************************************************************************
490  * class FGStartupController
491  * handle
492  *****************************************************************************/
493
494 class FGStartupController : public FGATCController
495 {
496 private:
497     TrafficVector activeTraffic;
498     //ActiveRunwayVec activeRunways;
499     FGAirportDynamics *parent;
500
501 public:
502     FGStartupController(FGAirportDynamics *parent);
503     virtual ~FGStartupController() {};
504     virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
505                                   double lat, double lon,
506                                   double hdg, double spd, double alt, double radius, int leg,
507                                   FGAIAircraft *aircraft);
508     virtual void             signOff(int id);
509     virtual void             updateAircraftInformation(int id, double lat, double lon,
510             double heading, double speed, double alt, double dt);
511     virtual bool             hasInstruction(int id);
512     virtual FGATCInstruction getInstruction(int id);
513
514     virtual void render(bool);
515     virtual std::string getName();
516     virtual void update(double dt);
517
518     bool hasActiveTraffic() {
519         return activeTraffic.size() != 0;
520     };
521     TrafficVector &getActiveTraffic() {
522         return activeTraffic;
523     };
524
525     // Hpoefully, we can move this function to the base class, but I need to verify what is needed for the other controllers before doing so.
526     bool checkTransmissionState(int st, time_t now, time_t startTime, TrafficVectorIterator i, AtcMsgId msgId,
527                                 AtcMsgDir msgDir);
528
529 };
530
531 /******************************************************************************
532  * class FGTowerControl
533  *****************************************************************************/
534 class FGApproachController : public FGATCController
535 {
536 private:
537     TrafficVector activeTraffic;
538     ActiveRunwayVec activeRunways;
539     FGAirportDynamics *parent;
540
541 public:
542     FGApproachController(FGAirportDynamics * parent);
543     virtual ~FGApproachController() { };
544     virtual void announcePosition(int id, FGAIFlightPlan *intendedRoute, int currentRoute,
545                                   double lat, double lon,
546                                   double hdg, double spd, double alt, double radius, int leg,
547                                   FGAIAircraft *aircraft);
548     virtual void             signOff(int id);
549     virtual void             updateAircraftInformation(int id, double lat, double lon,
550             double heading, double speed, double alt, double dt);
551     virtual bool             hasInstruction(int id);
552     virtual FGATCInstruction getInstruction(int id);
553
554     virtual void render(bool);
555     virtual std::string getName();
556     virtual void update(double dt);
557
558     ActiveRunway* getRunway(const std::string& name);
559
560     bool hasActiveTraffic() {
561         return activeTraffic.size() != 0;
562     };
563     TrafficVector &getActiveTraffic() {
564         return activeTraffic;
565     };
566 };
567
568
569 #endif // _TRAFFIC_CONTROL_HXX