source: src/mlx/checks.py@ 546:707f2520f2d4

Last change on this file since 546:707f2520f2d4 was 546:707f2520f2d4, checked in by István Váradi <ivaradi@…>, 10 years ago

Added some logging to the Tupolev anti-collision lights checker (re #220)
File size: 64.9 KB
Line 
1
2import fs
3import const
4import util
5from acars import ACARS
6from sound import startSound
7
8import time
9
10#---------------------------------------------------------------------------------------
11
12## @package mlx.checks
13#
14# The classes that check the state of the aircraft.
15#
16# During the flight the program periodically queries various data from the
17# simulator. This data is returned in instances of the \ref
18# mlx.fs.AircraftState class and passed to the various "checkers",
19# i.e. instances of subclasses of the \ref StateChecker class. These checkers
20# perform various checks to see if the aircraft's parameters are within the
21# expected limits, or some of them just logs something.
22#
23# There are a few special ones, such as \ref StageChecker which computes the
24# transitions from one stage of the flight to the next one. Or \ref ACARSSender
25# which sends the ACARS periodically
26
27#---------------------------------------------------------------------------------------
28
29class StateChecker(object):
30 """Base class for classes the instances of which check the aircraft's state
31 from some aspect.
32
33 As a result of the check they may log something, or notify of some fault, etc."""
34 def check(self, flight, aircraft, logger, oldState, state):
35 """Perform the check and do whatever is needed.
36
37 This default implementation raises a NotImplementedError."""
38 raise NotImplementedError()
39
40#---------------------------------------------------------------------------------------
41
42class StageChecker(StateChecker):
43 """Check the flight stage transitions."""
44 def __init__(self):
45 """Construct the stage checker."""
46 self._flareStarted = False
47
48 def check(self, flight, aircraft, logger, oldState, state):
49 """Check the stage of the aircraft."""
50 stage = flight.stage
51 if stage==None:
52 aircraft.setStage(state, const.STAGE_BOARDING)
53 elif stage==const.STAGE_BOARDING:
54 if not state.parking or \
55 (not state.trickMode and state.groundSpeed>5.0):
56 aircraft.setStage(state, const.STAGE_PUSHANDTAXI)
57 elif stage==const.STAGE_PUSHANDTAXI or stage==const.STAGE_RTO:
58 if state.strobeLightsOn or \
59 (state.strobeLightsOn is None and state.xpdrC):
60 aircraft.setStage(state, const.STAGE_TAKEOFF)
61 elif stage==const.STAGE_TAKEOFF:
62 if not state.gearsDown or \
63 (state.radioAltitude>3000.0 and state.vs>0):
64 aircraft.setStage(state, const.STAGE_CLIMB)
65 elif not state.landingLightsOn and \
66 (state.strobeLightsOn is False or
67 (state.strobeLightsOn is None and state.xpdrC is False)) and \
68 state.onTheGround and \
69 state.groundSpeed<50.0:
70 aircraft.setStage(state, const.STAGE_RTO)
71 elif stage==const.STAGE_CLIMB:
72 if (state.altitude+2000) > flight.cruiseAltitude:
73 aircraft.setStage(state, const.STAGE_CRUISE)
74 elif state.radioAltitude<2000.0 and \
75 state.vs < 0.0 and state.gearsDown:
76 aircraft.setStage(state, const.STAGE_LANDING)
77 elif stage==const.STAGE_CRUISE:
78 if (state.altitude+2000) < flight.cruiseAltitude:
79 aircraft.setStage(state, const.STAGE_DESCENT)
80 elif stage==const.STAGE_DESCENT or stage==const.STAGE_GOAROUND:
81 if state.gearsDown and state.radioAltitude<2000.0:
82 aircraft.setStage(state, const.STAGE_LANDING)
83 elif (state.altitude+2000) > flight.cruiseAltitude:
84 aircraft.setStage(state, const.STAGE_CRUISE)
85 elif stage==const.STAGE_LANDING:
86 if state.onTheGround and state.groundSpeed<25.0:
87 aircraft.setStage(state, const.STAGE_TAXIAFTERLAND)
88 elif not state.gearsDown:
89 aircraft.setStage(state, const.STAGE_GOAROUND)
90 elif state.radioAltitude>200 and self._flareStarted:
91 aircraft.cancelFlare()
92 self._flareStarted = False
93 elif state.radioAltitude<150 and not state.onTheGround and \
94 not self._flareStarted:
95 self._flareStarted = True
96 aircraft.prepareFlare()
97 elif stage==const.STAGE_TAXIAFTERLAND:
98 if state.parking and aircraft.checkFlightEnd(state):
99 aircraft.setStage(state, const.STAGE_END)
100
101#---------------------------------------------------------------------------------------
102
103class ACARSSender(StateChecker):
104 """Sender of online ACARS.
105
106 It sends the ACARS every 3 minutes to the MAVA website."""
107
108 ## The interval at which the ACARS are sent
109 INTERVAL = 3*60.0
110
111 def __init__(self, gui):
112 """Construct the ACARS sender."""
113 self._gui = gui
114 self._lastSent = None
115 self._sending = False
116
117 def check(self, flight, aircraft, logger, oldState, state):
118 """If the time has come to send the ACARS, send it."""
119 if self._sending:
120 return
121
122 now = time.time()
123
124 if self._lastSent is not None and \
125 (self._lastSent + ACARSSender.INTERVAL)>now:
126 return
127
128 self._sending = True
129 acars = ACARS(self._gui, state)
130 self._gui.webHandler.sendACARS(self._acarsCallback, acars)
131
132 def _acarsCallback(self, returned, result):
133 """Callback for ACARS sending."""
134 if returned:
135 print "Sent online ACARS"
136 self._lastSent = time.time() if self._lastSent is None \
137 else self._lastSent + ACARSSender.INTERVAL
138 else:
139 print "Failed to send the ACARS"
140 self._sending = False
141
142#---------------------------------------------------------------------------------------
143
144class TakeOffLogger(StateChecker):
145 """Logger for the cruise speed."""
146 def __init__(self):
147 """Construct the logger."""
148 self._onTheGround = True
149
150 def check(self, flight, aircraft, logger, oldState, state):
151 """Log the cruise speed if necessary."""
152 if flight.stage==const.STAGE_TAKEOFF and \
153 self._onTheGround and not state.onTheGround:
154 logger.message(state.timestamp,
155 "Takeoff speed: %.0f %s" % \
156 (flight.speedFromKnots(state.ias),
157 flight.getEnglishSpeedUnit()))
158 logger.message(state.timestamp,
159 "Takeoff heading: %03.0f degrees" % (state.heading,))
160 logger.message(state.timestamp,
161 "Takeoff pitch: %.1f degrees" % (state.pitch,))
162 logger.message(state.timestamp,
163 "Takeoff flaps: %.0f" % (state.flapsSet))
164 logger.message(state.timestamp,
165 "CG/Trim: %.1f%%/%.2f" % \
166 (state.cog*100.0, state.elevatorTrim))
167 self._onTheGround = False
168
169#---------------------------------------------------------------------------------------
170
171class CruiseSpeedLogger(StateChecker):
172 """Logger for the cruise speed."""
173 def __init__(self):
174 """Construct the logger."""
175 self._lastTime = None
176
177 def check(self, flight, aircraft, logger, oldState, state):
178 """Log the cruise speed if necessary."""
179 if flight.stage==const.STAGE_CRUISE and \
180 (self._lastTime is None or \
181 (self._lastTime+800)<=state.timestamp):
182 if state.altitude>24500.0:
183 logger.message(state.timestamp,
184 "Cruise speed: %.3f mach" % (state.mach,))
185 else:
186 logger.message(state.timestamp,
187 "Cruise speed: %.0f %s" %
188 (flight.speedFromKnots(state.ias),
189 flight.getEnglishSpeedUnit()))
190 self._lastTime = state.timestamp
191
192#---------------------------------------------------------------------------------------
193
194class SpoilerLogger(StateChecker):
195 """Logger for the cruise speed."""
196 def __init__(self):
197 """Construct the logger."""
198 self._logged = False
199 self._spoilersExtension = None
200
201 def check(self, flight, aircraft, logger, oldState, state):
202 """Log the cruise speed if necessary."""
203 if flight.stage==const.STAGE_LANDING and not self._logged:
204 if state.onTheGround:
205 if state.spoilersExtension!=self._spoilersExtension:
206 logger.message(state.timestamp, "Spoilers deployed")
207 self._logged = True
208 config = flight.config
209 if config.enableSounds and config.speedbrakeAtTD:
210 startSound(const.SOUND_SPEEDBRAKE)
211 else:
212 self._spoilersExtension = state.spoilersExtension
213
214#---------------------------------------------------------------------------------------
215
216class VisibilityChecker(StateChecker):
217 """Inform the pilot of the visibility once when descending below 2000 ft,
218 then when descending below 1000 ft."""
219 def __init__(self):
220 """Construct the visibility checker."""
221 self._informedBelow2000 = False
222 self._informedBelow1000 = False
223
224 def check(self, flight, aircraft, logger, oldState, state):
225 """Check if we need to inform the pilot of the visibility."""
226 if flight.stage==const.STAGE_DESCENT or \
227 flight.stage==const.STAGE_LANDING:
228 if (state.radioAltitude<2000 and not self._informedBelow2000) or \
229 (state.radioAltitude<1000 and not self._informedBelow1000):
230 visibilityString = util.visibility2String(state.visibility)
231 fs.sendMessage(const.MESSAGETYPE_VISIBILITY,
232 "Current visibility: " + visibilityString,
233 5)
234 logger.message(state.timestamp,
235 "Pilot was informed about the visibility: " +
236 visibilityString)
237 self._informedBelow2000 = True
238 self._informedBelow1000 = state.radioAltitude<1000
239
240#---------------------------------------------------------------------------------------
241
242class ApproachCalloutsPlayer(StateChecker):
243 """A state checker that plays a sequence of approach callouts.
244
245 It tracks the altitude during the descent and landing phases and
246 if the altitude crosses one that has a callout associated with and
247 the vertical speed is negative, that callout will be played."""
248 def __init__(self, approachCallouts):
249 """Construct the approach callouts player."""
250 self._approachCallouts = approachCallouts
251 self._altitudes = approachCallouts.getAltitudes(descending = False)
252
253 def check(self, flight, aircraft, logger, oldState, state):
254 """Check if we need to play a callout."""
255 if (flight.stage==const.STAGE_DESCENT or \
256 flight.stage==const.STAGE_LANDING) and state.vs<0:
257 oldRadioAltitude = oldState.radioAltitude
258 radioAltitude = state.radioAltitude
259 for altitude in self._altitudes:
260 if radioAltitude<=altitude and \
261 oldRadioAltitude>altitude:
262 startSound(self._approachCallouts[altitude])
263 break
264
265#---------------------------------------------------------------------------------------
266
267class StateChangeLogger(StateChecker):
268 """Base class for classes the instances of which check if a specific change has
269 occured in the aircraft's state, and log such change."""
270 def __init__(self, logInitial = True, excludedStages = None):
271 """Construct the logger.
272
273 If logInitial is True, the initial value will be logged, not just the
274 changes later.
275
276 If excludedStages is given, it should be a list containing those stages
277 during which the changes should not be logged.
278
279 Child classes should define the following functions:
280 - _changed(self, oldState, state): returns a boolean indicating if the
281 value has changed or not
282 - _getMessage(self, flight, state, forced): return a strings containing
283 the message to log with the new value
284 """
285 self._logInitial = logInitial
286 self._excludedStages = [] if excludedStages is None else excludedStages
287
288 def _getLogTimestamp(self, state, forced):
289 """Get the log timestamp."""
290 return state.timestamp
291
292 def check(self, flight, aircraft, logger, oldState, state):
293 """Check if the state has changed, and if so, log the new state."""
294 if flight.stage in self._excludedStages:
295 return
296
297 shouldLog = False
298 if oldState is None:
299 shouldLog = self._logInitial
300 else:
301 shouldLog = self._changed(oldState, state)
302
303 if shouldLog:
304 self.logState(flight, logger, state)
305
306 def logState(self, flight, logger, state, forced = False):
307 """Log the state."""
308 message = self._getMessage(flight, state, forced)
309 if message is not None:
310 logger.message(self._getLogTimestamp(state, forced), message)
311
312#-------------------------------------------------------------------------------
313
314class SimpleChangeMixin(object):
315 """A mixin that defines a _changed() function which simply calls a function
316 to retrieve the value two monitor for both states and compares them.
317
318 Child classes should define the following function:
319 - _getValue(state): get the value we are interested in."""
320 def _changed(self, oldState, state):
321 """Determine if the value has changed."""
322 currentValue = self._getValue(state)
323 return currentValue is not None and self._getValue(oldState)!=currentValue
324
325#---------------------------------------------------------------------------------------
326
327class SingleValueMixin(object):
328 """A mixin that provides a _getValue() function to query a value from the
329 state using the name of the attribute."""
330 def __init__(self, attrName):
331 """Construct the mixin with the given attribute name."""
332 self._attrName = attrName
333
334 def _getValue(self, state):
335 """Get the value of the attribute from the state."""
336 return getattr(state, self._attrName)
337
338#---------------------------------------------------------------------------------------
339
340class DelayedChangeMixin(object):
341 """A mixin to a StateChangeLogger that stores the old value and reports a
342 change only if the change has been there for a certain amount of time.
343
344 Child classes should define the following function:
345 - _getValue(state): get the value we are interested in."""
346 def __init__(self, minDelay = 3.0, maxDelay = 10.0):
347 """Construct the mixin with the given delay in seconds."""
348 self._minDelay = minDelay
349 self._maxDelay = maxDelay
350 self._oldValue = None
351 self._firstChange = None
352 self._lastChangeState = None
353 self._lastLoggedValue = None
354
355 self._logState = lambda flight, logger, state, forced = False: \
356 StateChangeLogger.logState(self, flight, logger, state,
357 forced = forced)
358 self.logState = lambda flight, logger, state, forced = False: \
359 DelayedChangeMixin.logState(self, flight, logger, state,
360 forced = forced)
361
362 def _changed(self, oldState, state):
363 """Determine if the value has changed."""
364 if self._oldValue is None:
365 self._oldValue = self._getValue(oldState)
366
367 newValue = self._getValue(state)
368 if self._isDifferent(self._oldValue, newValue):
369 if self._lastLoggedValue is not None and \
370 not self._isDifferent(self._lastLoggedValue, newValue):
371 self._firstChange = None
372 else:
373 if self._firstChange is None:
374 self._firstChange = state.timestamp
375 self._lastChangeState = state
376 self._oldValue = newValue
377
378 if self._firstChange is not None:
379 if state.timestamp >= min(self._lastChangeState.timestamp +
380 self._minDelay,
381 self._firstChange + self._maxDelay):
382 self._firstChange = None
383 return True
384
385 return False
386
387 def _getLogTimestamp(self, state, forced):
388 """Get the log timestamp."""
389 return self._lastChangeState.timestamp \
390 if not forced and self._lastChangeState is not None \
391 else state.timestamp
392
393 def _isDifferent(self, oldValue, newValue):
394 """Determine if the given values are different.
395
396 This default implementation checks for simple equality."""
397 return oldValue!=newValue
398
399 def logState(self, flight, logger, state, forced):
400 """Log the given state.
401
402 The value belonging to that state is recorded in _lastLoggedValue.
403
404 It calls _logState to perform the real logging."""
405 self._lastLoggedValue = self._getValue(state)
406 self._logState(flight, logger, state, forced = forced)
407
408#---------------------------------------------------------------------------------------
409
410class TemplateMessageMixin(object):
411 """Mixin to generate a message based on a template.
412
413 Child classes should define the following function:
414 - _getValue(state): get the value we are interested in."""
415 def __init__(self, template):
416 """Construct the mixin."""
417 self._template = template
418
419 def _getMessage(self, flight, state, forced):
420 """Get the message."""
421 value = self._getValue(state)
422 return None if value is None else self._template % (value,)
423
424#---------------------------------------------------------------------------------------
425
426class GenericStateChangeLogger(StateChangeLogger, SingleValueMixin,
427 DelayedChangeMixin, TemplateMessageMixin):
428 """Base for generic state change loggers that monitor a single value in the
429 state possibly with a delay and the logged message comes from a template"""
430 def __init__(self, attrName, template, logInitial = True,
431 excludedStages = None, minDelay = 0.0, maxDelay = 0.0):
432 """Construct the object."""
433 StateChangeLogger.__init__(self, logInitial = logInitial,
434 excludedStages = excludedStages)
435 SingleValueMixin.__init__(self, attrName)
436 DelayedChangeMixin.__init__(self, minDelay = minDelay,
437 maxDelay = maxDelay)
438 TemplateMessageMixin.__init__(self, template)
439 self._getLogTimestamp = \
440 lambda state, forced: \
441 DelayedChangeMixin._getLogTimestamp(self, state, forced)
442
443#---------------------------------------------------------------------------------------
444
445class ForceableLoggerMixin(object):
446 """A mixin for loggers that can be forced to log a certain state."""
447 def forceLog(self, flight, logger, state):
448 """Force logging the given state."""
449 self.logState(flight, logger, state, forced = True)
450
451#---------------------------------------------------------------------------------------
452
453class AltimeterLogger(StateChangeLogger, SingleValueMixin,
454 DelayedChangeMixin):
455 """Logger for the altimeter setting."""
456 def __init__(self):
457 """Construct the logger."""
458 StateChangeLogger.__init__(self, logInitial = True)
459 SingleValueMixin.__init__(self, "altimeter")
460 DelayedChangeMixin.__init__(self)
461 self._getLogTimestamp = \
462 lambda state, forced: \
463 DelayedChangeMixin._getLogTimestamp(self, state, forced)
464
465 def _getMessage(self, flight, state, forced):
466 """Get the message to log on a change."""
467 logState = self._lastChangeState if \
468 self._lastChangeState is not None else state
469 message = "Altimeter: %.2f hPa at %.0f feet" % \
470 (logState.altimeter, logState.altitude)
471 if not logState.altimeterReliable:
472 message += " (u/r)"
473 return message
474
475#---------------------------------------------------------------------------------------
476
477class NAVLogger(StateChangeLogger, DelayedChangeMixin, ForceableLoggerMixin):
478 """Logger for NAV radios.
479
480 It also logs the OBS radial set."""
481 excludedStages = [const.STAGE_BOARDING, const.STAGE_PUSHANDTAXI,
482 const.STAGE_RTO, const.STAGE_TAXIAFTERLAND,
483 const.STAGE_PARKING]
484
485 @staticmethod
486 def getMessage(logName, frequency, obs):
487 """Get the message for the given NAV radio setting."""
488 message = u"%-5s %s" % (logName + ":", frequency)
489 if obs is not None: message += u" (%03d\u00b0)" % (obs,)
490 return message
491
492 def __init__(self, attrName, logName):
493 """Construct the NAV logger."""
494 StateChangeLogger.__init__(self, logInitial = False,
495 excludedStages = self.excludedStages)
496 DelayedChangeMixin.__init__(self)
497
498 self._getLogTimestamp = \
499 lambda state, forced: \
500 DelayedChangeMixin._getLogTimestamp(self, state, forced)
501
502 self._attrName = attrName
503 self._logName = logName
504
505 def _getValue(self, state):
506 """Get the value.
507
508 If both the frequency and the obs settings are available, a tuple
509 containing them is returned, otherwise None."""
510 frequency = getattr(state, self._attrName)
511 obs = getattr(state, self._attrName + "_obs")
512 manual = getattr(state, self._attrName + "_manual")
513 return (frequency, obs, manual)
514
515 def _getMessage(self, flight, state, forced):
516 """Get the message."""
517 (frequency, obs, manual) = self._getValue(state)
518 return None if frequency is None or obs is None or \
519 (not manual and not forced) else \
520 self.getMessage(self._logName, frequency, obs)
521
522 def _isDifferent(self, oldValue, newValue):
523 """Determine if the valie has changed between the given states."""
524 (oldFrequency, oldOBS, _oldManual) = oldValue
525 (newFrequency, newOBS, _newManual) = newValue
526 return oldFrequency!=newFrequency or oldOBS!=newOBS
527
528#---------------------------------------------------------------------------------------
529
530class ILSLogger(NAVLogger):
531 """Logger for the ILS radio setting."""
532 def __init__(self):
533 """Construct the logger."""
534 super(ILSLogger, self).__init__("ils", "ILS")
535
536#---------------------------------------------------------------------------------------
537
538class NAV1Logger(NAVLogger):
539 """Logger for the NAV1 radio setting."""
540 def __init__(self):
541 """Construct the logger."""
542 super(NAV1Logger, self).__init__("nav1", "NAV1")
543
544#---------------------------------------------------------------------------------------
545
546class NAV2Logger(NAVLogger):
547 """Logger for the NAV2 radio setting."""
548 def __init__(self):
549 """Construct the logger."""
550 super(NAV2Logger, self).__init__("nav2", "NAV2")
551
552#---------------------------------------------------------------------------------------
553
554class ADFLogger(GenericStateChangeLogger, ForceableLoggerMixin):
555 """Base class for the ADF loggers."""
556 def __init__(self, attr, logName):
557 """Construct the ADF logger."""
558 GenericStateChangeLogger.__init__(self, attr,
559 "%s: %%s" % (logName,),
560 logInitial = False,
561 excludedStages =
562 NAVLogger.excludedStages,
563 minDelay = 3.0, maxDelay = 10.0)
564
565#---------------------------------------------------------------------------------------
566
567class ADF1Logger(ADFLogger):
568 """Logger for the ADF1 radio setting."""
569 def __init__(self):
570 """Construct the logger."""
571 super(ADF1Logger, self).__init__("adf1", "ADF1")
572
573#---------------------------------------------------------------------------------------
574
575class ADF2Logger(ADFLogger):
576 """Logger for the ADF2 radio setting."""
577 def __init__(self):
578 """Construct the logger."""
579 super(ADF2Logger, self).__init__("adf2", "ADF2")
580
581#---------------------------------------------------------------------------------------
582
583class SquawkLogger(GenericStateChangeLogger):
584 """Logger for the squawk setting."""
585 def __init__(self):
586 """Construct the logger."""
587 super(SquawkLogger, self).__init__("squawk", "Squawk code: %s",
588 minDelay = 3.0, maxDelay = 10.0)
589
590#---------------------------------------------------------------------------------------
591
592class LightsLogger(StateChangeLogger, SingleValueMixin, SimpleChangeMixin):
593 """Base class for the loggers of the various lights."""
594 def __init__(self, attrName, template):
595 """Construct the logger."""
596 StateChangeLogger.__init__(self)
597 SingleValueMixin.__init__(self, attrName)
598
599 self._template = template
600
601 def _getMessage(self, flight, state, forced):
602 """Get the message from the given state."""
603 value = self._getValue(state)
604 if value is None:
605 return None
606 else:
607 return self._template % ("ON" if value else "OFF")
608
609#---------------------------------------------------------------------------------------
610
611class AnticollisionLightsLogger(LightsLogger):
612 """Logger for the anti-collision lights."""
613 def __init__(self):
614 LightsLogger.__init__(self, "antiCollisionLightsOn",
615 "Anti-collision lights: %s")
616
617#---------------------------------------------------------------------------------------
618
619class LandingLightsLogger(LightsLogger):
620 """Logger for the landing lights."""
621 def __init__(self):
622 LightsLogger.__init__(self, "landingLightsOn",
623 "Landing lights: %s")
624
625#---------------------------------------------------------------------------------------
626
627class StrobeLightsLogger(LightsLogger):
628 """Logger for the strobe lights."""
629 def __init__(self):
630 LightsLogger.__init__(self, "strobeLightsOn",
631 "Strobe lights: %s")
632
633#---------------------------------------------------------------------------------------
634
635class NavLightsLogger(LightsLogger):
636 """Logger for the navigational lights."""
637 def __init__(self):
638 LightsLogger.__init__(self, "navLightsOn",
639 "Navigational lights: %s")
640
641#---------------------------------------------------------------------------------------
642
643class FlapsLogger(StateChangeLogger, SingleValueMixin, DelayedChangeMixin):
644 """Logger for the flaps setting."""
645 def __init__(self):
646 """Construct the logger."""
647 StateChangeLogger.__init__(self, logInitial = True,
648 excludedStages =
649 [const.STAGE_BOARDING,
650 const.STAGE_PUSHANDTAXI,
651 const.STAGE_RTO,
652 const.STAGE_TAKEOFF])
653 SingleValueMixin.__init__(self, "flapsSet")
654 DelayedChangeMixin.__init__(self)
655 self._getLogTimestamp = \
656 lambda state, forced: \
657 DelayedChangeMixin._getLogTimestamp(self, state, forced)
658
659 def _getMessage(self, flight, state, forced):
660 """Get the message to log on a change."""
661 logState = self._lastChangeState if \
662 self._lastChangeState is not None else state
663 speed = logState.groundSpeed if logState.groundSpeed<80.0 \
664 else logState.ias
665 message = "Flaps %.0f - %.0f %s" % \
666 (logState.flapsSet, flight.speedFromKnots(speed),
667 flight.getEnglishSpeedUnit())
668
669 if flight.stage in [const.STAGE_DESCENT, const.STAGE_LANDING]:
670 message += ", %.0f ft AGL" % (logState.radioAltitude,)
671
672 return message
673
674#---------------------------------------------------------------------------------------
675
676class GearsLogger(StateChangeLogger, SingleValueMixin, SimpleChangeMixin):
677 """Logger for the gears state."""
678 def __init__(self):
679 """Construct the logger."""
680 StateChangeLogger.__init__(self, logInitial = True)
681 SingleValueMixin.__init__(self, "gearControlDown")
682
683 def _getMessage(self, flight, state, forced):
684 """Get the message to log on a change."""
685 return "Gears SET to %s at %.0f %s, %.0f ft, %.0f ft AGL" % \
686 ("DOWN" if state.gearControlDown else "UP",
687 flight.speedFromKnots(state.ias),
688 flight.getEnglishSpeedUnit(),
689 state.altitude, state.radioAltitude)
690
691#---------------------------------------------------------------------------------------
692
693class APLogger(StateChangeLogger, DelayedChangeMixin):
694 """Log the state of the autopilot."""
695 @staticmethod
696 def _logBoolean(logger, timestamp, what, value):
697 """Log a boolean value.
698
699 what is the name of the value that is being logged."""
700 message = what + " "
701 if value is None:
702 message += "cannot be detected, will not log"
703 else:
704 message += "is " + ("ON" if value else "OFF")
705 logger.message(timestamp, message)
706
707 @staticmethod
708 def _logNumeric(logger, timestamp, what, format, value):
709 """Log a numerical value."""
710 message = what
711 if value is None:
712 message += u" cannot be detected, will not log"
713 else:
714 message += u": " + format % (value,)
715 logger.message(timestamp, message)
716
717 @staticmethod
718 def _logAPMaster(logger, timestamp, state):
719 """Log the AP master state."""
720 APLogger._logBoolean(logger, timestamp, "AP master",
721 state.apMaster)
722
723 @staticmethod
724 def _logAPHeadingHold(logger, timestamp, state):
725 """Log the AP heading hold state."""
726 APLogger._logBoolean(logger, timestamp, "AP heading hold",
727 state.apHeadingHold)
728
729 @staticmethod
730 def _logAPHeading(logger, timestamp, state):
731 """Log the AP heading."""
732 APLogger._logNumeric(logger, timestamp, u"AP heading",
733 u"%03.0f\u00b0", state.apHeading)
734
735 @staticmethod
736 def _logAPAltitudeHold(logger, timestamp, state):
737 """Log the AP altitude hold state."""
738 APLogger._logBoolean(logger, timestamp, "AP altitude hold",
739 state.apAltitudeHold)
740
741 @staticmethod
742 def _logAPAltitude(logger, timestamp, state):
743 """Log the AP heading."""
744 APLogger._logNumeric(logger, timestamp, u"AP altitude",
745 u"%.0f ft", state.apAltitude)
746
747 def __init__(self):
748 """Construct the state logger."""
749 StateChangeLogger.__init__(self)
750 DelayedChangeMixin.__init__(self)
751 self._lastLoggedState = None
752 self.logState = lambda flight, logger, state:\
753 APLogger.logState(self, flight, logger, state)
754
755 def _getValue(self, state):
756 """Convert the relevant values from the given state into a tuple."""
757 return (state.apMaster,
758 state.apHeadingHold, state.apHeading,
759 state.apAltitudeHold, state.apAltitude)
760
761 def _isDifferent(self, oldValue, newValue):
762 """Determine if the given old and new values are different (enough) to
763 be logged."""
764 (oldAPMaster, oldAPHeadingHold, oldAPHeading,
765 oldAPAltitudeHold, oldAPAltitude) = oldValue
766 (apMaster, apHeadingHold, apHeading,
767 apAltitudeHold, apAltitude) = newValue
768
769 if apMaster is not None and apMaster!=oldAPMaster:
770 return True
771 if apMaster is False:
772 return False
773
774 if apHeadingHold is not None and apHeadingHold!=oldAPHeadingHold:
775 return True
776 if apHeadingHold is not False and apHeading is not None and \
777 apHeading!=oldAPHeading:
778 return True
779
780 if apAltitudeHold is not None and apAltitudeHold!=oldAPAltitudeHold:
781 return True
782 if apAltitudeHold is not False and apAltitude is not None and \
783 apAltitude!=oldAPAltitude:
784 return True
785
786 return False
787
788 def logState(self, flight, logger, state):
789 """Log the autopilot state."""
790 timestamp = DelayedChangeMixin._getLogTimestamp(self, state, False)
791 if self._lastLoggedState is None:
792 self._logAPMaster(logger, timestamp, state)
793 if state.apMaster is not False or state.apHeadingHold is None:
794 self._logAPHeadingHold(logger, timestamp, state)
795 if state.apMaster is not False and \
796 (state.apHeadingHold is not False or state.apHeading is None):
797 self._logAPHeading(logger, timestamp, state)
798 if state.apMaster is not False or state.apAltitudeHold is None:
799 self._logAPAltitudeHold(logger, timestamp, state)
800 if state.apMaster is not False and \
801 (state.apAltitudeHold is not False or state.apAltitude is None):
802 self._logAPAltitude(logger, timestamp, state)
803 self._firstCall = False
804 else:
805 oldState = self._lastLoggedState
806
807 apMasterTurnedOn = False
808 if state.apMaster is not None and state.apMaster!=oldState.apMaster:
809 apMasterTurnedOn = state.apMaster
810 self._logAPMaster(logger, timestamp, state)
811
812 if state.apMaster is not False:
813 apHeadingHoldTurnedOn = False
814 if state.apHeadingHold is not None and \
815 (state.apHeadingHold!=oldState.apHeadingHold or
816 apMasterTurnedOn):
817 apHeadingHoldTurnedOn = state.apHeadingHold
818 self._logAPHeadingHold(logger, timestamp, state)
819
820 if state.apHeadingHold is not False and \
821 state.apHeading is not None and \
822 (state.apHeading!=oldState.apHeading or apMasterTurnedOn or
823 apHeadingHoldTurnedOn):
824 self._logAPHeading(logger, timestamp, state)
825
826 apAltitudeHoldTurnedOn = False
827 if state.apAltitudeHold is not None and \
828 (state.apAltitudeHold!=oldState.apAltitudeHold or
829 apMasterTurnedOn):
830 apAltitudeHoldTurnedOn = state.apAltitudeHold
831 self._logAPAltitudeHold(logger, timestamp, state)
832
833 if state.apAltitudeHold is not False and \
834 state.apAltitude is not None and \
835 (state.apAltitude!=oldState.apAltitude or apMasterTurnedOn or
836 apAltitudeHoldTurnedOn):
837 self._logAPAltitude(logger, timestamp, state)
838
839 self._lastLoggedState = state
840
841#---------------------------------------------------------------------------------------
842
843class FaultChecker(StateChecker):
844 """Base class for checkers that look for faults."""
845 @staticmethod
846 def _appendDuring(flight, message):
847 """Append a 'during XXX' test to the given message, depending on the
848 flight stage."""
849 stageStr = const.stage2string(flight.stage)
850 return message if stageStr is None \
851 else (message + " during " + stageStr.upper())
852
853 @staticmethod
854 def _getLinearScore(minFaultValue, maxFaultValue, minScore, maxScore,
855 value):
856 """Get the score for a faulty value where the score is calculated
857 linearly within a certain range."""
858 if value<minFaultValue:
859 return 0
860 elif value>maxFaultValue:
861 return maxScore
862 else:
863 return minScore + (maxScore-minScore) * (value-minFaultValue) / \
864 (maxFaultValue - minFaultValue)
865
866#---------------------------------------------------------------------------------------
867
868class SimpleFaultChecker(FaultChecker):
869 """Base class for fault checkers that check for a single occurence of a
870 faulty condition.
871
872 Child classes should implement the following functions:
873 - isCondition(self, flight, aircraft, oldState, state): should return whether the
874 condition holds
875 - logFault(self, flight, aircraft, logger, oldState, state): log the fault
876 via the logger."""
877 def check(self, flight, aircraft, logger, oldState, state):
878 """Perform the check."""
879 if self.isCondition(flight, aircraft, oldState, state):
880 self.logFault(flight, aircraft, logger, oldState, state)
881
882#---------------------------------------------------------------------------------------
883
884class PatientFaultChecker(FaultChecker):
885 """A fault checker that does not decides on a fault when the condition
886 arises immediately, but can wait some time.
887
888 Child classes should implement the following functions:
889 - isCondition(self, flight, aircraft, oldState, state): should return whether the
890 condition holds
891 - logFault(self, flight, aircraft, logger, oldState, state): log the fault
892 via the logger
893 """
894 def __init__(self, timeout = 2.0):
895 """Construct the fault checker with the given timeout."""
896 self._timeout = timeout
897 self._faultStarted = None
898
899 def getTimeout(self, flight, aircraft, oldState, state):
900 """Get the timeout.
901
902 This default implementation returns the timeout given in the
903 constructor, but child classes might want to enforce a different
904 policy."""
905 return self._timeout
906
907 def check(self, flight, aircraft, logger, oldState, state):
908 """Perform the check."""
909 if self.isCondition(flight, aircraft, oldState, state):
910 if self._faultStarted is None:
911 self._faultStarted = state.timestamp
912 timeout = self.getTimeout(flight, aircraft, oldState, state)
913 if state.timestamp>=(self._faultStarted + timeout):
914 self.logFault(flight, aircraft, logger, oldState, state)
915 self._faultStarted = state.timestamp
916 else:
917 self._faultStarted = None
918
919#---------------------------------------------------------------------------------------
920
921class AntiCollisionLightsChecker(PatientFaultChecker):
922 """Check for the anti-collision light being off at high N1 values."""
923 def isCondition(self, flight, aircraft, oldState, state):
924 """Check if the fault condition holds."""
925 return (not flight.config.usingFS2Crew or not state.parking or
926 flight.stage!=const.STAGE_TAXIAFTERLAND) and \
927 not state.antiCollisionLightsOn and \
928 self.isEngineCondition(state)
929
930 def logFault(self, flight, aircraft, logger, oldState, state):
931 """Log the fault."""
932 flight.handleFault(AntiCollisionLightsChecker, state.timestamp,
933 FaultChecker._appendDuring(flight,
934 "Anti-collision lights were off"),
935 1)
936
937 def isEngineCondition(self, state):
938 """Determine if the engines are in such a state that the lights should
939 be on."""
940 if state.n1 is not None:
941 return max(state.n1)>5
942 elif state.rpm is not None:
943 return max(state.rpm)>0
944 else:
945 return False
946
947#---------------------------------------------------------------------------------------
948
949class TupolevAntiCollisionLightsChecker(AntiCollisionLightsChecker):
950 """Check for the anti-collision light for Tuplev planes."""
951 def isCondition(self, flight, aircraft, oldState, state):
952 """Check if the fault condition holds."""
953 numEnginesRunning = 0
954 for n1 in state.n1:
955 if n1>5: numEnginesRunning += 1
956
957 print "TupolevAntiCollisionLightsChecker: n1", state.n1,
958 print ", numEnginesRunning:", numEnginesRunning,
959 print ", stage:", flight.stage,
960 print ", antiCollisionLightsOn:", state.antiCollisionLightsOn,
961 print ", parking:", state.parking,
962 print
963
964 if flight.stage==const.STAGE_PARKING or \
965 (flight.stage==const.STAGE_TAXIAFTERLAND and state.parking):
966 return numEnginesRunning<len(state.n1) \
967 and state.antiCollisionLightsOn
968 else:
969 return numEnginesRunning>1 and not state.antiCollisionLightsOn or \
970 numEnginesRunning<1 and state.antiCollisionLightsOn
971
972#---------------------------------------------------------------------------------------
973
974class BankChecker(SimpleFaultChecker):
975 """Check for the bank is within limits."""
976 def isCondition(self, flight, aircraft, oldState, state):
977 """Check if the fault condition holds."""
978 if flight.stage==const.STAGE_CRUISE:
979 isDH8DXplane = flight.aircraftType==const.AIRCRAFT_DH8D and \
980 (flight.fsType==const.SIM_XPLANE10 or
981 flight.fsType==const.SIM_XPLANE9)
982 bankLimit = 35 if isDH8DXplane else 30
983 elif flight.stage in [const.STAGE_TAKEOFF, const.STAGE_CLIMB,
984 const.STAGE_DESCENT, const.STAGE_LANDING]:
985 bankLimit = 35
986 else:
987 return False
988
989 return state.bank>bankLimit or state.bank<-bankLimit
990
991 def logFault(self, flight, aircraft, logger, oldState, state):
992 """Log the fault."""
993 message = "Bank too steep (%.1f)" % (state.bank,)
994 flight.handleFault(BankChecker, state.timestamp,
995 FaultChecker._appendDuring(flight, message),
996 2)
997
998#---------------------------------------------------------------------------------------
999
1000class FlapsRetractChecker(SimpleFaultChecker):
1001 """Check if the flaps are not retracted too early."""
1002 def __init__(self):
1003 """Construct the flaps checker."""
1004 self._timeStart = None
1005
1006 def isCondition(self, flight, aircraft, oldState, state):
1007 """Check if the fault condition holds.
1008
1009 FIXME: check if this really is the intention (FlapsRetractedMistake.java)"""
1010 if (flight.stage==const.STAGE_TAKEOFF and not state.onTheGround and
1011 aircraft.type!=const.AIRCRAFT_F70) or \
1012 (flight.stage==const.STAGE_LANDING and state.onTheGround):
1013 if self._timeStart is None:
1014 self._timeStart = state.timestamp
1015
1016 if state.flapsSet==0 and state.timestamp<=(self._timeStart+2.0):
1017 return True
1018 else:
1019 self._timeStart = None
1020 return False
1021
1022 def logFault(self, flight, aircraft, logger, oldState, state):
1023 """Log the fault."""
1024 flight.handleFault(FlapsRetractChecker, state.timestamp,
1025 FaultChecker._appendDuring(flight, "Flaps retracted"),
1026 20)
1027
1028#---------------------------------------------------------------------------------------
1029
1030class FlapsSpeedLimitChecker(SimpleFaultChecker):
1031 """Check if the flaps are extended only at the right speeds."""
1032 def isCondition(self, flight, aircraft, oldState, state):
1033 """Check if the fault condition holds."""
1034 speedLimit = aircraft.getFlapsSpeedLimit(state.flapsSet)
1035 return speedLimit is not None and state.smoothedIAS>speedLimit
1036
1037 def logFault(self, flight, aircraft, logger, oldState, state):
1038 """Log the fault."""
1039 flight.handleFault(FlapsSpeedLimitChecker, state.timestamp,
1040 FaultChecker._appendDuring(flight, "Flap speed limit fault"),
1041 5)
1042
1043#---------------------------------------------------------------------------------------
1044
1045class GearsDownChecker(SimpleFaultChecker):
1046 """Check if the gears are down at low altitudes."""
1047 def isCondition(self, flight, aircraft, oldState, state):
1048 """Check if the fault condition holds."""
1049 return state.radioAltitude<10 and not state.gearsDown and \
1050 flight.stage!=const.STAGE_TAKEOFF
1051
1052 def logFault(self, flight, aircraft, logger, oldState, state):
1053 """Log the fault."""
1054 flight.handleNoGo(GearsDownChecker, state.timestamp,
1055 "Gears not down at %.0f feet radio altitude" % \
1056 (state.radioAltitude,),
1057 "GEAR DOWN NO GO")
1058
1059#---------------------------------------------------------------------------------------
1060
1061class GearSpeedLimitChecker(PatientFaultChecker):
1062 """Check if the gears not down at too high a speed."""
1063 def isCondition(self, flight, aircraft, oldState, state):
1064 """Check if the fault condition holds."""
1065 return state.gearsDown and state.smoothedIAS>aircraft.gearSpeedLimit
1066
1067 def logFault(self, flight, aircraft, logger, oldState, state):
1068 """Log the fault."""
1069 flight.handleFault(GearSpeedLimitChecker, state.timestamp,
1070 FaultChecker._appendDuring(flight, "Gear speed limit fault"),
1071 5)
1072
1073#---------------------------------------------------------------------------------------
1074
1075class GLoadChecker(SimpleFaultChecker):
1076 """Check if the G-load does not exceed 2 except during flare."""
1077 def isCondition(self, flight, aircraft, oldState, state):
1078 """Check if the fault condition holds."""
1079 return state.gLoad>2.0 and not state.onTheGround and \
1080 (flight.stage!=const.STAGE_LANDING or state.radioAltitude>=50)
1081
1082 def logFault(self, flight, aircraft, logger, oldState, state):
1083 """Log the fault."""
1084 flight.handleFault(GLoadChecker, state.timestamp,
1085 "G-load was %.2f" % (state.gLoad,),
1086 10)
1087
1088#---------------------------------------------------------------------------------------
1089
1090class LandingLightsChecker(PatientFaultChecker):
1091 """Check if the landing lights are used properly."""
1092 def getTimeout(self, flight, aircraft, oldState, state):
1093 """Get the timeout.
1094
1095 It is the default timeout except for landing and takeoff."""
1096 return 0.0 if flight.stage in [const.STAGE_TAKEOFF,
1097 const.STAGE_LANDING] else self._timeout
1098
1099 def isCondition(self, flight, aircraft, oldState, state):
1100 """Check if the fault condition holds."""
1101 return state.landingLightsOn is not None and \
1102 ((flight.stage==const.STAGE_BOARDING and \
1103 state.landingLightsOn and state.onTheGround) or \
1104 (flight.stage==const.STAGE_TAKEOFF and \
1105 not state.landingLightsOn and not state.onTheGround) or \
1106 (flight.stage in [const.STAGE_CLIMB, const.STAGE_CRUISE,
1107 const.STAGE_DESCENT] and \
1108 state.landingLightsOn and state.altitude>12500) or \
1109 (flight.stage==const.STAGE_LANDING and \
1110 not state.landingLightsOn and state.onTheGround and
1111 state.groundSpeed>50.0) or \
1112 (flight.stage==const.STAGE_PARKING and \
1113 state.landingLightsOn and state.onTheGround))
1114
1115 def logFault(self, flight, aircraft, logger, oldState, state):
1116 """Log the fault."""
1117 score = 0 if flight.stage in [const.STAGE_TAKEOFF,
1118 const.STAGE_LANDING] else 1
1119 message = "Landing lights were %s" % \
1120 (("on" if state.landingLightsOn else "off"),)
1121 flight.handleFault(LandingLightsChecker, state.timestamp,
1122 FaultChecker._appendDuring(flight, message),
1123 score)
1124
1125#---------------------------------------------------------------------------------------
1126
1127class TransponderChecker(PatientFaultChecker):
1128 """Check if the transponder is used properly."""
1129 def __init__(self):
1130 """Construct the transponder checker."""
1131 super(TransponderChecker, self).__init__()
1132 self._liftOffTime = None
1133
1134 def isCondition(self, flight, aircraft, oldState, state):
1135 """Check if the fault condition holds."""
1136 if state.onTheGround:
1137 self._liftOffTime = None
1138 elif self._liftOffTime is None:
1139 self._liftOffTime = state.timestamp
1140
1141 return state.xpdrC is not None and \
1142 ((state.xpdrC and flight.stage in
1143 [const.STAGE_BOARDING, const.STAGE_PARKING]) or \
1144 (not state.xpdrC and
1145 (flight.stage in
1146 [const.STAGE_CRUISE, const.STAGE_DESCENT,
1147 const.STAGE_GOAROUND] or \
1148 (flight.stage==const.STAGE_LANDING and
1149 state.groundSpeed>50.0) or \
1150 ((not state.autoXPDR or \
1151 (self._liftOffTime is not None and
1152 state.timestamp > (self._liftOffTime+8))) and \
1153 ((flight.stage==const.STAGE_TAKEOFF and
1154 not state.onTheGround) or flight.stage==const.STAGE_CLIMB))
1155 )
1156 )
1157 )
1158
1159 def logFault(self, flight, aircraft, logger, oldState, state):
1160 """Log the fault."""
1161 score = 0
1162 message = "Transponder was %s" % \
1163 (("mode C" if state.xpdrC else "standby"),)
1164 flight.handleFault(TransponderChecker, state.timestamp,
1165 FaultChecker._appendDuring(flight, message),
1166 score)
1167
1168#---------------------------------------------------------------------------------------
1169
1170class WeightChecker(PatientFaultChecker):
1171 """Base class for checkers that check that some limit is not exceeded."""
1172 def __init__(self, name):
1173 """Construct the checker."""
1174 super(WeightChecker, self).__init__(timeout = 5.0)
1175 self._name = name
1176
1177 def isCondition(self, flight, aircraft, oldState, state):
1178 """Check if the fault condition holds."""
1179 if flight.entranceExam:
1180 return False
1181
1182 limit = self.getLimit(flight, aircraft, state)
1183 if limit is not None:
1184 #if flight.options.compensation is not None:
1185 # limit += flight.options.compensation
1186 return self.getWeight(state)>limit
1187
1188 return False
1189
1190 def logFault(self, flight, aircraft, logger, oldState, state):
1191 """Log the fault."""
1192 mname = "M" + self._name
1193 flight.handleNoGo(self.__class__, state.timestamp,
1194 "%s exceeded: %s is %.0f kg" % \
1195 (mname, self._name, self.getWeight(state)),
1196 "%s NO GO" % (mname,))
1197
1198 def getWeight(self, state):
1199 """Get the weight that is interesting for us."""
1200 return state.grossWeight
1201
1202#---------------------------------------------------------------------------------------
1203
1204class MLWChecker(WeightChecker):
1205 """Checks if the MLW is not exceeded on landing."""
1206 def __init__(self):
1207 """Construct the checker."""
1208 super(MLWChecker, self).__init__("LW")
1209
1210 def getLimit(self, flight, aircraft, state):
1211 """Get the limit if we are in the right state."""
1212 return aircraft.mlw if flight.stage==const.STAGE_LANDING and \
1213 state.onTheGround and \
1214 not flight.entranceExam else None
1215
1216#---------------------------------------------------------------------------------------
1217
1218class MTOWChecker(WeightChecker):
1219 """Checks if the MTOW is not exceeded on landing."""
1220 def __init__(self):
1221 """Construct the checker."""
1222 super(MTOWChecker, self).__init__("TOW")
1223
1224 def getLimit(self, flight, aircraft, state):
1225 """Get the limit if we are in the right state."""
1226 return aircraft.mtow if flight.stage==const.STAGE_TAKEOFF and \
1227 not flight.entranceExam else None
1228
1229#---------------------------------------------------------------------------------------
1230
1231class MZFWChecker(WeightChecker):
1232 """Checks if the MZFW is not exceeded on landing."""
1233 def __init__(self):
1234 """Construct the checker."""
1235 super(MZFWChecker, self).__init__("ZFW")
1236
1237 def getLimit(self, flight, aircraft, state):
1238 """Get the limit if we are in the right state."""
1239 return aircraft.mzfw if not flight.entranceExam else None
1240
1241 def getWeight(self, state):
1242 """Get the weight that is interesting for us."""
1243 return state.zfw
1244
1245#---------------------------------------------------------------------------------------
1246
1247class NavLightsChecker(PatientFaultChecker):
1248 """Check if the navigational lights are used properly."""
1249 def isCondition(self, flight, aircraft, oldState, state):
1250 """Check if the fault condition holds."""
1251 return flight.stage!=const.STAGE_BOARDING and \
1252 flight.stage!=const.STAGE_PARKING and \
1253 state.navLightsOn is False
1254
1255 def logFault(self, flight, aircraft, logger, oldState, state):
1256 """Log the fault."""
1257 flight.handleFault(NavLightsChecker, state.timestamp,
1258 FaultChecker._appendDuring(flight,
1259 "Navigation lights were off"),
1260 1)
1261
1262#---------------------------------------------------------------------------------------
1263
1264class OverspeedChecker(PatientFaultChecker):
1265 """Check if Vne has been exceeded."""
1266 def __init__(self, timeout = 30.0):
1267 """Construct the checker."""
1268 super(OverspeedChecker, self).__init__(timeout = timeout)
1269
1270 def isCondition(self, flight, aircraft, oldState, state):
1271 """Check if the fault condition holds."""
1272 return state.overspeed
1273
1274 def logFault(self, flight, aircraft, logger, oldState, state):
1275 """Log the fault."""
1276 flight.handleFault(OverspeedChecker, state.timestamp,
1277 FaultChecker._appendDuring(flight, "Overspeed"),
1278 20)
1279
1280#---------------------------------------------------------------------------------------
1281
1282class PayloadChecker(SimpleFaultChecker):
1283 """Check if the payload matches the specification."""
1284 TOLERANCE=550
1285
1286 @staticmethod
1287 def isZFWFaulty(aircraftZFW, flightZFW):
1288 """Check if the given aircraft's ZFW is outside of the limits."""
1289 return aircraftZFW < (flightZFW - PayloadChecker.TOLERANCE) or \
1290 aircraftZFW > (flightZFW + PayloadChecker.TOLERANCE)
1291
1292 def isCondition(self, flight, aircraft, oldState, state):
1293 """Check if the fault condition holds."""
1294 return not flight.entranceExam and \
1295 flight.stage==const.STAGE_PUSHANDTAXI and \
1296 PayloadChecker.isZFWFaulty(state.zfw, flight.zfw)
1297
1298 def logFault(self, flight, aircraft, logger, oldState, state):
1299 """Log the fault."""
1300 flight.handleNoGo(PayloadChecker, state.timestamp,
1301 "ZFW difference is more than %d kgs" % \
1302 (PayloadChecker.TOLERANCE,),
1303 "ZFW NO GO")
1304
1305#---------------------------------------------------------------------------------------
1306
1307class PitotChecker(PatientFaultChecker):
1308 """Check if pitot heat is on."""
1309 def __init__(self):
1310 """Construct the checker."""
1311 super(PitotChecker, self).__init__(timeout = 3.0)
1312
1313 def isCondition(self, flight, aircraft, oldState, state):
1314 """Check if the fault condition holds."""
1315 return state.groundSpeed>80 and not state.pitotHeatOn
1316
1317 def logFault(self, flight, aircraft, logger, oldState, state):
1318 """Log the fault."""
1319 score = 2 if flight.stage in [const.STAGE_TAKEOFF, const.STAGE_CLIMB,
1320 const.STAGE_CRUISE, const.STAGE_DESCENT,
1321 const.STAGE_LANDING] else 0
1322 flight.handleFault(PitotChecker, state.timestamp,
1323 FaultChecker._appendDuring(flight, "Pitot heat was off"),
1324 score)
1325
1326#---------------------------------------------------------------------------------------
1327
1328class ReverserChecker(SimpleFaultChecker):
1329 """Check if the reverser is not used below the speed prescribed for the
1330 aircraft."""
1331 def isCondition(self, flight, aircraft, oldState, state):
1332 """Check if the fault condition holds."""
1333 return flight.stage in [const.STAGE_DESCENT, const.STAGE_LANDING,
1334 const.STAGE_TAXIAFTERLAND] and \
1335 state.reverser and \
1336 state.groundSpeed<aircraft.reverseMinSpeed and max(state.reverser)
1337
1338 def logFault(self, flight, aircraft, logger, oldState, state):
1339 """Log the fault."""
1340 message = "Reverser used below %.0f %s" % \
1341 (flight.speedFromKnots(60), flight.getEnglishSpeedUnit())
1342 flight.handleFault(ReverserChecker, state.timestamp,
1343 FaultChecker._appendDuring(flight, message),
1344 15)
1345
1346#---------------------------------------------------------------------------------------
1347
1348class SpeedChecker(SimpleFaultChecker):
1349 """Check if the speed is in the prescribed limits."""
1350 @staticmethod
1351 def needNoStrobe(aircraft, state):
1352 """Determine if the given aircraft and state needs a strobeless speed
1353 checking."""
1354 return aircraft.needNoStrobeSpeedCheck or \
1355 (state.strobeLightsOn is None and state.xpdrC is None)
1356
1357 @staticmethod
1358 def logSpeedFault(flight, state, stage = None, updateID = None):
1359 """Log the speed fault."""
1360 message = "Taxi speed over %.0f %s" % \
1361 (flight.speedFromKnots(50), flight.getEnglishSpeedUnit())
1362 if stage is None:
1363 stage = flight.stage
1364 score = FaultChecker._getLinearScore(50, 80, 10, 15, state.groundSpeed)
1365 return flight.handleFault((SpeedChecker, stage), state.timestamp,
1366 FaultChecker._appendDuring(flight, message),
1367 score, updatePrevious = updateID is None,
1368 updateID = updateID)
1369
1370 def isCondition(self, flight, aircraft, oldState, state):
1371 """Check if the fault condition holds."""
1372 return not self.needNoStrobe(aircraft, state) and \
1373 flight.stage in [const.STAGE_PUSHANDTAXI,
1374 const.STAGE_RTO,
1375 const.STAGE_TAXIAFTERLAND] and \
1376 state.groundSpeed>50
1377
1378 def logFault(self, flight, aircraft, logger, oldState, state):
1379 """Log the fault."""
1380 self.logSpeedFault(flight, state)
1381
1382#---------------------------------------------------------------------------------------
1383
1384class NoStrobeSpeedChecker(StateChecker):
1385 """Checker for the ground speed of aircraft that have no strobe lights by
1386 which to detect the takeoff stage.
1387
1388 If, during the PUSHANDTAXI stage the speed exceeds 50 knots, the state as
1389 saved as a provisional takeoff state. If the speed then decreases below 50
1390 knots, or the plane remains on the ground for more than 40 seconds, a taxi
1391 speed error is logged with the highest ground speed detected. This state is
1392 also stored in the flight object as a possible
1393
1394 If the plane becomes airborne within 40 seconds, the stage becomes TAKEOFF,
1395 and the previously saved takeoff state is logged.
1396
1397 During the TAXIAFTERLAND stage, speed is checked as in case of
1398 SpeedChecker."""
1399 def __init__(self):
1400 """Initialize the speed checker."""
1401 self._takeoffState = None
1402 self._highestSpeedState = None
1403
1404 def check(self, flight, aircraft, logger, oldState, state):
1405 """Check the state as described above."""
1406 if SpeedChecker.needNoStrobe(aircraft, state):
1407 if flight.stage==const.STAGE_PUSHANDTAXI or \
1408 flight.stage==const.STAGE_RTO:
1409 self._checkPushAndTaxi(flight, aircraft, state)
1410 elif flight.stage==const.STAGE_TAXIAFTERLAND:
1411 if state.groundSpeed>50:
1412 SpeedChecker.logSpeedFault(flight, state)
1413 else:
1414 self._takeoffState = None
1415
1416 def _checkPushAndTaxi(self, flight, aircraft, state):
1417 """Check the speed during the push and taxi stage."""
1418 if state.groundSpeed>50:
1419 if self._takeoffState is None:
1420 self._takeoffState = state
1421 self._highestSpeedState = state
1422 else:
1423 if state.groundSpeed>self._highestSpeedState.groundSpeed:
1424 self._highestSpeedState = state
1425
1426 if not state.onTheGround:
1427 aircraft.setStage(self._takeoffState, const.STAGE_TAKEOFF)
1428 self._takeoffState = None
1429 elif state.timestamp > (self._takeoffState.timestamp + 40):
1430 flight.setRTOState(self._highestSpeedState)
1431 elif self._takeoffState is not None:
1432 flight.setRTOState(self._highestSpeedState)
1433 self._takeoffState = None
1434
1435#---------------------------------------------------------------------------------------
1436
1437class StallChecker(PatientFaultChecker):
1438 """Check if stall occured."""
1439 def isCondition(self, flight, aircraft, oldState, state):
1440 """Check if the fault condition holds."""
1441 return flight.stage in [const.STAGE_TAKEOFF, const.STAGE_CLIMB,
1442 const.STAGE_CRUISE, const.STAGE_DESCENT,
1443 const.STAGE_LANDING] and state.stalled
1444
1445 def logFault(self, flight, aircraft, logger, oldState, state):
1446 """Log the fault."""
1447 score = 40 if flight.stage in [const.STAGE_TAKEOFF,
1448 const.STAGE_LANDING] else 30
1449 flight.handleFault(StallChecker, state.timestamp,
1450 FaultChecker._appendDuring(flight, "Stalled"),
1451 score)
1452
1453#---------------------------------------------------------------------------------------
1454
1455class StrobeLightsChecker(PatientFaultChecker):
1456 """Check if the strobe lights are used properly."""
1457 def isCondition(self, flight, aircraft, oldState, state):
1458 """Check if the fault condition holds."""
1459 return state.strobeLightsOn is not None and \
1460 ((flight.stage==const.STAGE_BOARDING and \
1461 state.strobeLightsOn and state.onTheGround) or \
1462 (flight.stage==const.STAGE_TAKEOFF and \
1463 not state.strobeLightsOn and not state.gearsDown) or \
1464 (flight.stage in [const.STAGE_CLIMB, const.STAGE_CRUISE,
1465 const.STAGE_DESCENT] and \
1466 not state.strobeLightsOn and not state.onTheGround) or \
1467 (flight.stage==const.STAGE_PARKING and \
1468 state.strobeLightsOn and state.onTheGround))
1469
1470 def logFault(self, flight, aircraft, logger, oldState, state):
1471 """Log the fault."""
1472 message = "Strobe lights were %s" % (("on" if state.strobeLightsOn else "off"),)
1473 flight.handleFault(StrobeLightsChecker, state.timestamp,
1474 FaultChecker._appendDuring(flight, message),
1475 1)
1476
1477#---------------------------------------------------------------------------------------
1478
1479class ThrustChecker(SimpleFaultChecker):
1480 """Check if the thrust setting is not too high during takeoff.
1481
1482 FIXME: is this really so general, for all aircraft?"""
1483 def isCondition(self, flight, aircraft, oldState, state):
1484 """Check if the fault condition holds."""
1485 return flight.stage==const.STAGE_TAKEOFF and \
1486 state.n1 is not None and max(state.n1)>97
1487
1488 def logFault(self, flight, aircraft, logger, oldState, state):
1489 """Log the fault."""
1490 flight.handleFault(ThrustChecker, state.timestamp,
1491 FaultChecker._appendDuring(flight,
1492 "Thrust setting was too high (>97%)"),
1493 FaultChecker._getLinearScore(97, 110, 0, 10,
1494 max(state.n1)),
1495 updatePrevious = True)
1496
1497#---------------------------------------------------------------------------------------
1498
1499class VSChecker(SimpleFaultChecker):
1500 """Check if the vertical speed is not too low at certain altitudes"""
1501 BELOW10000 = -5000
1502 BELOW5000 = -2500
1503 BELOW2500 = -1500
1504 BELOW500 = -1000
1505 TOLERANCE = 1.2
1506
1507 def isCondition(self, flight, aircraft, oldState, state):
1508 """Check if the fault condition holds."""
1509 vs = state.smoothedVS
1510 altitude = state.altitude
1511 return vs < -8000 or vs > 8000 or \
1512 (altitude<500 and vs < (VSChecker.BELOW500 *
1513 VSChecker.TOLERANCE)) or \
1514 (altitude<2500 and vs < (VSChecker.BELOW2500 *
1515 VSChecker.TOLERANCE)) or \
1516 (altitude<5000 and vs < (VSChecker.BELOW5000 *
1517 VSChecker.TOLERANCE)) or \
1518 (altitude<10000 and vs < (VSChecker.BELOW10000 *
1519 VSChecker.TOLERANCE))
1520
1521 def logFault(self, flight, aircraft, logger, oldState, state):
1522 """Log the fault."""
1523 vs = state.smoothedVS
1524
1525 message = "Vertical speed was %.0f feet/min" % (vs,)
1526 if vs>-8000 and vs<8000:
1527 message += " at %.0f feet (exceeds company limit)" % (state.altitude,)
1528
1529 score = 10 if vs<-8000 or vs>8000 else 0
1530
1531 flight.handleFault(VSChecker, state.timestamp,
1532 FaultChecker._appendDuring(flight, message),
1533 score)
1534
1535#---------------------------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.