Changeset 5:90eade9afbcb

Timestamp:

01/31/12 18:01:43 (13 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

Added some further data to those queried and reworked a bit the way the model changes are handled

Location:

src

Files:

• acft.py (modified) (4 diffs)
• fs.py (modified) (5 diffs)
• fsuipc.py (modified) (13 diffs)
• test.py (modified) (1 diff)

src/acft.py

@@ -49 +49 @@
 
         if self._aircraftState is None or \
+           self._aircraftState.onTheGround != aircraftState.onTheGround:
+            print "Aircraft.handleState: %s: onTheGround=%d" % \
+                (timeStr, aircraftState.onTheGround)
+
+        if self._aircraftState is None or \
            self._aircraftState.grossWeight != aircraftState.grossWeight:
             print "Aircraft.handleState: %s: grossWeight=%f" % \
@@ -74 +79 @@
 
         if self._aircraftState is None or \
+           self._aircraftState.groundSpeed != aircraftState.groundSpeed:
+            print "Aircraft.handleState: %s: groundSpeed=%f" % \
+                (timeStr, aircraftState.groundSpeed)
+
+        if self._aircraftState is None or \
            self._aircraftState.vs != aircraftState.vs:
             print "Aircraft.handleState: %s: vs=%f" % \
@@ -82 +92 @@
             print "Aircraft.handleState: %s: altitude=%f" % \
                 (timeStr, aircraftState.altitude)
+
+        if self._aircraftState is None or \
+           self._aircraftState.gLoad != aircraftState.gLoad:
+            print "Aircraft.handleState: %s: gLoad=%f" % \
+                (timeStr, aircraftState.gLoad)
 
         if self._aircraftState is None or \
@@ -133 +148 @@
                 (timeStr, aircraftState.spoilersExtension)
 
+        if self._aircraftState is None or \
+           self._aircraftState.altimeter != aircraftState.altimeter:
+            print "Aircraft.handleState: %s: altimeter=%f" % \
+                (timeStr, aircraftState.altimeter)
+
+        if self._aircraftState is None or \
+           self._aircraftState.nav1 != aircraftState.nav1:
+            print "Aircraft.handleState: %s: nav1=%s" % \
+                (timeStr, aircraftState.nav1)
+
+        if self._aircraftState is None or \
+           self._aircraftState.nav2 != aircraftState.nav2:
+            print "Aircraft.handleState: %s: nav2=%s" % \
+                (timeStr, aircraftState.nav2)
+
         self._aircraftState = aircraftState
             

src/fs.py

@@ -25 +25 @@
 #-------------------------------------------------------------------------------
 
-def createSimulator(type, connectionListener):
+def createSimulator(type, connectionListener, aircraft):
     """Create a simulator instance for the given simulator type with the given
     connection listener.
@@ -34 +34 @@
     assert type==const.TYPE_MSFS9, "Only MS Flight Simulator 2004 is supported"
     import fsuipc
-    return fsuipc.Simulator(connectionListener)
+    return fsuipc.Simulator(connectionListener, aircraft)
 
 #-------------------------------------------------------------------------------
@@ -60 +60 @@
     negative means bank right (float)
     - ias: the indicated airspeed in knots (float)    
+    - groundSpeed: the ground speed (float)
     - vs: the vertical speed in feet/minutes (float)
     - altitude: the altitude of the aircraft in feet (float)
+    - gLoad: G-load (float)
     - flapsSet: the selected degrees of the flaps (float)
     - flaps: the actual degrees of the flaps (float)
+    - fuelWeight[]: the fuel weights in the different tanks in kgs (array of
+    floats of as many items as the number fuel tanks)
     - n1[]: the N1 values of the turbine engines (array of floats
     of as many items as the number of engines, present only for aircraft with
@@ -83 +87 @@
     - spoilersExtension: the percentage of how much the spoiler is extended
     (float) 
+    - altimeter: the altimeter setting in hPa (float)
+    - nav1: the frequency of the NAV1 radio in MHz (string)
+    - nav2: the frequency of the NAV1 radio in MHz (string)
 
     FIXME: needed when taxiing only:
     - zfw: the Zero Fuel Weight in klograms (float)
+    - payload weight
 
     FIXME: needed for touchdown only:
@@ -91 +99 @@
     - ambientWindSpeed: the ambient wind speed around the aircraft in knowns (float)
     - tdRate: the touchdown rate calculated by FSUIPC (float)
+
+    FIXME: needed rarely:
+    - latitude, longitude
+    - transporter
+    - visibility 
     """
     

src/fsuipc.py

@@ -340 +340 @@
     """The simulator class representing the interface to the flight simulator
     via FSUIPC."""
-    def __init__(self, connectionListener):
-        """Construct the simulator."""
-        self._handler = Handler(connectionListener)
-        self._handler.start()
-        self._aircraft = None
-        self._aircraftName = None
-        self._aircraftModel = None
-        self._monitoringRequestID = None
-
-    def connect(self):
-        """Initiate a connection to the simulator."""
-        self._handler.connect()
-
-    def startMonitoring(self, aircraft):
-        """Start the periodic monitoring of the aircraft and pass the resulting
-        state to the given aircraft object periodically.
+    # The basic data that should be queried all the time once we are connected
+    normalData = [ (0x3d00, -256) ]
+
+    def __init__(self, connectionListener, aircraft):
+        """Construct the simulator.
         
         The aircraft object passed must provide the following members:
@@ -362 +351 @@
         the aircraft has changed.
         - handleState(aircraftState): handle the given state."""
-        assert self._aircraft is None
-
         self._aircraft = aircraft
-        self._startMonitoring()
+
+        self._handler = Handler(connectionListener)
+        self._handler.start()
+
+        self._normalRequestID = None
+
+        self._monitoringRequested = False
+        self._monitoring = False
+
+        self._aircraftName = None
+        self._aircraftModel = None
+
+    def connect(self):
+        """Initiate a connection to the simulator."""
+        self._handler.connect()
+        self._startDefaultNormal()
+                                                            
+    def startMonitoring(self):
+        """Start the periodic monitoring of the aircraft and pass the resulting
+        state to the aircraft object periodically."""
+        assert not self._monitoringRequested         
+        self._monitoringRequested = True
 
     def stopMonitoring(self):
         """Stop the periodic monitoring of the aircraft."""
-        self._aircraft = None
+        assert self._monitoringRequested 
+        self._monitoringRequested = False
 
     def disconnect(self):
         """Disconnect from the simulator."""
+        assert not self._monitoringRequested 
+        
+        self._stopNormal()
         self._handler.disconnect()
 
-    def _startMonitoring(self):
-        """The internal call to start monitoring."""
-        self._handler.requestRead([(0x3d00, -256)], self._monitoringStartCallback)
-
-    def _monitoringStartCallback(self, data, extra):
-        """Callback for the data read when the monitoring has started.
-        
-        The following data items are expected:
-        - the name of the aircraft
+    def _startDefaultNormal(self):
+        """Start the default normal periodic request."""
+        assert self._normalRequestID is None
+        self._normalRequestID = self._handler.requestPeriodicRead(1.0,
+                                                                  Simulator.normalData,
+                                                                  self._handleNormal)
+
+    def _stopNormal(self):
+        """Stop the normal period request."""
+        assert self._normalRequestID is not None
+        self._handler.clearPeriodic(self._normalRequestID)
+        self._normalRequestID = None
+
+    def _handleNormal(self, data, extra):
+        """Handle the reply to the normal request.
+
+        At the beginning the result consists the data for normalData. When
+        monitoring is started, it contains the result also for the
+        aircraft-specific values.
         """
-        if self._aircraft is None:
-            return
-        elif data is None:
+        self._setAircraftName(data[0])
+        if self._monitoringRequested and not self._monitoring:
+            self._monitoring = True
+            self._stopNormal()
             self._startMonitoring()
-        else:
-            self._setAircraftName(data[0])            
+        elif self._monitoring and not self._monitoringRequested:
+            self._monitoring = False
+            self._stopNormal()
+            self._startDefaultNormal()
+        elif self._monitoring and self._aircraftModel is not None:
+            aircraftState = self._aircraftModel.getAircraftState(self._aircraft, data)
+            self._aircraft.handleState(aircraftState)
 
     def _setAircraftName(self, name):
@@ -415 +443 @@
         self._aircraftModel = model
         
-        if self._monitoringRequestID is not None:
-            self._handler.clearPeriodic(self._monitoringRequestID)
-            
-        self._monitoringRequestID = \
-            self._handler.requestPeriodicRead(1.0, 
-                                              model.getMonitoringData(),
-                                              self._handleMonitoringData)
-
-    def _handleMonitoringData(self, data, extra):
-        """Handle the monitoring data."""
-        if self._aircraft is None:
-            self._handler.clearPeriodic(self._monitoringRequestID)
-            return
-
-        self._setAircraftName(data[0])
-        aircraftState = self._aircraftModel.getAircraftState(self._aircraft, data)
-        self._aircraft.handleState(aircraftState)
+        if self._monitoring:
+            self._handler.clearPeriodic(self._normalRequestID)            
+            self._startMonitoring()
+            
+    def _startMonitoring(self):
+        """Start monitoring with the current aircraft model."""
+        assert self._monitoring
+
+        data = Simulator.normalData[:]
+        self._aircraftModel.addMonitoringData(data)
+        
+        self._normalRequestID = \
+            self._handler.requestPeriodicRead(1.0, data, 
+                                              self._handleNormal)
 
 #------------------------------------------------------------------------------
@@ -440 +465 @@
     Aircraft models handle the data arriving from FSUIPC and turn it into an
     object describing the aircraft's state."""
-    monitoringData = [("aircraftName", 0x3d00, -256),
-                      ("year", 0x0240, "H"),
+    monitoringData = [("year", 0x0240, "H"),
                       ("dayOfYear", 0x023e, "H"),
                       ("zuluHour", 0x023b, "b"),
@@ -448 +472 @@
                       ("paused", 0x0264, "H"),
                       ("frozen", 0x3364, "H"),
+                      ("replay", 0x0628, "d"),
                       ("slew", 0x05dc, "H"),
                       ("overspeed", 0x036d, "b"),
@@ -457 +482 @@
                       ("bank", 0x057c, "d"),
                       ("ias", 0x02bc, "d"),
+                      ("groundSpeed", 0x02b4, "d"),
                       ("vs", 0x02c8, "d"),
                       ("altitude", 0x0570, "l"),
+                      ("gLoad", 0x11ba, "H"),
                       ("flapsControl", 0x0bdc, "d"),
                       ("flapsLeft", 0x0be0, "d"),
@@ -466 +493 @@
                       ("noseGear", 0x0bec, "d"),
                       ("spoilersArmed", 0x0bcc, "d"),
-                      ("spoilers", 0x0bd0, "d")]
+                      ("spoilers", 0x0bd0, "d"),
+                      ("altimeter", 0x0330, "H"),
+                      ("nav1", 0x0350, "H"),
+                      ("nav2", 0x0352, "H")]
 
     @staticmethod
@@ -473 +503 @@
         aircraft about it."""        
         return AircraftModel([0, 10, 20, 30])
+
+    @staticmethod
+    def convertFrequency(data):
+        """Convert the given frequency data to a string."""
+        frequency = ""
+        for i in range(0, 4):
+            digit = chr(ord('0') + (data&0x0f))
+            data >>= 4
+            frequency = digit + frequency
+            if i==1:
+                frequency = "." + frequency
+        return "1" + frequency            
 
     def __init__(self, flapsNotches):
@@ -508 +550 @@
             index += 1
             
-    def getMonitoringData(self):
+    def addMonitoringData(self, data):
         """Get the data specification for monitoring.
         
-        The first item should always be the aircraft name (0x3d00, -256)."""
-        data = []
+        Add the model-specific monitoring data to the given array."""
         self.addDataWithIndexMembers(data, "_monidx_",
                                      AircraftModel.monitoringData)
-        return data
     
     def getAircraftState(self, aircraft, data):
@@ -530 +570 @@
         
         state.paused = data[self._monidx_paused]!=0 or \
-            data[self._monidx_frozen]!=0
+            data[self._monidx_frozen]!=0 or \
+            data[self._monidx_replay]!=0
         state.trickMode = data[self._monidx_slew]!=0
 
@@ -546 +587 @@
 
         state.ias = data[self._monidx_ias]/128.0
+        state.groundSpeed = data[self._monidx_groundSpeed]* 3600.0/65536.0/1852.0
         state.vs = data[self._monidx_vs]*60.0*3.28984/256.0
 
         state.altitude = data[self._monidx_altitude]*3.28084/65536.0/65536.0
+
+        state.gLoad = data[self._monidx_gLoad] / 625.0
         
         numNotchesM1 = len(self._flapsNotches) - 1
@@ -572 +616 @@
         lights = data[self._monidx_lights]
         
-        state.navLightsOn = (lights%0x01) != 0
-        state.antiCollisionLightsOn = (lights%0x02) != 0
-        state.landingLightsOn = (lights%0x04) != 0
-        state.strobeLightsOn = (lights%0x10) != 0
+        state.navLightsOn = (lights&0x01) != 0
+        state.antiCollisionLightsOn = (lights&0x02) != 0
+        state.landingLightsOn = (lights&0x04) != 0
+        state.strobeLightsOn = (lights&0x10) != 0
         
         state.pitotHeatOn = data[self._monidx_pitot]!=0
@@ -588 +632 @@
         else:
             state.spoilersExtension = (spoilers - 4800) * 100.0 / (16383 - 4800)
+
+        state.altimeter = data[self._monidx_altimeter] / 16.0
+           
+        state.nav1 = AircraftModel.convertFrequency(data[self._monidx_nav1])
+        state.nav2 = AircraftModel.convertFrequency(data[self._monidx_nav2])
         
         return state
+
+#------------------------------------------------------------------------------
+

src/test.py

@@ -9 +9 @@
     print data
 
-class ConnectionListener(fs.ConnectionListener):
-    def __init__(self):
-        self._simulator = None
-        self._monitoring = False
+def main():
+    simulator = fs.createSimulator(const.TYPE_MSFS9, fs.ConnectionListener(),
+                                   acft.Aircraft(const.AIRCRAFT_B737))
+    simulator.connect()
 
-    def connected(self, fsType, descriptor):
-        print "fs.ConnectionListener.connected, fsType:", fsType, ", descriptor:", descriptor
-        if not self._monitoring:
-            self._simulator.startMonitoring(acft.Aircraft(const.AIRCRAFT_B737))
-
-def main():
-    connectionListener = ConnectionListener()
-    simulator = fs.createSimulator(const.TYPE_MSFS9, connectionListener)
-    connectionListener._simulator = simulator
-    simulator.connect()
+    time.sleep(10)
+    simulator.startMonitoring()
 
     while True:
         time.sleep(1000)
+    simulator.stopMonitoring()
+    simulator.disconnect()
+
+    time.sleep(5)
 
 if __name__ == "__main__":