source: src/mlx/fsuipc.py@ 308:ce19a15a3152

Last change on this file since 308:ce19a15a3152 was 298:24c67ec5cdca, checked in by István Váradi <ivaradi@…>, 12 years ago

Documented the non-GUI modules

File size: 72.9 KB
Line 
1
2import fs
3import const
4import util
5import acft
6
7import threading
8import os
9import time
10import calendar
11import sys
12import codecs
13
14if os.name == "nt" and "FORCE_PYUIPC_SIM" not in os.environ:
15 import pyuipc
16else:
17 import pyuipc_sim as pyuipc
18
19#------------------------------------------------------------------------------
20
21## @package mlx.fsuipc
22#
23# The module towards FSUIPC.
24#
25# This module implements the simulator interface to FSUIPC.
26#
27# The \ref Handler class is thread handling the FSUIPC requests. It can be
28# given read, periodic read and write, requests, that are executed
29# asynchronously, and a callback function is called with the result. This class
30# is used internally within the module.
31#
32# The \ref Simulator class is the actual interface to the flight simulator, and
33# an instance of it is returned by \ref mlx.fs.createSimulator. This object can
34# be used to connect to the simulator and disconnect from it, to query various
35# data and to start and stop the monitoring of the data.
36#
37# \ref AircraftModel is the base class of the aircraft models. A "model" is a
38# particular implementation of an aircraft, such as the PMDG Boeing 737NG in
39# Flight Simulator 2004. Since each type and each model has its peculiarities
40# (e.g. the different engine and fuel tank configurations), each aircraft type
41# has a generic model, that should work for most of the time. However, certain
42# models may implement various controls, gauges, etc. differently, and such
43# peculiarites can be handled in a specific subclass of \ref
44# AircraftModel. These subclasses should be registered as special ones, and if
45# the simulator detects that the aircraft's model became known or has changed,
46# it will check these special models before resorting to the generic ones.
47#
48# The models are responsible also for querying certain parameters, such as the
49# fuel tank configuration. While ideally it should be specific to a type only,
50# it is possible that the model contains different tanks, in which case some
51# tricks may be needed. See the \ref DC3Model "DC-3 (Li-2)" aircraft as an
52# example.
53
54#------------------------------------------------------------------------------
55
56## The mapping of tank types to FSUIPC offsets
57_tank2offset = { const.FUELTANK_CENTRE : 0x0b74,
58 const.FUELTANK_LEFT : 0x0b7c,
59 const.FUELTANK_RIGHT : 0x0b94,
60 const.FUELTANK_LEFT_AUX : 0x0b84,
61 const.FUELTANK_RIGHT_AUX : 0x0b9c,
62 const.FUELTANK_LEFT_TIP : 0x0b8c,
63 const.FUELTANK_RIGHT_TIP : 0x0ba4,
64 const.FUELTANK_EXTERNAL1 : 0x1254,
65 const.FUELTANK_EXTERNAL2 : 0x125c,
66 const.FUELTANK_CENTRE2 : 0x1244 }
67
68#------------------------------------------------------------------------------
69
70class Handler(threading.Thread):
71 """The thread to handle the FSUIPC requests."""
72 @staticmethod
73 def fsuipc2VS(data):
74 """Convert the given vertical speed data read from FSUIPC into feet/min."""
75 return data*60.0/const.FEETTOMETRES/256.0
76
77 @staticmethod
78 def fsuipc2radioAltitude(data):
79 """Convert the given radio altitude data read from FSUIPC into feet."""
80 return data/const.FEETTOMETRES/65536.0
81
82 @staticmethod
83 def fsuipc2Degrees(data):
84 """Convert the given data into degrees."""
85 return data * 360.0 / 65536.0 / 65536.0
86
87 @staticmethod
88 def fsuipc2PositiveDegrees(data):
89 """Convert the given data into positive degrees."""
90 degrees = Handler.fsuipc2Degrees(data)
91 if degrees<0.0: degrees += 360.0
92 return degrees
93
94 @staticmethod
95 def fsuipc2IAS(data):
96 """Convert the given data into indicated airspeed."""
97 return data / 128.0
98
99 @staticmethod
100 def _callSafe(fun):
101 """Call the given function and swallow any exceptions."""
102 try:
103 return fun()
104 except Exception, e:
105 print >> sys.stderr, str(e)
106 return None
107
108 # The number of times a read is attempted
109 NUM_READATTEMPTS = 3
110
111 # The number of connection attempts
112 NUM_CONNECTATTEMPTS = 3
113
114 # The interval between successive connect attempts
115 CONNECT_INTERVAL = 0.25
116
117 @staticmethod
118 def _performRead(data, callback, extra, validator):
119 """Perform a read request.
120
121 If there is a validator, that will be called with the return values,
122 and if the values are wrong, the request is retried at most a certain
123 number of times.
124
125 Return True if the request has succeeded, False if validation has
126 failed during all attempts. An exception may also be thrown if there is
127 some lower-level communication problem."""
128 attemptsLeft = Handler.NUM_READATTEMPTS
129 while attemptsLeft>0:
130 values = pyuipc.read(data)
131 if validator is None or \
132 Handler._callSafe(lambda: validator(values, extra)):
133 Handler._callSafe(lambda: callback(values, extra))
134 return True
135 else:
136 attemptsLeft -= 1
137 return False
138
139 class Request(object):
140 """A simple, one-shot request."""
141 def __init__(self, forWrite, data, callback, extra, validator = None):
142 """Construct the request."""
143 self._forWrite = forWrite
144 self._data = data
145 self._callback = callback
146 self._extra = extra
147 self._validator = validator
148
149 def process(self, time):
150 """Process the request.
151
152 Return True if the request has succeeded, False if data validation
153 has failed for a reading request. An exception may also be thrown
154 if there is some lower-level communication problem."""
155 if self._forWrite:
156 pyuipc.write(self._data)
157 Handler._callSafe(lambda: self._callback(True, self._extra))
158 return True
159 else:
160 return Handler._performRead(self._data, self._callback,
161 self._extra, self._validator)
162
163 def fail(self):
164 """Handle the failure of this request."""
165 if self._forWrite:
166 Handler._callSafe(lambda: self._callback(False, self._extra))
167 else:
168 Handler._callSafe(lambda: self._callback(None, self._extra))
169
170 class PeriodicRequest(object):
171 """A periodic request."""
172 def __init__(self, id, period, data, callback, extra, validator):
173 """Construct the periodic request."""
174 self._id = id
175 self._period = period
176 self._nextFire = time.time()
177 self._data = data
178 self._preparedData = None
179 self._callback = callback
180 self._extra = extra
181 self._validator = validator
182
183 @property
184 def id(self):
185 """Get the ID of this periodic request."""
186 return self._id
187
188 @property
189 def nextFire(self):
190 """Get the next firing time."""
191 return self._nextFire
192
193 def process(self, time):
194 """Check if this request should be executed, and if so, do so.
195
196 time is the time at which the request is being executed. If this
197 function is called too early, nothing is done, and True is
198 returned.
199
200 Return True if the request has succeeded, False if data validation
201 has failed. An exception may also be thrown if there is some
202 lower-level communication problem."""
203 if time<self._nextFire:
204 return True
205
206 if self._preparedData is None:
207 self._preparedData = pyuipc.prepare_data(self._data)
208 self._data = None
209
210 isOK = Handler._performRead(self._preparedData, self._callback,
211 self._extra, self._validator)
212
213 if isOK:
214 while self._nextFire <= time:
215 self._nextFire += self._period
216
217 return isOK
218
219 def fail(self):
220 """Handle the failure of this request."""
221 pass
222
223 def __cmp__(self, other):
224 """Compare two periodic requests. They are ordered by their next
225 firing times."""
226 return cmp(self._nextFire, other._nextFire)
227
228 def __init__(self, connectionListener,
229 connectAttempts = -1, connectInterval = 0.2):
230 """Construct the handler with the given connection listener."""
231 threading.Thread.__init__(self)
232
233 self._connectionListener = connectionListener
234 self._connectAttempts = connectAttempts
235 self._connectInterval = connectInterval
236
237 self._requestCondition = threading.Condition()
238 self._connectionRequested = False
239 self._connected = False
240
241 self._requests = []
242 self._nextPeriodicID = 1
243 self._periodicRequests = []
244
245 self.daemon = True
246
247 def requestRead(self, data, callback, extra = None, validator = None):
248 """Request the reading of some data.
249
250 data is a list of tuples of the following items:
251 - the offset of the data as an integer
252 - the type letter of the data as a string
253
254 callback is a function that receives two pieces of data:
255 - the values retrieved or None on error
256 - the extra parameter
257
258 It will be called in the handler's thread!
259 """
260 with self._requestCondition:
261 self._requests.append(Handler.Request(False, data, callback, extra,
262 validator))
263 self._requestCondition.notify()
264
265 def requestWrite(self, data, callback, extra = None):
266 """Request the writing of some data.
267
268 data is a list of tuples of the following items:
269 - the offset of the data as an integer
270 - the type letter of the data as a string
271 - the data to write
272
273 callback is a function that receives two pieces of data:
274 - a boolean indicating if writing was successful
275 - the extra data
276 It will be called in the handler's thread!
277 """
278 with self._requestCondition:
279 request = Handler.Request(True, data, callback, extra)
280 #print "fsuipc.Handler.requestWrite", request
281 self._requests.append(request)
282 self._requestCondition.notify()
283
284 @staticmethod
285 def _readWriteCallback(data, extra):
286 """Callback for the read() and write() calls below."""
287 extra.append(data)
288 with extra[0] as condition:
289 condition.notify()
290
291 def requestPeriodicRead(self, period, data, callback, extra = None,
292 validator = None):
293 """Request a periodic read of data.
294
295 period is a floating point number with the period in seconds.
296
297 This function returns an identifier which can be used to cancel the
298 request."""
299 with self._requestCondition:
300 id = self._nextPeriodicID
301 self._nextPeriodicID += 1
302 request = Handler.PeriodicRequest(id, period, data, callback,
303 extra, validator)
304 self._periodicRequests.append(request)
305 self._requestCondition.notify()
306 return id
307
308 def clearPeriodic(self, id):
309 """Clear the periodic request with the given ID."""
310 with self._requestCondition:
311 for i in range(0, len(self._periodicRequests)):
312 if self._periodicRequests[i].id==id:
313 del self._periodicRequests[i]
314 return True
315 return False
316
317 def connect(self):
318 """Initiate the connection to the flight simulator."""
319 with self._requestCondition:
320 if not self._connectionRequested:
321 self._connectionRequested = True
322 self._requestCondition.notify()
323
324 def disconnect(self):
325 """Disconnect from the flight simulator."""
326 with self._requestCondition:
327 self._requests = []
328 if self._connectionRequested:
329 self._connectionRequested = False
330 self._requestCondition.notify()
331
332 def clearRequests(self):
333 """Clear the outstanding one-shot requests."""
334 with self._requestCondition:
335 self._requests = []
336
337 def run(self):
338 """Perform the operation of the thread."""
339 while True:
340 self._waitConnectionRequest()
341
342 if self._connect()>0:
343 self._handleConnection()
344
345 self._disconnect()
346
347 def _waitConnectionRequest(self):
348 """Wait for a connection request to arrive."""
349 with self._requestCondition:
350 while not self._connectionRequested:
351 self._requestCondition.wait()
352
353 def _connect(self, autoReconnection = False, attempts = 0):
354 """Try to connect to the flight simulator via FSUIPC
355
356 Returns True if the connection has been established, False if it was
357 not due to no longer requested.
358 """
359 while self._connectionRequested:
360 if attempts>=self.NUM_CONNECTATTEMPTS:
361 self._connectionRequested = False
362 if autoReconnection:
363 Handler._callSafe(lambda:
364 self._connectionListener.disconnected())
365 else:
366 Handler._callSafe(lambda:
367 self._connectionListener.connectionFailed())
368 return 0
369
370 try:
371 attempts += 1
372 pyuipc.open(pyuipc.SIM_ANY)
373 description = "(FSUIPC version: 0x%04x, library version: 0x%04x, FS version: %d)" % \
374 (pyuipc.fsuipc_version, pyuipc.lib_version,
375 pyuipc.fs_version)
376 if not autoReconnection:
377 fsType = const.SIM_MSFSX \
378 if pyuipc.fs_version == pyuipc.SIM_FSX \
379 else const.SIM_MSFS9
380
381 Handler._callSafe(lambda:
382 self._connectionListener.connected(fsType,
383 description))
384 self._connected = True
385 return attempts
386 except Exception, e:
387 print "fsuipc.Handler._connect: connection failed: " + str(e) + \
388 " (attempts: %d)" % (attempts,)
389 if attempts<self.NUM_CONNECTATTEMPTS:
390 time.sleep(self.CONNECT_INTERVAL)
391
392 def _handleConnection(self):
393 """Handle a living connection."""
394 with self._requestCondition:
395 while self._connectionRequested:
396 self._processRequests()
397 self._waitRequest()
398
399 def _waitRequest(self):
400 """Wait for the time of the next request.
401
402 Returns also, if the connection is no longer requested.
403
404 Should be called with the request condition lock held."""
405 while self._connectionRequested:
406 timeout = None
407 if self._periodicRequests:
408 self._periodicRequests.sort()
409 timeout = self._periodicRequests[0].nextFire - time.time()
410
411 if self._requests or \
412 (timeout is not None and timeout <= 0.0):
413 return
414
415 self._requestCondition.wait(timeout)
416
417 def _disconnect(self):
418 """Disconnect from the flight simulator."""
419 print "fsuipc.Handler._disconnect"
420 if self._connected:
421 pyuipc.close()
422 self._connected = False
423
424 def _processRequest(self, request, time, attempts):
425 """Process the given request.
426
427 If an exception occurs or invalid data is read too many times, we try
428 to reconnect.
429
430 This function returns only if the request has succeeded, or if a
431 connection is no longer requested.
432
433 This function is called with the request lock held, but is relased
434 whole processing the request and reconnecting."""
435 self._requestCondition.release()
436
437 #print "fsuipc.Handler._processRequest", request
438
439 needReconnect = False
440 try:
441 try:
442 if not request.process(time):
443 print "fsuipc.Handler._processRequest: FSUIPC returned invalid data too many times, reconnecting"
444 needReconnect = True
445 except Exception as e:
446 print "fsuipc.Handler._processRequest: FSUIPC connection failed (" + \
447 str(e) + "), reconnecting (attempts=%d)." % (attempts,)
448 needReconnect = True
449
450 if needReconnect:
451 with self._requestCondition:
452 self._requests.insert(0, request)
453 self._disconnect()
454 return self._connect(autoReconnection = True, attempts = attempts)
455 else:
456 return 0
457 finally:
458 self._requestCondition.acquire()
459
460 def _processRequests(self):
461 """Process any pending requests.
462
463 Will be called with the request lock held."""
464 attempts = 0
465 while self._connectionRequested and self._periodicRequests:
466 self._periodicRequests.sort()
467 request = self._periodicRequests[0]
468
469 t = time.time()
470
471 if request.nextFire>t:
472 break
473
474 attempts = self._processRequest(request, t, attempts)
475
476 while self._connectionRequested and self._requests:
477 request = self._requests[0]
478 del self._requests[0]
479
480 attempts = self._processRequest(request, None, attempts)
481
482 return self._connectionRequested
483
484#------------------------------------------------------------------------------
485
486class Simulator(object):
487 """The simulator class representing the interface to the flight simulator
488 via FSUIPC."""
489 # The basic data that should be queried all the time once we are connected
490 timeData = [ (0x0240, "H"), # Year
491 (0x023e, "H"), # Number of day in year
492 (0x023b, "b"), # UTC hour
493 (0x023c, "b"), # UTC minute
494 (0x023a, "b") ] # seconds
495
496 normalData = timeData + \
497 [ (0x3d00, -256), # The name of the current aircraft
498 (0x3c00, -256), # The path of the current AIR file
499 (0x1274, "h") ] # Text display mode
500
501 flareData1 = [ (0x023a, "b"), # Seconds of time
502 (0x31e4, "d"), # Radio altitude
503 (0x02c8, "d") ] # Vertical speed
504
505 flareStartData = [ (0x0e90, "H"), # Ambient wind speed
506 (0x0e92, "H"), # Ambient wind direction
507 (0x0e8a, "H") ] # Visibility
508
509 flareData2 = [ (0x023a, "b"), # Seconds of time
510 (0x0366, "H"), # On the ground
511 (0x02c8, "d"), # Vertical speed
512 (0x030c, "d"), # Touch-down rate
513 (0x02bc, "d"), # IAS
514 (0x0578, "d"), # Pitch
515 (0x057c, "d"), # Bank
516 (0x0580, "d") ] # Heading
517
518 TIME_SYNC_INTERVAL = 3.0
519
520 @staticmethod
521 def _getTimestamp(data):
522 """Convert the given data into a timestamp."""
523 timestamp = calendar.timegm(time.struct_time([data[0],
524 1, 1, 0, 0, 0, -1, 1, 0]))
525 timestamp += data[1] * 24 * 3600
526 timestamp += data[2] * 3600
527 timestamp += data[3] * 60
528 timestamp += data[4]
529
530 return timestamp
531
532 @staticmethod
533 def _appendHotkeyData(data, offset, hotkey):
534 """Append the data for the given hotkey to the given array, that is
535 intended to be passed to requestWrite call on the handler."""
536 data.append((offset + 0, "b", ord(hotkey.key)))
537
538 modifiers = 0
539 if hotkey.ctrl: modifiers |= 0x02
540 if hotkey.shift: modifiers |= 0x01
541 data.append((offset + 1, "b", modifiers))
542
543 data.append((offset + 2, "b", 0))
544
545 data.append((offset + 3, "b", 0))
546
547 def __init__(self, connectionListener, connectAttempts = -1,
548 connectInterval = 0.2):
549 """Construct the simulator.
550
551 The aircraft object passed must provide the following members:
552 - type: one of the AIRCRAFT_XXX constants from const.py
553 - modelChanged(aircraftName, modelName): called when the model handling
554 the aircraft has changed.
555 - handleState(aircraftState): handle the given state.
556 - flareStarted(windSpeed, windDirection, visibility, flareStart,
557 flareStartFS): called when the flare has
558 started. windSpeed is in knots, windDirection is in degrees and
559 visibility is in metres. flareStart and flareStartFS are two time
560 values expressed in seconds that can be used to calculate the flare
561 time.
562 - flareFinished(flareEnd, flareEndFS, tdRate, tdRateCalculatedByFS,
563 ias, pitch, bank, heading): called when the flare has
564 finished, i.e. the aircraft is on the ground. flareEnd and flareEndFS
565 are the two time values corresponding to the touchdown time. tdRate is
566 the touch-down rate, tdRateCalculatedBySim indicates if the data comes
567 from the simulator or was calculated by the adapter. The other data
568 are self-explanatory and expressed in their 'natural' units."""
569 self._fsType = None
570 self._aircraft = None
571
572 self._handler = Handler(self,
573 connectAttempts = connectAttempts,
574 connectInterval = connectInterval)
575 self._connectionListener = connectionListener
576 self._handler.start()
577
578 self._scroll = False
579
580 self._syncTime = False
581 self._nextSyncTime = -1
582
583 self._normalRequestID = None
584
585 self._monitoringRequested = False
586 self._monitoring = False
587
588 self._aircraftName = None
589 self._aircraftModel = None
590
591 self._flareRequestID = None
592 self._flareRates = []
593 self._flareStart = None
594 self._flareStartFS = None
595
596 self._hotkeyLock = threading.Lock()
597 self._hotkeys = None
598 self._hotkeySetID = 0
599 self._hotkeySetGeneration = 0
600 self._hotkeyOffets = None
601 self._hotkeyRequestID = None
602 self._hotkeyCallback = None
603
604 self._latin1decoder = codecs.getdecoder("iso-8859-1")
605 self._fuelCallback = None
606
607 def connect(self, aircraft):
608 """Initiate a connection to the simulator."""
609 self._aircraft = aircraft
610 self._aircraftName = None
611 self._aircraftModel = None
612 self._handler.connect()
613 if self._normalRequestID is None:
614 self._nextSyncTime = -1
615 self._startDefaultNormal()
616
617 def reconnect(self):
618 """Initiate a reconnection to the simulator.
619
620 It does not reset already set up data, just calls connect() on the
621 handler."""
622 self._handler.connect()
623
624 def requestZFW(self, callback):
625 """Send a request for the ZFW."""
626 self._handler.requestRead([(0x3bfc, "d")], self._handleZFW, extra = callback)
627
628 def requestWeights(self, callback):
629 """Request the following weights: DOW, ZFW, payload.
630
631 These values will be passed to the callback function in this order, as
632 separate arguments."""
633 self._handler.requestRead([(0x13fc, "d")], self._handlePayloadCount,
634 extra = callback)
635
636 def requestTime(self, callback):
637 """Request the time from the simulator."""
638 self._handler.requestRead(Simulator.timeData, self._handleTime,
639 extra = callback)
640
641 def startMonitoring(self):
642 """Start the periodic monitoring of the aircraft and pass the resulting
643 state to the aircraft object periodically."""
644 assert not self._monitoringRequested
645 self._monitoringRequested = True
646
647 def stopMonitoring(self):
648 """Stop the periodic monitoring of the aircraft."""
649 assert self._monitoringRequested
650 self._monitoringRequested = False
651
652 def startFlare(self):
653 """Start monitoring the flare time.
654
655 At present it is assumed to be called from the FSUIPC thread, hence no
656 protection."""
657 #self._aircraft.logger.debug("startFlare")
658 if self._flareRequestID is None:
659 self._flareRates = []
660 self._flareRequestID = self._handler.requestPeriodicRead(0.1,
661 Simulator.flareData1,
662 self._handleFlare1)
663
664 def cancelFlare(self):
665 """Cancel monitoring the flare time.
666
667 At present it is assumed to be called from the FSUIPC thread, hence no
668 protection."""
669 if self._flareRequestID is not None:
670 self._handler.clearPeriodic(self._flareRequestID)
671 self._flareRequestID = None
672
673 def sendMessage(self, message, duration = 3,
674 _disconnect = False):
675 """Send a message to the pilot via the simulator.
676
677 duration is the number of seconds to keep the message displayed."""
678
679 if self._scroll:
680 if duration==0: duration = -1
681 elif duration == 1: duration = -2
682 else: duration = -duration
683
684 data = [(0x3380, -1 - len(message), message),
685 (0x32fa, 'h', duration)]
686
687 #if _disconnect:
688 # print "fsuipc.Simulator.sendMessage(disconnect)", message
689
690 self._handler.requestWrite(data, self._handleMessageSent,
691 extra = _disconnect)
692
693 def getFuel(self, callback):
694 """Get the fuel information for the current model.
695
696 The callback will be called with a list of triplets with the following
697 items:
698 - the fuel tank identifier
699 - the current weight of the fuel in the tank (in kgs)
700 - the current total capacity of the tank (in kgs)."""
701 if self._aircraftModel is None:
702 self._fuelCallback = callback
703 else:
704 self._aircraftModel.getFuel(self._handler, callback)
705
706 def setFuelLevel(self, levels):
707 """Set the fuel level to the given ones.
708
709 levels is an array of two-tuples, where each tuple consists of the
710 following:
711 - the const.FUELTANK_XXX constant denoting the tank that must be set,
712 - the requested level of the fuel as a floating-point value between 0.0
713 and 1.0."""
714 if self._aircraftModel is not None:
715 self._aircraftModel.setFuelLevel(self._handler, levels)
716
717 def enableTimeSync(self):
718 """Enable the time synchronization."""
719 self._nextSyncTime = -1
720 self._syncTime = True
721
722 def disableTimeSync(self):
723 """Enable the time synchronization."""
724 self._syncTime = False
725 self._nextSyncTime = -1
726
727 def listenHotkeys(self, hotkeys, callback):
728 """Start listening to the given hotkeys.
729
730 callback is function expecting two arguments:
731 - the ID of the hotkey set as returned by this function,
732 - the list of the indexes of the hotkeys that were pressed."""
733 with self._hotkeyLock:
734 assert self._hotkeys is None
735
736 self._hotkeys = hotkeys
737 self._hotkeySetID += 1
738 self._hotkeySetGeneration = 0
739 self._hotkeyCallback = callback
740
741 self._handler.requestRead([(0x320c, "u")],
742 self._handleNumHotkeys,
743 (self._hotkeySetID,
744 self._hotkeySetGeneration))
745
746 return self._hotkeySetID
747
748 def clearHotkeys(self):
749 """Clear the current hotkey set.
750
751 Note that it is possible, that the callback function set either
752 previously or after calling this function by listenHotkeys() will be
753 called with data from the previous hotkey set.
754
755 Therefore it is recommended to store the hotkey set ID somewhere and
756 check that in the callback function. Right before calling
757 clearHotkeys(), this stored ID should be cleared so that the check
758 fails for sure."""
759 with self._hotkeyLock:
760 if self._hotkeys is not None:
761 self._hotkeys = None
762 self._hotkeySetID += 1
763 self._hotkeyCallback = None
764 self._clearHotkeyRequest()
765
766 def disconnect(self, closingMessage = None, duration = 3):
767 """Disconnect from the simulator."""
768 assert not self._monitoringRequested
769
770 print "fsuipc.Simulator.disconnect", closingMessage, duration
771
772 self._stopNormal()
773 self.clearHotkeys()
774 if closingMessage is None:
775 self._handler.disconnect()
776 else:
777 self.sendMessage(closingMessage, duration = duration,
778 _disconnect = True)
779
780 def connected(self, fsType, descriptor):
781 """Called when a connection has been established to the flight
782 simulator of the given type."""
783 self._fsType = fsType
784 with self._hotkeyLock:
785 if self._hotkeys is not None:
786 self._hotkeySetGeneration += 1
787
788 self._handler.requestRead([(0x320c, "u")],
789 self._handleNumHotkeys,
790 (self._hotkeySetID,
791 self._hotkeySetGeneration))
792 self._connectionListener.connected(fsType, descriptor)
793
794 def connectionFailed(self):
795 """Called when the connection could not be established."""
796 with self._hotkeyLock:
797 self._clearHotkeyRequest()
798 self._connectionListener.connectionFailed()
799
800 def disconnected(self):
801 """Called when a connection to the flight simulator has been broken."""
802 with self._hotkeyLock:
803 self._clearHotkeyRequest()
804 self._connectionListener.disconnected()
805
806 def _startDefaultNormal(self):
807 """Start the default normal periodic request."""
808 assert self._normalRequestID is None
809 self._normalRequestID = \
810 self._handler.requestPeriodicRead(1.0,
811 Simulator.normalData,
812 self._handleNormal,
813 validator = self._validateNormal)
814
815 def _stopNormal(self):
816 """Stop the normal period request."""
817 assert self._normalRequestID is not None
818 self._handler.clearPeriodic(self._normalRequestID)
819 self._normalRequestID = None
820 self._monitoring = False
821
822 def _validateNormal(self, data, extra):
823 """Validate the normal data."""
824 return data[0]!=0 and data[1]!=0 and len(data[5])>0 and len(data[6])>0
825
826 def _handleNormal(self, data, extra):
827 """Handle the reply to the normal request.
828
829 At the beginning the result consists the data for normalData. When
830 monitoring is started, it contains the result also for the
831 aircraft-specific values.
832 """
833 timestamp = Simulator._getTimestamp(data)
834
835 createdNewModel = self._setAircraftName(timestamp, data[5], data[6])
836 if self._fuelCallback is not None:
837 self._aircraftModel.getFuel(self._handler, self._fuelCallback)
838 self._fuelCallback = None
839
840 self._scroll = data[7]!=0
841
842 if self._monitoringRequested and not self._monitoring:
843 self._stopNormal()
844 self._startMonitoring()
845 elif self._monitoring and not self._monitoringRequested:
846 self._stopNormal()
847 self._startDefaultNormal()
848 elif self._monitoring and self._aircraftModel is not None and \
849 not createdNewModel:
850 aircraftState = self._aircraftModel.getAircraftState(self._aircraft,
851 timestamp, data)
852
853 self._checkTimeSync(aircraftState)
854
855 self._aircraft.handleState(aircraftState)
856
857 def _checkTimeSync(self, aircraftState):
858 """Check if we need to synchronize the FS time."""
859 if not self._syncTime or aircraftState.paused or \
860 self._flareRequestID is not None:
861 self._nextSyncTime = -1
862 return
863
864 now = time.time()
865 seconds = time.gmtime(now).tm_sec
866
867 if seconds>30 and seconds<59:
868 if self._nextSyncTime > (now - 0.49):
869 return
870
871 self._handler.requestWrite([(0x023a, "b", int(seconds))],
872 self._handleTimeSynced)
873
874 #print "Set the seconds to ", seconds
875
876 if self._nextSyncTime<0:
877 self._nextSyncTime = now
878
879 self._nextSyncTime += Simulator.TIME_SYNC_INTERVAL
880 else:
881 self._nextSyncTime = -1
882
883 def _handleTimeSynced(self, success, extra):
884 """Callback for the time sync result."""
885 pass
886
887 def _setAircraftName(self, timestamp, name, airPath):
888 """Set the name of the aicraft and if it is different from the
889 previous, create a new model for it.
890
891 If so, also notifty the aircraft about the change.
892
893 Return if a new model was created."""
894 aircraftName = (name, airPath)
895 if aircraftName==self._aircraftName:
896 return False
897
898 self._aircraftName = aircraftName
899 needNew = self._aircraftModel is None
900 needNew = needNew or\
901 not self._aircraftModel.doesHandle(self._aircraft, aircraftName)
902 if not needNew:
903 specialModel = AircraftModel.findSpecial(self._aircraft, aircraftName)
904 needNew = specialModel is not None and \
905 specialModel is not self._aircraftModel.__class__
906
907 if needNew:
908 self._setAircraftModel(AircraftModel.create(self._aircraft, aircraftName))
909
910
911 self._aircraft.modelChanged(timestamp, self._latin1decoder(name)[0],
912 self._aircraftModel.name)
913
914 return needNew
915
916 def _setAircraftModel(self, model):
917 """Set a new aircraft model.
918
919 It will be queried for the data to monitor and the monitoring request
920 will be replaced by a new one."""
921 self._aircraftModel = model
922
923 if self._monitoring:
924 self._stopNormal()
925 self._startMonitoring()
926
927 def _startMonitoring(self):
928 """Start monitoring with the current aircraft model."""
929 data = Simulator.normalData[:]
930 self._aircraftModel.addMonitoringData(data, self._fsType)
931
932 self._normalRequestID = \
933 self._handler.requestPeriodicRead(1.0, data,
934 self._handleNormal,
935 validator = self._validateNormal)
936 self._monitoring = True
937
938 def _addFlareRate(self, data):
939 """Append a flare rate to the list of last rates."""
940 if len(self._flareRates)>=3:
941 del self._flareRates[0]
942 self._flareRates.append(Handler.fsuipc2VS(data))
943
944 def _handleFlare1(self, data, normal):
945 """Handle the first stage of flare monitoring."""
946 #self._aircraft.logger.debug("handleFlare1: " + str(data))
947 if Handler.fsuipc2radioAltitude(data[1])<=50.0:
948 self._flareStart = time.time()
949 self._flareStartFS = data[0]
950 self._handler.clearPeriodic(self._flareRequestID)
951 self._flareRequestID = \
952 self._handler.requestPeriodicRead(0.1,
953 Simulator.flareData2,
954 self._handleFlare2)
955 self._handler.requestRead(Simulator.flareStartData,
956 self._handleFlareStart)
957
958 self._addFlareRate(data[2])
959
960 def _handleFlareStart(self, data, extra):
961 """Handle the data need to notify the aircraft about the starting of
962 the flare."""
963 #self._aircraft.logger.debug("handleFlareStart: " + str(data))
964 if data is not None:
965 windDirection = data[1]*360.0/65536.0
966 if windDirection<0.0: windDirection += 360.0
967 self._aircraft.flareStarted(data[0], windDirection,
968 data[2]*1609.344/100.0,
969 self._flareStart, self._flareStartFS)
970
971 def _handleFlare2(self, data, normal):
972 """Handle the first stage of flare monitoring."""
973 #self._aircraft.logger.debug("handleFlare2: " + str(data))
974 if data[1]!=0:
975 flareEnd = time.time()
976 self._handler.clearPeriodic(self._flareRequestID)
977 self._flareRequestID = None
978
979 flareEndFS = data[0]
980 if flareEndFS<self._flareStartFS:
981 flareEndFS += 60
982
983 tdRate = Handler.fsuipc2VS(data[3])
984 tdRateCalculatedByFS = True
985 if tdRate==0 or tdRate>1000.0 or tdRate<-1000.0:
986 tdRate = min(self._flareRates)
987 tdRateCalculatedByFS = False
988
989 self._aircraft.flareFinished(flareEnd, flareEndFS,
990 tdRate, tdRateCalculatedByFS,
991 Handler.fsuipc2IAS(data[4]),
992 Handler.fsuipc2Degrees(data[5]),
993 Handler.fsuipc2Degrees(data[6]),
994 Handler.fsuipc2PositiveDegrees(data[7]))
995 else:
996 self._addFlareRate(data[2])
997
998 def _handleZFW(self, data, callback):
999 """Callback for a ZFW retrieval request."""
1000 zfw = data[0] * const.LBSTOKG / 256.0
1001 callback(zfw)
1002
1003 def _handleTime(self, data, callback):
1004 """Callback for a time retrieval request."""
1005 callback(Simulator._getTimestamp(data))
1006
1007 def _handlePayloadCount(self, data, callback):
1008 """Callback for the payload count retrieval request."""
1009 payloadCount = data[0]
1010 data = [(0x3bfc, "d"), (0x30c0, "f")]
1011 for i in range(0, payloadCount):
1012 data.append((0x1400 + i*48, "f"))
1013
1014 self._handler.requestRead(data, self._handleWeights,
1015 extra = callback)
1016
1017 def _handleWeights(self, data, callback):
1018 """Callback for the weights retrieval request."""
1019 zfw = data[0] * const.LBSTOKG / 256.0
1020 grossWeight = data[1] * const.LBSTOKG
1021 payload = sum(data[2:]) * const.LBSTOKG
1022 dow = zfw - payload
1023 callback(dow, payload, zfw, grossWeight)
1024
1025 def _handleMessageSent(self, success, disconnect):
1026 """Callback for a message sending request."""
1027 #print "fsuipc.Simulator._handleMessageSent", disconnect
1028 if disconnect:
1029 self._handler.disconnect()
1030
1031 def _handleNumHotkeys(self, data, (id, generation)):
1032 """Handle the result of the query of the number of hotkeys"""
1033 with self._hotkeyLock:
1034 if id==self._hotkeySetID and generation==self._hotkeySetGeneration:
1035 numHotkeys = data[0]
1036 print "fsuipc.Simulator._handleNumHotkeys: numHotkeys:", numHotkeys
1037 data = [(0x3210 + i*4, "d") for i in range(0, numHotkeys)]
1038 self._handler.requestRead(data, self._handleHotkeyTable,
1039 (id, generation))
1040
1041 def _setupHotkeys(self, data):
1042 """Setup the hiven hotkeys and return the data to be written.
1043
1044 If there were hotkeys set previously, they are reused as much as
1045 possible. Any of them not reused will be cleared."""
1046 hotkeys = self._hotkeys
1047 numHotkeys = len(hotkeys)
1048
1049 oldHotkeyOffsets = set([] if self._hotkeyOffets is None else
1050 self._hotkeyOffets)
1051
1052 self._hotkeyOffets = []
1053 numOffsets = 0
1054
1055 while oldHotkeyOffsets:
1056 offset = oldHotkeyOffsets.pop()
1057 self._hotkeyOffets.append(offset)
1058 numOffsets += 1
1059
1060 if numOffsets>=numHotkeys:
1061 break
1062
1063 for i in range(0, len(data)):
1064 if numOffsets>=numHotkeys:
1065 break
1066
1067 if data[i]==0:
1068 self._hotkeyOffets.append(0x3210 + i*4)
1069 numOffsets += 1
1070
1071 writeData = []
1072 for i in range(0, numOffsets):
1073 Simulator._appendHotkeyData(writeData,
1074 self._hotkeyOffets[i],
1075 hotkeys[i])
1076
1077 for offset in oldHotkeyOffsets:
1078 writeData.append((offset, "u", long(0)))
1079
1080 return writeData
1081
1082 def _handleHotkeyTable(self, data, (id, generation)):
1083 """Handle the result of the query of the hotkey table."""
1084 with self._hotkeyLock:
1085 if id==self._hotkeySetID and generation==self._hotkeySetGeneration:
1086 writeData = self._setupHotkeys(data)
1087 self._handler.requestWrite(writeData,
1088 self._handleHotkeysWritten,
1089 (id, generation))
1090
1091 def _handleHotkeysWritten(self, success, (id, generation)):
1092 """Handle the result of the hotkeys having been written."""
1093 with self._hotkeyLock:
1094 if success and id==self._hotkeySetID and \
1095 generation==self._hotkeySetGeneration:
1096 data = [(offset + 3, "b") for offset in self._hotkeyOffets]
1097
1098 self._hotkeyRequestID = \
1099 self._handler.requestPeriodicRead(0.5, data,
1100 self._handleHotkeys,
1101 (id, generation))
1102
1103 def _handleHotkeys(self, data, (id, generation)):
1104 """Handle the hotkeys."""
1105 with self._hotkeyLock:
1106 if id!=self._hotkeySetID or generation!=self._hotkeySetGeneration:
1107 return
1108
1109 callback = self._hotkeyCallback
1110 offsets = self._hotkeyOffets
1111
1112 hotkeysPressed = []
1113 for i in range(0, len(data)):
1114 if data[i]!=0:
1115 hotkeysPressed.append(i)
1116
1117 if hotkeysPressed:
1118 data = []
1119 for index in hotkeysPressed:
1120 data.append((offsets[index]+3, "b", int(0)))
1121 self._handler.requestWrite(data, self._handleHotkeysCleared)
1122
1123 callback(id, hotkeysPressed)
1124
1125 def _handleHotkeysCleared(self, sucess, extra):
1126 """Callback for the hotkey-clearing write request."""
1127
1128 def _clearHotkeyRequest(self):
1129 """Clear the hotkey request in the handler if there is any."""
1130 if self._hotkeyRequestID is not None:
1131 self._handler.clearPeriodic(self._hotkeyRequestID)
1132 self._hotkeyRequestID = None
1133
1134#------------------------------------------------------------------------------
1135
1136class AircraftModel(object):
1137 """Base class for the aircraft models.
1138
1139 Aircraft models handle the data arriving from FSUIPC and turn it into an
1140 object describing the aircraft's state."""
1141 monitoringData = [("paused", 0x0264, "H"),
1142 ("latitude", 0x0560, "l"),
1143 ("longitude", 0x0568, "l"),
1144 ("frozen", 0x3364, "H"),
1145 ("replay", 0x0628, "d"),
1146 ("slew", 0x05dc, "H"),
1147 ("overspeed", 0x036d, "b"),
1148 ("stalled", 0x036c, "b"),
1149 ("onTheGround", 0x0366, "H"),
1150 ("zfw", 0x3bfc, "d"),
1151 ("grossWeight", 0x30c0, "f"),
1152 ("heading", 0x0580, "d"),
1153 ("pitch", 0x0578, "d"),
1154 ("bank", 0x057c, "d"),
1155 ("ias", 0x02bc, "d"),
1156 ("mach", 0x11c6, "H"),
1157 ("groundSpeed", 0x02b4, "d"),
1158 ("vs", 0x02c8, "d"),
1159 ("radioAltitude", 0x31e4, "d"),
1160 ("altitude", 0x0570, "l"),
1161 ("gLoad", 0x11ba, "H"),
1162 ("flapsControl", 0x0bdc, "d"),
1163 ("flapsLeft", 0x0be0, "d"),
1164 ("flapsRight", 0x0be4, "d"),
1165 ("lights", 0x0d0c, "H"),
1166 ("pitot", 0x029c, "b"),
1167 ("parking", 0x0bc8, "H"),
1168 ("gearControl", 0x0be8, "d"),
1169 ("noseGear", 0x0bec, "d"),
1170 ("spoilersArmed", 0x0bcc, "d"),
1171 ("spoilers", 0x0bd0, "d"),
1172 ("altimeter", 0x0330, "H"),
1173 ("nav1", 0x0350, "H"),
1174 ("nav2", 0x0352, "H"),
1175 ("squawk", 0x0354, "H"),
1176 ("windSpeed", 0x0e90, "H"),
1177 ("windDirection", 0x0e92, "H"),
1178 ("visibility", 0x0e8a, "H"),
1179 ("cog", 0x2ef8, "f")]
1180
1181 specialModels = []
1182
1183 @staticmethod
1184 def registerSpecial(clazz):
1185 """Register the given class as a special model."""
1186 AircraftModel.specialModels.append(clazz)
1187
1188 @staticmethod
1189 def findSpecial(aircraft, aircraftName):
1190 for specialModel in AircraftModel.specialModels:
1191 if specialModel.doesHandle(aircraft, aircraftName):
1192 return specialModel
1193 return None
1194
1195 @staticmethod
1196 def create(aircraft, aircraftName):
1197 """Create the model for the given aircraft name, and notify the
1198 aircraft about it."""
1199 specialModel = AircraftModel.findSpecial(aircraft, aircraftName)
1200 if specialModel is not None:
1201 return specialModel()
1202 if aircraft.type in _genericModels:
1203 return _genericModels[aircraft.type]()
1204 else:
1205 return GenericModel()
1206
1207 @staticmethod
1208 def convertBCD(data, length):
1209 """Convert a data item encoded as BCD into a string of the given number
1210 of digits."""
1211 bcd = ""
1212 for i in range(0, length):
1213 digit = chr(ord('0') + (data&0x0f))
1214 data >>= 4
1215 bcd = digit + bcd
1216 return bcd
1217
1218 @staticmethod
1219 def convertFrequency(data):
1220 """Convert the given frequency data to a string."""
1221 bcd = AircraftModel.convertBCD(data, 4)
1222 return "1" + bcd[0:2] + "." + bcd[2:4]
1223
1224 def __init__(self, flapsNotches):
1225 """Construct the aircraft model.
1226
1227 flapsNotches is a list of degrees of flaps that are available on the aircraft."""
1228 self._flapsNotches = flapsNotches
1229
1230 @property
1231 def name(self):
1232 """Get the name for this aircraft model."""
1233 return "FSUIPC/Generic"
1234
1235 def doesHandle(self, aircraft, aircraftName):
1236 """Determine if the model handles the given aircraft name.
1237
1238 This default implementation returns False."""
1239 return False
1240
1241 def _addOffsetWithIndexMember(self, dest, offset, type, attrName = None):
1242 """Add the given FSUIPC offset and type to the given array and a member
1243 attribute with the given name."""
1244 dest.append((offset, type))
1245 if attrName is not None:
1246 setattr(self, attrName, len(dest)-1)
1247
1248 def _addDataWithIndexMembers(self, dest, prefix, data):
1249 """Add FSUIPC data to the given array and also corresponding index
1250 member variables with the given prefix.
1251
1252 data is a list of triplets of the following items:
1253 - the name of the data item. The index member variable will have a name
1254 created by prepending the given prefix to this name.
1255 - the FSUIPC offset
1256 - the FSUIPC type
1257
1258 The latter two items will be appended to dest."""
1259 for (name, offset, type) in data:
1260 self._addOffsetWithIndexMember(dest, offset, type, prefix + name)
1261
1262 def addMonitoringData(self, data, fsType):
1263 """Add the model-specific monitoring data to the given array."""
1264 self._addDataWithIndexMembers(data, "_monidx_",
1265 AircraftModel.monitoringData)
1266
1267 def getAircraftState(self, aircraft, timestamp, data):
1268 """Get an aircraft state object for the given monitoring data."""
1269 state = fs.AircraftState()
1270
1271 state.timestamp = timestamp
1272
1273 state.latitude = data[self._monidx_latitude] * \
1274 90.0 / 10001750.0 / 65536.0 / 65536.0
1275
1276 state.longitude = data[self._monidx_longitude] * \
1277 360.0 / 65536.0 / 65536.0 / 65536.0 / 65536.0
1278 if state.longitude>180.0: state.longitude = 360.0 - state.longitude
1279
1280 state.paused = data[self._monidx_paused]!=0 or \
1281 data[self._monidx_frozen]!=0 or \
1282 data[self._monidx_replay]!=0
1283 state.trickMode = data[self._monidx_slew]!=0
1284
1285 state.overspeed = data[self._monidx_overspeed]!=0
1286 state.stalled = data[self._monidx_stalled]!=0
1287 state.onTheGround = data[self._monidx_onTheGround]!=0
1288
1289 state.zfw = data[self._monidx_zfw] * const.LBSTOKG / 256.0
1290 state.grossWeight = data[self._monidx_grossWeight] * const.LBSTOKG
1291
1292 state.heading = Handler.fsuipc2PositiveDegrees(data[self._monidx_heading])
1293
1294 state.pitch = Handler.fsuipc2Degrees(data[self._monidx_pitch])
1295 state.bank = Handler.fsuipc2Degrees(data[self._monidx_bank])
1296
1297 state.ias = Handler.fsuipc2IAS(data[self._monidx_ias])
1298 state.mach = data[self._monidx_mach] / 20480.0
1299 state.groundSpeed = data[self._monidx_groundSpeed]* 3600.0/65536.0/1852.0
1300 state.vs = Handler.fsuipc2VS(data[self._monidx_vs])
1301
1302 state.radioAltitude = \
1303 Handler.fsuipc2radioAltitude(data[self._monidx_radioAltitude])
1304 state.altitude = data[self._monidx_altitude]/const.FEETTOMETRES/65536.0/65536.0
1305
1306 state.gLoad = data[self._monidx_gLoad] / 625.0
1307
1308 numNotchesM1 = len(self._flapsNotches) - 1
1309 flapsIncrement = 16383 / numNotchesM1
1310 flapsControl = data[self._monidx_flapsControl]
1311 flapsIndex = flapsControl / flapsIncrement
1312 if flapsIndex < numNotchesM1:
1313 if (flapsControl - (flapsIndex*flapsIncrement) >
1314 (flapsIndex+1)*flapsIncrement - flapsControl):
1315 flapsIndex += 1
1316 state.flapsSet = self._flapsNotches[flapsIndex]
1317
1318 flapsLeft = data[self._monidx_flapsLeft]
1319 state.flaps = self._flapsNotches[-1]*flapsLeft/16383.0
1320
1321 lights = data[self._monidx_lights]
1322
1323 state.navLightsOn = (lights&0x01) != 0
1324 state.antiCollisionLightsOn = (lights&0x02) != 0
1325 state.landingLightsOn = (lights&0x04) != 0
1326 state.strobeLightsOn = (lights&0x10) != 0
1327
1328 state.pitotHeatOn = data[self._monidx_pitot]!=0
1329
1330 state.parking = data[self._monidx_parking]!=0
1331
1332 state.gearControlDown = data[self._monidx_gearControl]==16383
1333 state.gearsDown = data[self._monidx_noseGear]==16383
1334
1335 state.spoilersArmed = data[self._monidx_spoilersArmed]!=0
1336
1337 spoilers = data[self._monidx_spoilers]
1338 if spoilers<=4800:
1339 state.spoilersExtension = 0.0
1340 else:
1341 state.spoilersExtension = (spoilers - 4800) * 100.0 / (16383 - 4800)
1342
1343 state.altimeter = data[self._monidx_altimeter] / 16.0
1344
1345 state.nav1 = AircraftModel.convertFrequency(data[self._monidx_nav1])
1346 state.nav2 = AircraftModel.convertFrequency(data[self._monidx_nav2])
1347 state.squawk = AircraftModel.convertBCD(data[self._monidx_squawk], 4)
1348
1349 state.windSpeed = data[self._monidx_windSpeed]
1350 state.windDirection = data[self._monidx_windDirection]*360.0/65536.0
1351 if state.windDirection<0.0: state.windDirection += 360.0
1352
1353 state.visibility = data[self._monidx_visibility]*1609.344/100.0
1354
1355 state.cog = data[self._monidx_cog]
1356
1357 return state
1358
1359#------------------------------------------------------------------------------
1360
1361class GenericAircraftModel(AircraftModel):
1362 """A generic aircraft model that can handle the fuel levels, the N1 or RPM
1363 values and some other common parameters in a generic way."""
1364
1365 def __init__(self, flapsNotches, fuelTanks, numEngines, isN1 = True):
1366 """Construct the generic aircraft model with the given data.
1367
1368 flapsNotches is an array of how much degrees the individual flaps
1369 notches mean.
1370
1371 fuelTanks is an array of const.FUELTANK_XXX constants about the
1372 aircraft's fuel tanks. They will be converted to offsets.
1373
1374 numEngines is the number of engines the aircraft has.
1375
1376 isN1 determines if the engines have an N1 value or an RPM value
1377 (e.g. pistons)."""
1378 super(GenericAircraftModel, self).__init__(flapsNotches = flapsNotches)
1379
1380 self._fuelTanks = fuelTanks
1381 self._fuelStartIndex = None
1382 self._numEngines = numEngines
1383 self._engineStartIndex = None
1384 self._isN1 = isN1
1385
1386 def doesHandle(self, aircraft, aircraftName):
1387 """Determine if the model handles the given aircraft name.
1388
1389 This implementation returns True."""
1390 return True
1391
1392 def addMonitoringData(self, data, fsType):
1393 """Add the model-specific monitoring data to the given array."""
1394 super(GenericAircraftModel, self).addMonitoringData(data, fsType)
1395
1396 self._fuelStartIndex = self._addFuelOffsets(data, "_monidx_fuelWeight")
1397
1398 self._engineStartIndex = len(data)
1399 for i in range(0, self._numEngines):
1400 self._addOffsetWithIndexMember(data, 0x088c + i * 0x98, "h") # throttle lever
1401 if self._isN1:
1402 self._addOffsetWithIndexMember(data, 0x2000 + i * 0x100, "f") # N1
1403 else:
1404 self._addOffsetWithIndexMember(data, 0x0898 + i * 0x98, "H") # RPM
1405 self._addOffsetWithIndexMember(data, 0x08c8 + i * 0x98, "H") # RPM scaler
1406
1407 def getAircraftState(self, aircraft, timestamp, data):
1408 """Get the aircraft state.
1409
1410 Get it from the parent, and then add the data about the fuel levels and
1411 the engine parameters."""
1412 state = super(GenericAircraftModel, self).getAircraftState(aircraft,
1413 timestamp,
1414 data)
1415
1416 (state.fuel, state.totalFuel) = \
1417 self._convertFuelData(data, index = self._monidx_fuelWeight)
1418
1419 state.n1 = [] if self._isN1 else None
1420 state.rpm = None if self._isN1 else []
1421 itemsPerEngine = 2 if self._isN1 else 3
1422
1423 state.reverser = []
1424 for i in range(self._engineStartIndex,
1425 self._engineStartIndex +
1426 itemsPerEngine*self._numEngines,
1427 itemsPerEngine):
1428 state.reverser.append(data[i]<0)
1429 if self._isN1:
1430 state.n1.append(data[i+1])
1431 else:
1432 state.rpm.append(data[i+1] * data[i+2]/65536.0)
1433
1434 return state
1435
1436 def getFuel(self, handler, callback):
1437 """Get the fuel information for this model.
1438
1439 See Simulator.getFuel for more information. This
1440 implementation simply queries the fuel tanks given to the
1441 constructor."""
1442 data = []
1443 self._addFuelOffsets(data)
1444
1445 handler.requestRead(data, self._handleFuelRetrieved,
1446 extra = callback)
1447
1448 def setFuelLevel(self, handler, levels):
1449 """Set the fuel level.
1450
1451 See the description of Simulator.setFuelLevel. This
1452 implementation simply sets the fuel tanks as given."""
1453 data = []
1454 for (tank, level) in levels:
1455 offset = _tank2offset[tank]
1456 value = long(level * 128.0 * 65536.0)
1457 data.append( (offset, "u", value) )
1458
1459 handler.requestWrite(data, self._handleFuelWritten)
1460
1461 def _addFuelOffsets(self, data, weightIndexName = None):
1462 """Add the fuel offsets to the given data array.
1463
1464 If weightIndexName is not None, it will be the name of the
1465 fuel weight index.
1466
1467 Returns the index of the first fuel tank's data."""
1468 self._addOffsetWithIndexMember(data, 0x0af4, "H", weightIndexName)
1469
1470 fuelStartIndex = len(data)
1471 for tank in self._fuelTanks:
1472 offset = _tank2offset[tank]
1473 self._addOffsetWithIndexMember(data, offset, "u") # tank level
1474 self._addOffsetWithIndexMember(data, offset+4, "u") # tank capacity
1475
1476 return fuelStartIndex
1477
1478 def _convertFuelData(self, data, index = 0, addCapacities = False):
1479 """Convert the given data into a fuel info list.
1480
1481 The list consists of two or three-tuples of the following
1482 items:
1483 - the fuel tank ID,
1484 - the amount of the fuel in kg,
1485 - if addCapacities is True, the total capacity of the tank."""
1486 fuelWeight = data[index] / 256.0
1487 index += 1
1488
1489 result = []
1490 totalFuel = 0
1491 for fuelTank in self._fuelTanks:
1492 capacity = data[index+1] * fuelWeight * const.LBSTOKG
1493 amount = data[index] * capacity / 128.0 / 65536.0
1494 index += 2
1495
1496 result.append( (fuelTank, amount, capacity) if addCapacities
1497 else (fuelTank, amount))
1498 totalFuel += amount
1499
1500 return (result, totalFuel)
1501
1502 def _handleFuelRetrieved(self, data, callback):
1503 """Callback for a fuel retrieval request."""
1504 (fuelData, _totalFuel) = self._convertFuelData(data,
1505 addCapacities = True)
1506 callback(fuelData)
1507
1508 def _handleFuelWritten(self, success, extra):
1509 """Callback for a fuel setting request."""
1510 pass
1511
1512#------------------------------------------------------------------------------
1513
1514class GenericModel(GenericAircraftModel):
1515 """Generic aircraft model for an unknown type."""
1516 def __init__(self):
1517 """Construct the model."""
1518 super(GenericModel, self). \
1519 __init__(flapsNotches = [0, 10, 20, 30],
1520 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_RIGHT],
1521 numEngines = 2)
1522
1523 @property
1524 def name(self):
1525 """Get the name for this aircraft model."""
1526 return "FSUIPC/Generic"
1527
1528#------------------------------------------------------------------------------
1529
1530class B737Model(GenericAircraftModel):
1531 """Generic model for the Boeing 737 Classing and NG aircraft."""
1532 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
1533
1534 def __init__(self):
1535 """Construct the model."""
1536 super(B737Model, self). \
1537 __init__(flapsNotches = [0, 1, 2, 5, 10, 15, 25, 30, 40],
1538 fuelTanks = B737Model.fuelTanks,
1539 numEngines = 2)
1540
1541 @property
1542 def name(self):
1543 """Get the name for this aircraft model."""
1544 return "FSUIPC/Generic Boeing 737"
1545
1546#------------------------------------------------------------------------------
1547
1548class PMDGBoeing737NGModel(B737Model):
1549 """A model handler for the PMDG Boeing 737NG model."""
1550 @staticmethod
1551 def doesHandle(aircraft, (name, airPath)):
1552 """Determine if this model handler handles the aircraft with the given
1553 name."""
1554 return aircraft.type in [const.AIRCRAFT_B736,
1555 const.AIRCRAFT_B737,
1556 const.AIRCRAFT_B738,
1557 const.AIRCRAFT_B738C] and \
1558 (name.find("PMDG")!=-1 or airPath.find("PMDG")!=-1) and \
1559 (name.find("737")!=-1 or airPath.find("737")!=-1) and \
1560 (name.find("600")!=-1 or airPath.find("600")!=-1 or \
1561 name.find("700")!=-1 or airPath.find("700")!=-1 or \
1562 name.find("800")!=-1 or airPath.find("800")!=-1 or \
1563 name.find("900")!=-1 or airPath.find("900")!=-1)
1564
1565 @property
1566 def name(self):
1567 """Get the name for this aircraft model."""
1568 return "FSUIPC/PMDG Boeing 737NG(X)"
1569
1570 def addMonitoringData(self, data, fsType):
1571 """Add the model-specific monitoring data to the given array."""
1572 self._fsType = fsType
1573
1574 super(PMDGBoeing737NGModel, self).addMonitoringData(data, fsType)
1575
1576 self._addOffsetWithIndexMember(data, 0x6202, "b", "_pmdgidx_switches")
1577
1578 if fsType==const.SIM_MSFSX:
1579 print "FSX detected, adding position lights switch offset"
1580 self._addOffsetWithIndexMember(data, 0x6500, "b",
1581 "_pmdgidx_lts_positionsw")
1582
1583 def getAircraftState(self, aircraft, timestamp, data):
1584 """Get the aircraft state.
1585
1586 Get it from the parent, and then check some PMDG-specific stuff."""
1587 state = super(PMDGBoeing737NGModel, self).getAircraftState(aircraft,
1588 timestamp,
1589 data)
1590 if data[self._pmdgidx_switches]&0x01==0x01:
1591 state.altimeter = 1013.25
1592
1593 if self._fsType==const.SIM_MSFSX:
1594 state.strobeLightsOn = data[self._pmdgidx_lts_positionsw]==0x02
1595
1596 return state
1597
1598#------------------------------------------------------------------------------
1599
1600class B767Model(GenericAircraftModel):
1601 """Generic model for the Boeing 767 aircraft."""
1602 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
1603
1604 def __init__(self):
1605 """Construct the model."""
1606 super(B767Model, self). \
1607 __init__(flapsNotches = [0, 1, 5, 15, 20, 25, 30],
1608 fuelTanks = Boeing767Model.fuelTanks,
1609 numEngines = 2)
1610
1611 @property
1612 def name(self):
1613 """Get the name for this aircraft model."""
1614 return "FSUIPC/Generic Boeing 767"
1615
1616#------------------------------------------------------------------------------
1617
1618class DH8DModel(GenericAircraftModel):
1619 """Generic model for the Bombardier Dash 8-Q400 aircraft."""
1620 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_RIGHT]
1621
1622 def __init__(self):
1623 """Construct the model."""
1624 super(DH8DModel, self). \
1625 __init__(flapsNotches = [0, 5, 10, 15, 35],
1626 fuelTanks = DH8DModel.fuelTanks,
1627 numEngines = 2)
1628
1629 @property
1630 def name(self):
1631 """Get the name for this aircraft model."""
1632 return "FSUIPC/Generic Bombardier Dash 8-Q400"
1633
1634#------------------------------------------------------------------------------
1635
1636class DreamwingsDH8DModel(DH8DModel):
1637 """Model handler for the Dreamwings Dash 8-Q400."""
1638 @staticmethod
1639 def doesHandle(aircraft, (name, airPath)):
1640 """Determine if this model handler handles the aircraft with the given
1641 name."""
1642 return aircraft.type==const.AIRCRAFT_DH8D and \
1643 (name.find("Dreamwings")!=-1 or airPath.find("Dreamwings")!=-1) and \
1644 (name.find("Dash")!=-1 or airPath.find("Dash")!=-1) and \
1645 (name.find("Q400")!=-1 or airPath.find("Q400")!=-1) and \
1646 airPath.find("Dash8Q400")!=-1
1647
1648 @property
1649 def name(self):
1650 """Get the name for this aircraft model."""
1651 return "FSUIPC/Dreamwings Bombardier Dash 8-Q400"
1652
1653 def getAircraftState(self, aircraft, timestamp, data):
1654 """Get the aircraft state.
1655
1656 Get it from the parent, and then invert the pitot heat state."""
1657 state = super(DreamwingsDH8DModel, self).getAircraftState(aircraft,
1658 timestamp,
1659 data)
1660 state.pitotHeatOn = not state.pitotHeatOn
1661
1662 return state
1663#------------------------------------------------------------------------------
1664
1665class CRJ2Model(GenericAircraftModel):
1666 """Generic model for the Bombardier CRJ-200 aircraft."""
1667 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
1668
1669 def __init__(self):
1670 """Construct the model."""
1671 super(CRJ2Model, self). \
1672 __init__(flapsNotches = [0, 8, 20, 30, 45],
1673 fuelTanks = CRJ2Model.fuelTanks,
1674 numEngines = 2)
1675
1676 @property
1677 def name(self):
1678 """Get the name for this aircraft model."""
1679 return "FSUIPC/Generic Bombardier CRJ-200"
1680
1681#------------------------------------------------------------------------------
1682
1683class F70Model(GenericAircraftModel):
1684 """Generic model for the Fokker F70 aircraft."""
1685 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
1686
1687 def __init__(self):
1688 """Construct the model."""
1689 super(F70Model, self). \
1690 __init__(flapsNotches = [0, 8, 15, 25, 42],
1691 fuelTanks = F70Model.fuelTanks,
1692 numEngines = 2)
1693
1694 @property
1695 def name(self):
1696 """Get the name for this aircraft model."""
1697 return "FSUIPC/Generic Fokker 70"
1698
1699#------------------------------------------------------------------------------
1700
1701class DC3Model(GenericAircraftModel):
1702 """Generic model for the Lisunov Li-2 (DC-3) aircraft."""
1703 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE,
1704 const.FUELTANK_RIGHT]
1705 # fuelTanks = [const.FUELTANK_LEFT_AUX, const.FUELTANK_LEFT,
1706 # const.FUELTANK_RIGHT, const.FUELTANK_RIGHT_AUX]
1707
1708 def __init__(self):
1709 """Construct the model."""
1710 super(DC3Model, self). \
1711 __init__(flapsNotches = [0, 15, 30, 45],
1712 fuelTanks = DC3Model.fuelTanks,
1713 numEngines = 2, isN1 = False)
1714 self._leftLevel = 0.0
1715 self._rightLevel = 0.0
1716
1717 @property
1718 def name(self):
1719 """Get the name for this aircraft model."""
1720 return "FSUIPC/Generic Lisunov Li-2 (DC-3)"
1721
1722 def _convertFuelData(self, data, index = 0, addCapacities = False):
1723 """Convert the given data into a fuel info list.
1724
1725 It assumes to receive the 3 fuel tanks as seen above (left,
1726 centre and right) and converts it to left aux, left, right,
1727 and right aux. The amount in the left tank goes into left aux,
1728 the amount of the right tank goes into right aux and the
1729 amount of the centre tank goes into the left and right tanks
1730 evenly distributed."""
1731 (rawFuelData, totalFuel) = \
1732 super(DC3Model, self)._convertFuelData(data, index, addCapacities)
1733
1734 centreAmount = rawFuelData[1][1]
1735 if addCapacities:
1736 centreCapacity = rawFuelData[1][2]
1737 self._leftLevel = self._rightLevel = \
1738 centreAmount / centreCapacity / 2.0
1739 fuelData = [(const.FUELTANK_LEFT_AUX,
1740 rawFuelData[0][1], rawFuelData[0][2]),
1741 (const.FUELTANK_LEFT,
1742 centreAmount/2.0, centreCapacity/2.0),
1743 (const.FUELTANK_RIGHT,
1744 centreAmount/2.0, centreCapacity/2.0),
1745 (const.FUELTANK_RIGHT_AUX,
1746 rawFuelData[2][1], rawFuelData[2][2])]
1747 else:
1748 fuelData = [(const.FUELTANK_LEFT_AUX, rawFuelData[0][1]),
1749 (const.FUELTANK_LEFT, centreAmount/2.0),
1750 (const.FUELTANK_RIGHT, centreAmount/2.0),
1751 (const.FUELTANK_RIGHT_AUX, rawFuelData[2][1])]
1752
1753 return (fuelData, totalFuel)
1754
1755 def setFuelLevel(self, handler, levels):
1756 """Set the fuel level.
1757
1758 See the description of Simulator.setFuelLevel. This
1759 implementation assumes to get the four-tank representation,
1760 as returned by getFuel()."""
1761 leftLevel = None
1762 centreLevel = None
1763 rightLevel = None
1764
1765 for (tank, level) in levels:
1766 if tank==const.FUELTANK_LEFT_AUX:
1767 leftLevel = level if leftLevel is None else (leftLevel + level)
1768 elif tank==const.FUELTANK_LEFT:
1769 level /= 2.0
1770 centreLevel = (self._rightLevel + level) \
1771 if centreLevel is None else (centreLevel + level)
1772 self._leftLevel = level
1773 elif tank==const.FUELTANK_RIGHT:
1774 level /= 2.0
1775 centreLevel = (self._leftLevel + level) \
1776 if centreLevel is None else (centreLevel + level)
1777 self._rightLevel = level
1778 elif tank==const.FUELTANK_RIGHT_AUX:
1779 rightLevel = level if rightLevel is None \
1780 else (rightLevel + level)
1781
1782 levels = []
1783 if leftLevel is not None: levels.append((const.FUELTANK_LEFT,
1784 leftLevel))
1785 if centreLevel is not None: levels.append((const.FUELTANK_CENTRE,
1786 centreLevel))
1787 if rightLevel is not None: levels.append((const.FUELTANK_RIGHT,
1788 rightLevel))
1789
1790 super(DC3Model, self).setFuelLevel(handler, levels)
1791
1792#------------------------------------------------------------------------------
1793
1794class T134Model(GenericAircraftModel):
1795 """Generic model for the Tupolev Tu-134 aircraft."""
1796 fuelTanks = [const.FUELTANK_LEFT_TIP, const.FUELTANK_EXTERNAL1,
1797 const.FUELTANK_LEFT_AUX,
1798 const.FUELTANK_CENTRE,
1799 const.FUELTANK_RIGHT_AUX,
1800 const.FUELTANK_EXTERNAL2, const.FUELTANK_RIGHT_TIP]
1801
1802 def __init__(self):
1803 """Construct the model."""
1804 super(T134Model, self). \
1805 __init__(flapsNotches = [0, 10, 20, 30],
1806 fuelTanks = T134Model.fuelTanks,
1807 numEngines = 2)
1808
1809 @property
1810 def name(self):
1811 """Get the name for this aircraft model."""
1812 return "FSUIPC/Generic Tupolev Tu-134"
1813
1814#------------------------------------------------------------------------------
1815
1816class T154Model(GenericAircraftModel):
1817 """Generic model for the Tupolev Tu-134 aircraft."""
1818 fuelTanks = [const.FUELTANK_LEFT_AUX, const.FUELTANK_LEFT,
1819 const.FUELTANK_CENTRE, const.FUELTANK_CENTRE2,
1820 const.FUELTANK_RIGHT, const.FUELTANK_RIGHT_AUX]
1821
1822 def __init__(self):
1823 """Construct the model."""
1824 super(T154Model, self). \
1825 __init__(flapsNotches = [0, 15, 28, 45],
1826 fuelTanks = T154Model.fuelTanks,
1827 numEngines = 3)
1828
1829 @property
1830 def name(self):
1831 """Get the name for this aircraft model."""
1832 return "FSUIPC/Generic Tupolev Tu-154"
1833
1834 def getAircraftState(self, aircraft, timestamp, data):
1835 """Get an aircraft state object for the given monitoring data.
1836
1837 This removes the reverser value for the middle engine."""
1838 state = super(T154Model, self).getAircraftState(aircraft, timestamp, data)
1839 del state.reverser[1]
1840 return state
1841
1842#------------------------------------------------------------------------------
1843
1844class YK40Model(GenericAircraftModel):
1845 """Generic model for the Yakovlev Yak-40 aircraft."""
1846 fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_RIGHT]
1847
1848 def __init__(self):
1849 """Construct the model."""
1850 super(YK40Model, self). \
1851 __init__(flapsNotches = [0, 20, 35],
1852 fuelTanks = YK40Model.fuelTanks,
1853 numEngines = 2)
1854
1855 @property
1856 def name(self):
1857 """Get the name for this aircraft model."""
1858 return "FSUIPC/Generic Yakovlev Yak-40"
1859
1860#------------------------------------------------------------------------------
1861
1862_genericModels = { const.AIRCRAFT_B736 : B737Model,
1863 const.AIRCRAFT_B737 : B737Model,
1864 const.AIRCRAFT_B738 : B737Model,
1865 const.AIRCRAFT_B738C : B737Model,
1866 const.AIRCRAFT_B733 : B737Model,
1867 const.AIRCRAFT_B734 : B737Model,
1868 const.AIRCRAFT_B735 : B737Model,
1869 const.AIRCRAFT_DH8D : DH8DModel,
1870 const.AIRCRAFT_B762 : B767Model,
1871 const.AIRCRAFT_B763 : B767Model,
1872 const.AIRCRAFT_CRJ2 : B767Model,
1873 const.AIRCRAFT_F70 : F70Model,
1874 const.AIRCRAFT_DC3 : DC3Model,
1875 const.AIRCRAFT_T134 : T134Model,
1876 const.AIRCRAFT_T154 : T154Model,
1877 const.AIRCRAFT_YK40 : YK40Model }
1878
1879#------------------------------------------------------------------------------
1880
1881AircraftModel.registerSpecial(PMDGBoeing737NGModel)
1882AircraftModel.registerSpecial(DreamwingsDH8DModel)
1883
1884#------------------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.