source: src/mlx/fsuipc.py@ 58:740f690a053f

Last change on this file since 58:740f690a053f was 51:f0f99ac21935, checked in by István Váradi <ivaradi@…>, 13 years ago

Fleet retrieval and gate selection works, started new connection handling and the fsuipc simulator
File size: 47.2 KB
Line 
1# Module handling the connection to FSUIPC
2
3#------------------------------------------------------------------------------
4
5import fs
6import const
7import util
8
9import threading
10import os
11import time
12import calendar
13import sys
14import codecs
15
16if os.name == "nt":
17 import pyuipc
18else:
19 import pyuipc_sim as pyuipc
20
21#------------------------------------------------------------------------------
22
23class Handler(threading.Thread):
24 """The thread to handle the FSUIPC requests."""
25 @staticmethod
26 def fsuipc2VS(data):
27 """Convert the given vertical speed data read from FSUIPC into feet/min."""
28 return data*60.0/const.FEETTOMETRES/256.0
29
30 @staticmethod
31 def fsuipc2radioAltitude(data):
32 """Convert the given radio altitude data read from FSUIPC into feet."""
33 return data/const.FEETTOMETRES/65536.0
34
35 @staticmethod
36 def fsuipc2Degrees(data):
37 """Convert the given data into degrees."""
38 return data * 360.0 / 65536.0 / 65536.0
39
40 @staticmethod
41 def fsuipc2PositiveDegrees(data):
42 """Convert the given data into positive degrees."""
43 degrees = Handler.fsuipc2Degrees(data)
44 if degrees<0.0: degrees += 360.0
45 return degrees
46
47 @staticmethod
48 def fsuipc2IAS(data):
49 """Convert the given data into indicated airspeed."""
50 return data / 128.0
51
52 @staticmethod
53 def _callSafe(fun):
54 """Call the given function and swallow any exceptions."""
55 try:
56 return fun()
57 except Exception, e:
58 print >> sys.stderr, str(e)
59 return None
60
61 NUM_READATTEMPTS = 3
62
63 @staticmethod
64 def _performRead(data, callback, extra, validator):
65 """Perform a read request.
66
67 If there is a validator, that will be called with the return values,
68 and if the values are wrong, the request is retried at most a certain
69 number of times.
70
71 Return True if the request has succeeded, False if validation has
72 failed during all attempts. An exception may also be thrown if there is
73 some lower-level communication problem."""
74 attemptsLeft = Handler.NUM_READATTEMPTS
75 while attemptsLeft>0:
76 values = pyuipc.read(data)
77 if validator is None or \
78 Handler._callSafe(lambda: validator(values, extra)):
79 Handler._callSafe(lambda: callback(values, extra))
80 return True
81 else:
82 attemptsLeft -= 1
83 return False
84
85 class Request(object):
86 """A simple, one-shot request."""
87 def __init__(self, forWrite, data, callback, extra, validator = None):
88 """Construct the request."""
89 self._forWrite = forWrite
90 self._data = data
91 self._callback = callback
92 self._extra = extra
93 self._validator = validator
94
95 def process(self, time):
96 """Process the request.
97
98 Return True if the request has succeeded, False if data validation
99 has failed for a reading request. An exception may also be thrown
100 if there is some lower-level communication problem."""
101 if self._forWrite:
102 pyuipc.write(self._data)
103 Handler._callSafe(lambda: self._callback(True, self._extra))
104 return True
105 else:
106 return Handler._performRead(self._data, self._callback,
107 self._extra, self._validator)
108
109 def fail(self):
110 """Handle the failure of this request."""
111 if self._forWrite:
112 Handler._callSafe(lambda: self._callback(False, self._extra))
113 else:
114 Handler._callSafe(lambda: self._callback(None, self._extra))
115
116 class PeriodicRequest(object):
117 """A periodic request."""
118 def __init__(self, id, period, data, callback, extra, validator):
119 """Construct the periodic request."""
120 self._id = id
121 self._period = period
122 self._nextFire = time.time() + period
123 self._data = data
124 self._preparedData = None
125 self._callback = callback
126 self._extra = extra
127 self._validator = validator
128
129 @property
130 def id(self):
131 """Get the ID of this periodic request."""
132 return self._id
133
134 @property
135 def nextFire(self):
136 """Get the next firing time."""
137 return self._nextFire
138
139 def process(self, time):
140 """Check if this request should be executed, and if so, do so.
141
142 time is the time at which the request is being executed. If this
143 function is called too early, nothing is done, and True is
144 returned.
145
146 Return True if the request has succeeded, False if data validation
147 has failed. An exception may also be thrown if there is some
148 lower-level communication problem."""
149 if time<self._nextFire:
150 return True
151
152 if self._preparedData is None:
153 self._preparedData = pyuipc.prepare_data(self._data)
154 self._data = None
155
156 isOK = Handler._performRead(self._preparedData, self._callback,
157 self._extra, self._validator)
158
159 if isOK:
160 while self._nextFire <= time:
161 self._nextFire += self._period
162
163 return isOK
164
165 def fail(self):
166 """Handle the failure of this request."""
167 pass
168
169 def __cmp__(self, other):
170 """Compare two periodic requests. They are ordered by their next
171 firing times."""
172 return cmp(self._nextFire, other._nextFire)
173
174 def __init__(self, connectionListener):
175 """Construct the handler with the given connection listener."""
176 threading.Thread.__init__(self)
177
178 self._connectionListener = connectionListener
179
180 self._requestCondition = threading.Condition()
181 self._connectionRequested = False
182 self._connected = False
183
184 self._requests = []
185 self._nextPeriodicID = 1
186 self._periodicRequests = []
187
188 self.daemon = True
189
190 def requestRead(self, data, callback, extra = None, validator = None):
191 """Request the reading of some data.
192
193 data is a list of tuples of the following items:
194 - the offset of the data as an integer
195 - the type letter of the data as a string
196
197 callback is a function that receives two pieces of data:
198 - the values retrieved or None on error
199 - the extra parameter
200
201 It will be called in the handler's thread!
202 """
203 with self._requestCondition:
204 self._requests.append(Handler.Request(False, data, callback, extra,
205 validator))
206 self._requestCondition.notify()
207
208 def requestWrite(self, data, callback, extra = None):
209 """Request the writing of some data.
210
211 data is a list of tuples of the following items:
212 - the offset of the data as an integer
213 - the type letter of the data as a string
214 - the data to write
215
216 callback is a function that receives two pieces of data:
217 - a boolean indicating if writing was successful
218 - the extra data
219 It will be called in the handler's thread!
220 """
221 with self._requestCondition:
222 self._requests.append(Handler.Request(True, data, callback, extra))
223 self._requestCondition.notify()
224
225 @staticmethod
226 def _readWriteCallback(data, extra):
227 """Callback for the read() and write() calls below."""
228 extra.append(data)
229 with extra[0] as condition:
230 condition.notify()
231
232 def requestPeriodicRead(self, period, data, callback, extra = None,
233 validator = None):
234 """Request a periodic read of data.
235
236 period is a floating point number with the period in seconds.
237
238 This function returns an identifier which can be used to cancel the
239 request."""
240 with self._requestCondition:
241 id = self._nextPeriodicID
242 self._nextPeriodicID += 1
243 request = Handler.PeriodicRequest(id, period, data, callback,
244 extra, validator)
245 self._periodicRequests.append(request)
246 self._requestCondition.notify()
247 return id
248
249 def clearPeriodic(self, id):
250 """Clear the periodic request with the given ID."""
251 with self._requestCondition:
252 for i in range(0, len(self._periodicRequests)):
253 if self._periodicRequests[i].id==id:
254 del self._periodicRequests[i]
255 return True
256 return False
257
258 def connect(self):
259 """Initiate the connection to the flight simulator."""
260 with self._requestCondition:
261 if not self._connectionRequested:
262 self._connectionRequested = True
263 self._requestCondition.notify()
264
265 def disconnect(self):
266 """Disconnect from the flight simulator."""
267 with self._requestCondition:
268 if self._connectionRequested:
269 self._connectionRequested = False
270 self._requestCondition.notify()
271
272 def run(self):
273 """Perform the operation of the thread."""
274 while True:
275 self._waitConnectionRequest()
276
277 if self._connect():
278 self._handleConnection()
279
280 self._disconnect()
281
282 def _waitConnectionRequest(self):
283 """Wait for a connection request to arrive."""
284 with self._requestCondition:
285 while not self._connectionRequested:
286 self._requestCondition.wait()
287
288 def _connect(self):
289 """Try to connect to the flight simulator via FSUIPC
290
291 Returns True if the connection has been established, False if it was
292 not due to no longer requested.
293 """
294 while self._connectionRequested:
295 try:
296 pyuipc.open(pyuipc.SIM_ANY)
297 description = "(FSUIPC version: 0x%04x, library version: 0x%04x, FS version: %d)" % \
298 (pyuipc.fsuipc_version, pyuipc.lib_version,
299 pyuipc.fs_version)
300 Handler._callSafe(lambda:
301 self._connectionListener.connected(const.SIM_MSFS9,
302 description))
303 self._connected = True
304 return True
305 except Exception, e:
306 print "fsuipc.Handler._connect: connection failed: " + str(e)
307 time.sleep(0.1)
308
309 return False
310
311 def _handleConnection(self):
312 """Handle a living connection."""
313 with self._requestCondition:
314 while self._connectionRequested:
315 self._processRequests()
316 self._waitRequest()
317
318 def _waitRequest(self):
319 """Wait for the time of the next request.
320
321 Returns also, if the connection is no longer requested.
322
323 Should be called with the request condition lock held."""
324 while self._connectionRequested:
325 timeout = None
326 if self._periodicRequests:
327 self._periodicRequests.sort()
328 timeout = self._periodicRequests[0].nextFire - time.time()
329
330 if timeout is not None and timeout <= 0.0:
331 return
332
333 self._requestCondition.wait(timeout)
334
335 def _disconnect(self):
336 """Disconnect from the flight simulator."""
337 if self._connected:
338 pyuipc.close()
339 Handler._callSafe(lambda: self._connectionListener.disconnected())
340 self._connected = False
341
342 def _failRequests(self, request):
343 """Fail the outstanding, single-shot requuests."""
344 request.fail()
345 with self._requestCondition:
346 for request in self._requests:
347 try:
348 self._requestCondition.release()
349 request.fail()
350 finally:
351 self._requestCondition.acquire()
352 self._requests = []
353
354 def _processRequest(self, request, time):
355 """Process the given request.
356
357 If an exception occurs or invalid data is read too many times, we try
358 to reconnect.
359
360 This function returns only if the request has succeeded, or if a
361 connection is no longer requested.
362
363 This function is called with the request lock held, but is relased
364 whole processing the request and reconnecting."""
365 self._requestCondition.release()
366
367 needReconnect = False
368 try:
369 try:
370 if not request.process(time):
371 print "fsuipc.Handler._processRequest: FSUIPC returned invalid data too many times, reconnecting"
372 needReconnect = True
373 except Exception as e:
374 print "fsuipc.Handler._processRequest: FSUIPC connection failed (" + \
375 str(e) + "), reconnecting."
376 needReconnect = True
377
378 if needReconnect:
379 self._disconnect()
380 self._failRequests(request)
381 self._connect()
382 finally:
383 self._requestCondition.acquire()
384
385 def _processRequests(self):
386 """Process any pending requests.
387
388 Will be called with the request lock held."""
389 while self._connectionRequested and self._periodicRequests:
390 self._periodicRequests.sort()
391 request = self._periodicRequests[0]
392
393 t = time.time()
394
395 if request.nextFire>t:
396 break
397
398 self._processRequest(request, t)
399
400 while self._connectionRequested and self._requests:
401 request = self._requests[0]
402 del self._requests[0]
403
404 self._processRequest(request, None)
405
406 return self._connectionRequested
407
408#------------------------------------------------------------------------------
409
410class Simulator(object):
411 """The simulator class representing the interface to the flight simulator
412 via FSUIPC."""
413 # The basic data that should be queried all the time once we are connected
414 normalData = [ (0x0240, "H"), # Year
415 (0x023e, "H"), # Number of day in year
416 (0x023b, "b"), # UTC hour
417 (0x023c, "b"), # UTC minute
418 (0x023a, "b"), # seconds
419 (0x3d00, -256), # The name of the current aircraft
420 (0x3c00, -256) ] # The path of the current AIR file
421
422 flareData1 = [ (0x023a, "b"), # Seconds of time
423 (0x31e4, "d"), # Radio altitude
424 (0x02c8, "d") ] # Vertical speed
425
426 flareStartData = [ (0x0e90, "H"), # Ambient wind speed
427 (0x0e92, "H"), # Ambient wind direction
428 (0x0e8a, "H") ] # Visibility
429
430 flareData2 = [ (0x023a, "b"), # Seconds of time
431 (0x0366, "H"), # On the ground
432 (0x02c8, "d"), # Vertical speed
433 (0x030c, "d"), # Touch-down rate
434 (0x02bc, "d"), # IAS
435 (0x0578, "d"), # Pitch
436 (0x057c, "d"), # Bank
437 (0x0580, "d") ] # Heading
438
439 def __init__(self, connectionListener):
440 """Construct the simulator.
441
442 The aircraft object passed must provide the following members:
443 - type: one of the AIRCRAFT_XXX constants from const.py
444 - modelChanged(aircraftName, modelName): called when the model handling
445 the aircraft has changed.
446 - handleState(aircraftState): handle the given state.
447 - flareStarted(windSpeed, windDirection, visibility, flareStart,
448 flareStartFS): called when the flare has
449 started. windSpeed is in knots, windDirection is in degrees and
450 visibility is in metres. flareStart and flareStartFS are two time
451 values expressed in seconds that can be used to calculate the flare
452 time.
453 - flareFinished(flareEnd, flareEndFS, tdRate, tdRateCalculatedByFS,
454 ias, pitch, bank, heading): called when the flare has
455 finished, i.e. the aircraft is on the ground. flareEnd and flareEndFS
456 are the two time values corresponding to the touchdown time. tdRate is
457 the touch-down rate, tdRateCalculatedBySim indicates if the data comes
458 from the simulator or was calculated by the adapter. The other data
459 are self-explanatory and expressed in their 'natural' units."""
460 self._aircraft = None
461
462 self._handler = Handler(connectionListener)
463 self._handler.start()
464
465 self._normalRequestID = None
466
467 self._monitoringRequested = False
468 self._monitoring = False
469
470 self._aircraftName = None
471 self._aircraftModel = None
472
473 self._flareRequestID = None
474 self._flareRates = []
475 self._flareStart = None
476 self._flareStartFS = None
477
478 self._latin1decoder = codecs.getdecoder("iso-8859-1")
479
480 def connect(self, aircraft):
481 """Initiate a connection to the simulator."""
482 self._aircraft = aircraft
483 self._aircraftName = None
484 self._aircraftModel = None
485 self._handler.connect()
486 self._startDefaultNormal()
487
488 def startMonitoring(self):
489 """Start the periodic monitoring of the aircraft and pass the resulting
490 state to the aircraft object periodically."""
491 assert not self._monitoringRequested
492 self._monitoringRequested = True
493
494 def stopMonitoring(self):
495 """Stop the periodic monitoring of the aircraft."""
496 assert self._monitoringRequested
497 self._monitoringRequested = False
498
499 def startFlare(self):
500 """Start monitoring the flare time.
501
502 At present it is assumed to be called from the FSUIPC thread, hence no
503 protection."""
504 #self._aircraft.logger.debug("startFlare")
505 if self._flareRequestID is None:
506 self._flareRates = []
507 self._flareRequestID = self._handler.requestPeriodicRead(0.1,
508 Simulator.flareData1,
509 self._handleFlare1)
510
511 def cancelFlare(self):
512 """Cancel monitoring the flare time.
513
514 At present it is assumed to be called from the FSUIPC thread, hence no
515 protection."""
516 if self._flareRequestID is not None:
517 self._handler.clearPeriodic(self._flareRequestID)
518 self._flareRequestID = None
519
520 def disconnect(self):
521 """Disconnect from the simulator."""
522 assert not self._monitoringRequested
523
524 self._stopNormal()
525 self._handler.disconnect()
526
527 def _startDefaultNormal(self):
528 """Start the default normal periodic request."""
529 assert self._normalRequestID is None
530 self._normalRequestID = \
531 self._handler.requestPeriodicRead(1.0,
532 Simulator.normalData,
533 self._handleNormal,
534 validator = self._validateNormal)
535
536 def _stopNormal(self):
537 """Stop the normal period request."""
538 assert self._normalRequestID is not None
539 self._handler.clearPeriodic(self._normalRequestID)
540 self._normalRequestID = None
541 self._monitoring = False
542
543 def _validateNormal(self, data, extra):
544 """Validate the normal data."""
545 return data[0]!=0 and data[1]!=0 and len(data[5])>0 and len(data[6])>0
546
547 def _handleNormal(self, data, extra):
548 """Handle the reply to the normal request.
549
550 At the beginning the result consists the data for normalData. When
551 monitoring is started, it contains the result also for the
552 aircraft-specific values.
553 """
554 timestamp = calendar.timegm(time.struct_time([data[0],
555 1, 1, 0, 0, 0, -1, 1, 0]))
556 timestamp += data[1] * 24 * 3600
557 timestamp += data[2] * 3600
558 timestamp += data[3] * 60
559 timestamp += data[4]
560
561 createdNewModel = self._setAircraftName(timestamp, data[5], data[6])
562
563 if self._monitoringRequested and not self._monitoring:
564 self._stopNormal()
565 self._startMonitoring()
566 elif self._monitoring and not self._monitoringRequested:
567 self._stopNormal()
568 self._startDefaultNormal()
569 elif self._monitoring and self._aircraftModel is not None and \
570 not createdNewModel:
571 aircraftState = self._aircraftModel.getAircraftState(self._aircraft,
572 timestamp, data)
573 self._aircraft.handleState(aircraftState)
574
575 def _setAircraftName(self, timestamp, name, airPath):
576 """Set the name of the aicraft and if it is different from the
577 previous, create a new model for it.
578
579 If so, also notifty the aircraft about the change.
580
581 Return if a new model was created."""
582 aircraftName = (name, airPath)
583 if aircraftName==self._aircraftName:
584 return False
585
586 self._aircraftName = aircraftName
587 needNew = self._aircraftModel is None
588 needNew = needNew or\
589 not self._aircraftModel.doesHandle(self._aircraft, aircraftName)
590 if not needNew:
591 specialModel = AircraftModel.findSpecial(self._aircraft, aircraftName)
592 needNew = specialModel is not None and \
593 specialModel is not self._aircraftModel.__class__
594
595 if needNew:
596 self._setAircraftModel(AircraftModel.create(self._aircraft, aircraftName))
597
598
599 self._aircraft.modelChanged(timestamp, self._latin1decoder(name),
600 self._aircraftModel.name)
601
602 return needNew
603
604 def _setAircraftModel(self, model):
605 """Set a new aircraft model.
606
607 It will be queried for the data to monitor and the monitoring request
608 will be replaced by a new one."""
609 self._aircraftModel = model
610
611 if self._monitoring:
612 self._stopNormal()
613 self._startMonitoring()
614
615 def _startMonitoring(self):
616 """Start monitoring with the current aircraft model."""
617 data = Simulator.normalData[:]
618 self._aircraftModel.addMonitoringData(data)
619
620 self._normalRequestID = \
621 self._handler.requestPeriodicRead(1.0, data,
622 self._handleNormal,
623 validator = self._validateNormal)
624 self._monitoring = True
625
626 def _addFlareRate(self, data):
627 """Append a flare rate to the list of last rates."""
628 if len(self._flareRates)>=3:
629 del self._flareRates[0]
630 self._flareRates.append(Handler.fsuipc2VS(data))
631
632 def _handleFlare1(self, data, normal):
633 """Handle the first stage of flare monitoring."""
634 #self._aircraft.logger.debug("handleFlare1: " + str(data))
635 if Handler.fsuipc2radioAltitude(data[1])<=50.0:
636 self._flareStart = time.time()
637 self._flareStartFS = data[0]
638 self._handler.clearPeriodic(self._flareRequestID)
639 self._flareRequestID = \
640 self._handler.requestPeriodicRead(0.1,
641 Simulator.flareData2,
642 self._handleFlare2)
643 self._handler.requestRead(Simulator.flareStartData,
644 self._handleFlareStart)
645
646 self._addFlareRate(data[2])
647
648 def _handleFlareStart(self, data, extra):
649 """Handle the data need to notify the aircraft about the starting of
650 the flare."""
651 #self._aircraft.logger.debug("handleFlareStart: " + str(data))
652 if data is not None:
653 windDirection = data[1]*360.0/65536.0
654 if windDirection<0.0: windDirection += 360.0
655 self._aircraft.flareStarted(data[0], windDirection,
656 data[2]*1609.344/100.0,
657 self._flareStart, self._flareStartFS)
658
659 def _handleFlare2(self, data, normal):
660 """Handle the first stage of flare monitoring."""
661 #self._aircraft.logger.debug("handleFlare2: " + str(data))
662 if data[1]!=0:
663 flareEnd = time.time()
664 self._handler.clearPeriodic(self._flareRequestID)
665 self._flareRequestID = None
666
667 flareEndFS = data[0]
668 if flareEndFS<self._flareStartFS:
669 flareEndFS += 60
670
671 tdRate = Handler.fsuipc2VS(data[3])
672 tdRateCalculatedByFS = True
673 if tdRate==0 or tdRate>1000.0 or tdRate<-1000.0:
674 tdRate = min(self._flareRates)
675 tdRateCalculatedByFS = False
676
677 self._aircraft.flareFinished(flareEnd, flareEndFS,
678 tdRate, tdRateCalculatedByFS,
679 Handler.fsuipc2IAS(data[4]),
680 Handler.fsuipc2Degrees(data[5]),
681 Handler.fsuipc2Degrees(data[6]),
682 Handler.fsuipc2PositiveDegrees(data[7]))
683 else:
684 self._addFlareRate(data[2])
685
686#------------------------------------------------------------------------------
687
688class AircraftModel(object):
689 """Base class for the aircraft models.
690
691 Aircraft models handle the data arriving from FSUIPC and turn it into an
692 object describing the aircraft's state."""
693 monitoringData = [("paused", 0x0264, "H"),
694 ("frozen", 0x3364, "H"),
695 ("replay", 0x0628, "d"),
696 ("slew", 0x05dc, "H"),
697 ("overspeed", 0x036d, "b"),
698 ("stalled", 0x036c, "b"),
699 ("onTheGround", 0x0366, "H"),
700 ("zfw", 0x3bfc, "d"),
701 ("grossWeight", 0x30c0, "f"),
702 ("heading", 0x0580, "d"),
703 ("pitch", 0x0578, "d"),
704 ("bank", 0x057c, "d"),
705 ("ias", 0x02bc, "d"),
706 ("mach", 0x11c6, "H"),
707 ("groundSpeed", 0x02b4, "d"),
708 ("vs", 0x02c8, "d"),
709 ("radioAltitude", 0x31e4, "d"),
710 ("altitude", 0x0570, "l"),
711 ("gLoad", 0x11ba, "H"),
712 ("flapsControl", 0x0bdc, "d"),
713 ("flapsLeft", 0x0be0, "d"),
714 ("flapsRight", 0x0be4, "d"),
715 ("lights", 0x0d0c, "H"),
716 ("pitot", 0x029c, "b"),
717 ("parking", 0x0bc8, "H"),
718 ("noseGear", 0x0bec, "d"),
719 ("spoilersArmed", 0x0bcc, "d"),
720 ("spoilers", 0x0bd0, "d"),
721 ("altimeter", 0x0330, "H"),
722 ("nav1", 0x0350, "H"),
723 ("nav2", 0x0352, "H"),
724 ("squawk", 0x0354, "H"),
725 ("windSpeed", 0x0e90, "H"),
726 ("windDirection", 0x0e92, "H")]
727
728
729 specialModels = []
730
731 @staticmethod
732 def registerSpecial(clazz):
733 """Register the given class as a special model."""
734 AircraftModel.specialModels.append(clazz)
735
736 @staticmethod
737 def findSpecial(aircraft, aircraftName):
738 for specialModel in AircraftModel.specialModels:
739 if specialModel.doesHandle(aircraft, aircraftName):
740 return specialModel
741 return None
742
743 @staticmethod
744 def create(aircraft, aircraftName):
745 """Create the model for the given aircraft name, and notify the
746 aircraft about it."""
747 specialModel = AircraftModel.findSpecial(aircraft, aircraftName)
748 if specialModel is not None:
749 return specialModel()
750 if aircraft.type in _genericModels:
751 return _genericModels[aircraft.type]()
752 else:
753 return GenericModel()
754
755 @staticmethod
756 def convertBCD(data, length):
757 """Convert a data item encoded as BCD into a string of the given number
758 of digits."""
759 bcd = ""
760 for i in range(0, length):
761 digit = chr(ord('0') + (data&0x0f))
762 data >>= 4
763 bcd = digit + bcd
764 return bcd
765
766 @staticmethod
767 def convertFrequency(data):
768 """Convert the given frequency data to a string."""
769 bcd = AircraftModel.convertBCD(data, 4)
770 return "1" + bcd[0:2] + "." + bcd[2:4]
771
772 def __init__(self, flapsNotches):
773 """Construct the aircraft model.
774
775 flapsNotches is a list of degrees of flaps that are available on the aircraft."""
776 self._flapsNotches = flapsNotches
777
778 @property
779 def name(self):
780 """Get the name for this aircraft model."""
781 return "FSUIPC/Generic"
782
783 def doesHandle(self, aircraft, aircraftName):
784 """Determine if the model handles the given aircraft name.
785
786 This default implementation returns False."""
787 return False
788
789 def _addOffsetWithIndexMember(self, dest, offset, type, attrName = None):
790 """Add the given FSUIPC offset and type to the given array and a member
791 attribute with the given name."""
792 dest.append((offset, type))
793 if attrName is not None:
794 setattr(self, attrName, len(dest)-1)
795
796 def _addDataWithIndexMembers(self, dest, prefix, data):
797 """Add FSUIPC data to the given array and also corresponding index
798 member variables with the given prefix.
799
800 data is a list of triplets of the following items:
801 - the name of the data item. The index member variable will have a name
802 created by prepending the given prefix to this name.
803 - the FSUIPC offset
804 - the FSUIPC type
805
806 The latter two items will be appended to dest."""
807 for (name, offset, type) in data:
808 self._addOffsetWithIndexMember(dest, offset, type, prefix + name)
809
810 def addMonitoringData(self, data):
811 """Add the model-specific monitoring data to the given array."""
812 self._addDataWithIndexMembers(data, "_monidx_",
813 AircraftModel.monitoringData)
814
815 def getAircraftState(self, aircraft, timestamp, data):
816 """Get an aircraft state object for the given monitoring data."""
817 state = fs.AircraftState()
818
819 state.timestamp = timestamp
820
821 state.paused = data[self._monidx_paused]!=0 or \
822 data[self._monidx_frozen]!=0 or \
823 data[self._monidx_replay]!=0
824 state.trickMode = data[self._monidx_slew]!=0
825
826 state.overspeed = data[self._monidx_overspeed]!=0
827 state.stalled = data[self._monidx_stalled]!=0
828 state.onTheGround = data[self._monidx_onTheGround]!=0
829
830 state.zfw = data[self._monidx_zfw] * const.LBSTOKG / 256.0
831 state.grossWeight = data[self._monidx_grossWeight] * const.LBSTOKG
832
833 state.heading = Handler.fsuipc2PositiveDegrees(data[self._monidx_heading])
834
835 state.pitch = Handler.fsuipc2Degrees(data[self._monidx_pitch])
836 state.bank = Handler.fsuipc2Degrees(data[self._monidx_bank])
837
838 state.ias = Handler.fsuipc2IAS(data[self._monidx_ias])
839 state.mach = data[self._monidx_mach] / 20480.0
840 state.groundSpeed = data[self._monidx_groundSpeed]* 3600.0/65536.0/1852.0
841 state.vs = Handler.fsuipc2VS(data[self._monidx_vs])
842
843 state.radioAltitude = \
844 Handler.fsuipc2radioAltitude(data[self._monidx_radioAltitude])
845 state.altitude = data[self._monidx_altitude]/const.FEETTOMETRES/65536.0/65536.0
846
847 state.gLoad = data[self._monidx_gLoad] / 625.0
848
849 numNotchesM1 = len(self._flapsNotches) - 1
850 flapsIncrement = 16383 / numNotchesM1
851 flapsControl = data[self._monidx_flapsControl]
852 flapsIndex = flapsControl / flapsIncrement
853 if flapsIndex < numNotchesM1:
854 if (flapsControl - (flapsIndex*flapsIncrement) >
855 (flapsIndex+1)*flapsIncrement - flapsControl):
856 flapsIndex += 1
857 state.flapsSet = self._flapsNotches[flapsIndex]
858
859 flapsLeft = data[self._monidx_flapsLeft]
860 state.flaps = self._flapsNotches[-1]*flapsLeft/16383.0
861
862 lights = data[self._monidx_lights]
863
864 state.navLightsOn = (lights&0x01) != 0
865 state.antiCollisionLightsOn = (lights&0x02) != 0
866 state.landingLightsOn = (lights&0x04) != 0
867 state.strobeLightsOn = (lights&0x10) != 0
868
869 state.pitotHeatOn = data[self._monidx_pitot]!=0
870
871 state.parking = data[self._monidx_parking]!=0
872
873 state.gearsDown = data[self._monidx_noseGear]==16383
874
875 state.spoilersArmed = data[self._monidx_spoilersArmed]!=0
876
877 spoilers = data[self._monidx_spoilers]
878 if spoilers<=4800:
879 state.spoilersExtension = 0.0
880 else:
881 state.spoilersExtension = (spoilers - 4800) * 100.0 / (16383 - 4800)
882
883 state.altimeter = data[self._monidx_altimeter] / 16.0
884
885 state.nav1 = AircraftModel.convertFrequency(data[self._monidx_nav1])
886 state.nav2 = AircraftModel.convertFrequency(data[self._monidx_nav2])
887 state.squawk = AircraftModel.convertBCD(data[self._monidx_squawk], 4)
888
889 state.windSpeed = data[self._monidx_windSpeed]
890 state.windDirection = data[self._monidx_windDirection]*360.0/65536.0
891 if state.windDirection<0.0: state.windDirection += 360.0
892
893 return state
894
895#------------------------------------------------------------------------------
896
897class GenericAircraftModel(AircraftModel):
898 """A generic aircraft model that can handle the fuel levels, the N1 or RPM
899 values and some other common parameters in a generic way."""
900 def __init__(self, flapsNotches, fuelInfo, numEngines, isN1 = True):
901 """Construct the generic aircraft model with the given data.
902
903 flapsNotches is an array of how much degrees the individual flaps
904 notches mean.
905
906 fuelInfo is an array of FSUIPC offsets for the levels of the fuel
907 tanks. It is assumed to be a 4-byte value, followed by another 4-byte
908 value, which is the fuel tank capacity.
909
910 numEngines is the number of engines the aircraft has.
911
912 isN1 determines if the engines have an N1 value or an RPM value
913 (e.g. pistons)."""
914 super(GenericAircraftModel, self).__init__(flapsNotches = flapsNotches)
915
916 self._fuelInfo = fuelInfo
917 self._fuelStartIndex = None
918 self._numEngines = numEngines
919 self._engineStartIndex = None
920 self._isN1 = isN1
921
922 def doesHandle(self, aircraft, aircraftName):
923 """Determine if the model handles the given aircraft name.
924
925 This implementation returns True."""
926 return True
927
928 def addMonitoringData(self, data):
929 """Add the model-specific monitoring data to the given array."""
930 super(GenericAircraftModel, self).addMonitoringData(data)
931
932 self._addOffsetWithIndexMember(data, 0x0af4, "H", "_monidx_fuelWeight")
933
934 self._fuelStartIndex = len(data)
935 for offset in self._fuelInfo:
936 self._addOffsetWithIndexMember(data, offset, "u") # tank level
937 self._addOffsetWithIndexMember(data, offset+4, "u") # tank capacity
938
939 if self._isN1:
940 self._engineStartIndex = len(data)
941 for i in range(0, self._numEngines):
942 self._addOffsetWithIndexMember(data, 0x2000 + i * 0x100, "f") # N1
943 self._addOffsetWithIndexMember(data, 0x088c + i * 0x98, "h") # throttle lever
944
945 def getAircraftState(self, aircraft, timestamp, data):
946 """Get the aircraft state.
947
948 Get it from the parent, and then add the data about the fuel levels and
949 the engine parameters."""
950 state = super(GenericAircraftModel, self).getAircraftState(aircraft,
951 timestamp,
952 data)
953
954 fuelWeight = data[self._monidx_fuelWeight]/256.0
955 state.fuel = []
956 for i in range(self._fuelStartIndex,
957 self._fuelStartIndex + 2*len(self._fuelInfo), 2):
958 fuel = data[i+1]*data[i]*fuelWeight*const.LBSTOKG/128.0/65536.0
959 state.fuel.append(fuel)
960
961 state.n1 = []
962 state.reverser = []
963 for i in range(self._engineStartIndex,
964 self._engineStartIndex + 2*self._numEngines, 2):
965 state.n1.append(data[i])
966 state.reverser.append(data[i+1]<0)
967
968 return state
969
970#------------------------------------------------------------------------------
971
972class GenericModel(GenericAircraftModel):
973 """Generic aircraft model for an unknown type."""
974 def __init__(self):
975 """Construct the model."""
976 super(GenericModel, self). \
977 __init__(flapsNotches = [0, 10, 20, 30],
978 fuelInfo = [0x0b74, 0x0b7c, 0xb94],
979 numEngines = 2)
980
981 @property
982 def name(self):
983 """Get the name for this aircraft model."""
984 return "FSUIPC/Generic"
985
986#------------------------------------------------------------------------------
987
988class B737Model(GenericAircraftModel):
989 """Generic model for the Boeing 737 Classing and NG aircraft."""
990 def __init__(self):
991 """Construct the model."""
992 super(B737Model, self). \
993 __init__(flapsNotches = [0, 1, 2, 5, 10, 15, 25, 30, 40],
994 fuelInfo = [0x0b74, 0x0b7c, 0xb94],
995 numEngines = 2)
996
997 @property
998 def name(self):
999 """Get the name for this aircraft model."""
1000 return "FSUIPC/Generic Boeing 737"
1001
1002#------------------------------------------------------------------------------
1003
1004class PMDGBoeing737NGModel(B737Model):
1005 """A model handler for the PMDG Boeing 737NG model."""
1006 @staticmethod
1007 def doesHandle(aircraft, (name, airPath)):
1008 """Determine if this model handler handles the aircraft with the given
1009 name."""
1010 return aircraft.type in [const.AIRCRAFT_B736,
1011 const.AIRCRAFT_B737,
1012 const.AIRCRAFT_B738] and \
1013 (name.find("PMDG")!=-1 or airPath.find("PMDG")!=-1) and \
1014 (name.find("737")!=-1 or airPath.find("737")!=-1) and \
1015 (name.find("600")!=-1 or airPath.find("600")!=-1 or \
1016 name.find("700")!=-1 or airPath.find("700")!=-1 or \
1017 name.find("800")!=-1 or airPath.find("800")!=-1 or \
1018 name.find("900")!=-1 or airPath.find("900")!=-1)
1019
1020 @property
1021 def name(self):
1022 """Get the name for this aircraft model."""
1023 return "FSUIPC/PMDG Boeing 737NG"
1024
1025 def addMonitoringData(self, data):
1026 """Add the model-specific monitoring data to the given array."""
1027 super(PMDGBoeing737NGModel, self).addMonitoringData(data)
1028
1029 self._addOffsetWithIndexMember(data, 0x6202, "b", "_pmdgidx_switches")
1030
1031 def getAircraftState(self, aircraft, timestamp, data):
1032 """Get the aircraft state.
1033
1034 Get it from the parent, and then check some PMDG-specific stuff."""
1035 state = super(PMDGBoeing737NGModel, self).getAircraftState(aircraft,
1036 timestamp,
1037 data)
1038 if data[self._pmdgidx_switches]&0x01==0x01:
1039 state.altimeter = 1013.25
1040
1041 return state
1042
1043#------------------------------------------------------------------------------
1044
1045class B767Model(GenericAircraftModel):
1046 """Generic model for the Boeing 767 aircraft."""
1047 def __init__(self):
1048 """Construct the model."""
1049 super(B767Model, self). \
1050 __init__(flapsNotches = [0, 1, 5, 15, 20, 25, 30],
1051 fuelInfo = [0x0b74, 0x0b7c, 0xb94],
1052 numEngines = 2)
1053
1054 @property
1055 def name(self):
1056 """Get the name for this aircraft model."""
1057 return "FSUIPC/Generic Boeing 767"
1058
1059#------------------------------------------------------------------------------
1060
1061class DH8DModel(GenericAircraftModel):
1062 """Generic model for the Bombardier Dash 8-Q400 aircraft."""
1063 def __init__(self):
1064 """Construct the model."""
1065 super(DH8DModel, self). \
1066 __init__(flapsNotches = [0, 5, 10, 15, 35],
1067 fuelInfo = [0x0b74, 0x0b7c, 0xb94],
1068 numEngines = 2)
1069
1070 @property
1071 def name(self):
1072 """Get the name for this aircraft model."""
1073 return "FSUIPC/Generic Bombardier Dash 8-Q400"
1074
1075#------------------------------------------------------------------------------
1076
1077class DreamwingsDH8DModel(DH8DModel):
1078 """Model handler for the Dreamwings Dash 8-Q400."""
1079 @staticmethod
1080 def doesHandle(aircraft, (name, airPath)):
1081 """Determine if this model handler handles the aircraft with the given
1082 name."""
1083 return aircraft.type==const.AIRCRAFT_DH8D and \
1084 (name.find("Dreamwings")!=-1 or airPath.find("Dreamwings")!=-1) and \
1085 (name.find("Dash")!=-1 or airPath.find("Dash")!=-1) and \
1086 (name.find("Q400")!=-1 or airPath.find("Q400")!=-1) and \
1087 airPath.find("Dash8Q400")!=-1
1088
1089 @property
1090 def name(self):
1091 """Get the name for this aircraft model."""
1092 return "FSUIPC/Dreamwings Bombardier Dash 8-Q400"
1093
1094 def getAircraftState(self, aircraft, timestamp, data):
1095 """Get the aircraft state.
1096
1097 Get it from the parent, and then invert the pitot heat state."""
1098 state = super(DreamwingsDH8DModel, self).getAircraftState(aircraft,
1099 timestamp,
1100 data)
1101 state.pitotHeatOn = not state.pitotHeatOn
1102
1103 return state
1104#------------------------------------------------------------------------------
1105
1106class CRJ2Model(GenericAircraftModel):
1107 """Generic model for the Bombardier CRJ-200 aircraft."""
1108 def __init__(self):
1109 """Construct the model."""
1110 super(CRJ2Model, self). \
1111 __init__(flapsNotches = [0, 8, 20, 30, 45],
1112 fuelInfo = [0x0b74, 0x0b7c, 0xb94],
1113 numEngines = 2)
1114
1115 @property
1116 def name(self):
1117 """Get the name for this aircraft model."""
1118 return "FSUIPC/Generic Bombardier CRJ-200"
1119
1120#------------------------------------------------------------------------------
1121
1122class F70Model(GenericAircraftModel):
1123 """Generic model for the Fokker F70 aircraft."""
1124 def __init__(self):
1125 """Construct the model."""
1126 super(F70Model, self). \
1127 __init__(flapsNotches = [0, 8, 15, 25, 42],
1128 fuelInfo = [0x0b74, 0x0b7c, 0xb94],
1129 numEngines = 2)
1130
1131 @property
1132 def name(self):
1133 """Get the name for this aircraft model."""
1134 return "FSUIPC/Generic Fokker 70"
1135
1136#------------------------------------------------------------------------------
1137
1138class DC3Model(GenericAircraftModel):
1139 """Generic model for the Lisunov Li-2 (DC-3) aircraft."""
1140 def __init__(self):
1141 """Construct the model."""
1142 super(DC3Model, self). \
1143 __init__(flapsNotches = [0, 15, 30, 45],
1144 fuelInfo = [0x0b7c, 0x0b84, 0x0b94, 0x0b9c],
1145 numEngines = 2)
1146
1147 @property
1148 def name(self):
1149 """Get the name for this aircraft model."""
1150 return "FSUIPC/Generic Lisunov Li-2"
1151
1152#------------------------------------------------------------------------------
1153
1154class T134Model(GenericAircraftModel):
1155 """Generic model for the Tupolev Tu-134 aircraft."""
1156 def __init__(self):
1157 """Construct the model."""
1158 super(T134Model, self). \
1159 __init__(flapsNotches = [0, 10, 20, 30],
1160 fuelInfo = [0x0b74,
1161 0x0b8c, 0x0b84,
1162 0x0ba4, 0x0b9c,
1163 0x1254, 0x125c],
1164 numEngines = 2)
1165
1166 @property
1167 def name(self):
1168 """Get the name for this aircraft model."""
1169 return "FSUIPC/Generic Tupolev Tu-134"
1170
1171#------------------------------------------------------------------------------
1172
1173class T154Model(GenericAircraftModel):
1174 """Generic model for the Tupolev Tu-134 aircraft."""
1175 def __init__(self):
1176 """Construct the model."""
1177 super(T154Model, self). \
1178 __init__(flapsNotches = [0, 15, 28, 45],
1179 fuelInfo = [0x0b74, 0x0b7c, 0x0b94,
1180 0x1244, 0x0b84, 0x0b9c],
1181 numEngines = 3)
1182
1183 @property
1184 def name(self):
1185 """Get the name for this aircraft model."""
1186 return "FSUIPC/Generic Tupolev Tu-154"
1187
1188 def getAircraftState(self, aircraft, timestamp, data):
1189 """Get an aircraft state object for the given monitoring data.
1190
1191 This removes the reverser value for the middle engine."""
1192 state = super(T154Model, self).getAircraftState(aircraft, timestamp, data)
1193 del state.reverser[1]
1194 return state
1195
1196#------------------------------------------------------------------------------
1197
1198class YK40Model(GenericAircraftModel):
1199 """Generic model for the Yakovlev Yak-40 aircraft."""
1200 def __init__(self):
1201 """Construct the model."""
1202 super(YK40Model, self). \
1203 __init__(flapsNotches = [0, 20, 35],
1204 fuelInfo = [0x0b7c, 0x0b94],
1205 numEngines = 2)
1206
1207 @property
1208 def name(self):
1209 """Get the name for this aircraft model."""
1210 return "FSUIPC/Generic Yakovlev Yak-40"
1211
1212#------------------------------------------------------------------------------
1213
1214_genericModels = { const.AIRCRAFT_B736 : B737Model,
1215 const.AIRCRAFT_B737 : B737Model,
1216 const.AIRCRAFT_B738 : B737Model,
1217 const.AIRCRAFT_B733 : B737Model,
1218 const.AIRCRAFT_B734 : B737Model,
1219 const.AIRCRAFT_B735 : B737Model,
1220 const.AIRCRAFT_DH8D : DH8DModel,
1221 const.AIRCRAFT_B762 : B767Model,
1222 const.AIRCRAFT_B763 : B767Model,
1223 const.AIRCRAFT_CRJ2 : B767Model,
1224 const.AIRCRAFT_F70 : F70Model,
1225 const.AIRCRAFT_DC3 : DC3Model,
1226 const.AIRCRAFT_T134 : T134Model,
1227 const.AIRCRAFT_T154 : T154Model,
1228 const.AIRCRAFT_YK40 : YK40Model }
1229
1230#------------------------------------------------------------------------------
1231
1232AircraftModel.registerSpecial(PMDGBoeing737NGModel)
1233AircraftModel.registerSpecial(DreamwingsDH8DModel)
1234
1235#------------------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.