private FlightData _lastFlightData; //Most recent falcon memory data
/// <summary>
/// Retrieve the AoAState of the angle of attack indexer in the game.
/// </summary>
/// <returns>an AoAState object representation of the current state of the aoa indexer in falcon</returns>
public int GetAoa()
{
try {
_lastFlightData = _sharedMemReader.GetCurrentData(); //Retrieve the data from falcon, store in variable
var lightBits = (LightBits)_lastFlightData.lightBits; // Get the LightBits from the retrieved falcon data
bool high = (lightBits & LightBits.AOAAbove) != 0; //If specific LightBit is not = 0 - means the LED is on in game.
bool on = (lightBits & LightBits.AOAOn) != 0;
bool low = (lightBits & LightBits.AOABelow) != 0;
var totalValue = 0; //The total value of all of the LEDs that are on.
if (high) //If AoA.Above is on in the game add it to the total value of the AoAState to send.
{
totalValue += AoaState.H;
}
if (on) //same as above but for the "on" bit.
{
totalValue += AoaState.O;
}
if (low) // low bit.
{
totalValue += AoaState.L;
}
//Determine which AoAState the totalValue variable corresponds to.
//Not exactly necessary, but why the hell not.
switch (totalValue)
{
case AoaState.H:
return(AoaState.H);
case AoaState.L:
return(AoaState.L);
case AoaState.O:
return(AoaState.O);
case AoaState.HL:
return(AoaState.HL);
case AoaState.HO:
return(AoaState.HO);
case AoaState.OL:
return(AoaState.OL);
case AoaState.HOL:
return(AoaState.HOL);
case AoaState.OFF:
return(AoaState.OFF);
default:
return(AoaState.OFF);
}
}
catch (NullReferenceException) { //LightBits will be null if the game isnt running.
Console.WriteLine("Falcon is not running!");
return(0);
}
}
protected override bool getGearDownValue(FlightData flightData)
{
return(flightData.RightGearPos == 1.0f);
}
public void Adapt(IFuelQuantityIndicator fuelQuantityIndicator, FlightData flightData)
{
fuelQuantityIndicator.InstrumentState.AftLeftFuelQuantityPounds = flightData.aft / 10.0f;
fuelQuantityIndicator.InstrumentState.ForeRightFuelQuantityPounds = flightData.fwd / 10.0f;
fuelQuantityIndicator.InstrumentState.TotalFuelQuantityPounds = flightData.total;
}
protected override bool getNonNullValue(FlightData flightData)
{
return((flightData.tacanInfo[tacanSource] & bit) != 0);
}
protected override bool getNonNullValue(FlightData flightData)
{
return((flightData.powerBits & bit) != 0);
}
private static bool WeightOnWheels(FlightData flightData)
{
return((flightData.lightBits & (int)LightBits.ONGROUND) == (int)LightBits.ONGROUND);
}
public Flight(FlightInfo flightInfo, FlightData flightData)
{
this.flightInfo = flightInfo;
this.flightData = flightData;
}
public FlightDataChangedEventArgs(FlightData oldFlightData, FlightData newFlightData)
{
this.oldFlightData = oldFlightData;
this.newFlightData = newFlightData;
}
private void timerTick(object sender, EventArgs e)
{
if (reader == null)
{
if (GetFalconWindowHandle() != IntPtr.Zero)
{
reader = new Reader();
if (!reader.IsFalconRunning)
{
reader.Dispose();
reader = null;
}
else
{
DebugUtils.Speak(string.Format("Falcon started"));
raiseFalconStarted();
timer.Interval = readFalconDataTimerInterval;
}
}
}
else
{
if (GetFalconWindowHandle() == IntPtr.Zero)
{
DebugUtils.Speak(string.Format("Falcon stopped"));
reader.Dispose();
reader = null;
raiseFalconStopped();
timer.Interval = detectFalconTimerInterval;
}
}
FlightData newFlightData = null;
if (reader != null)
{
newFlightData = reader.GetCurrentData();
}
if (newFlightData == null)
{
if (oldFlightData != null)
{
raiseFlightDataChanged(oldFlightData, newFlightData);
raiseFlightDataLightsChanged(oldFlightData, newFlightData);
}
}
else
{
if (oldFlightData == null)
{
raiseFlightDataChanged(oldFlightData, newFlightData);
raiseFlightDataLightsChanged(oldFlightData, newFlightData);
}
else
{
raiseFlightDataChanged(oldFlightData, newFlightData);
bool lightChanged = (oldFlightData.lightBits ^ newFlightData.lightBits) != 0;
lightChanged |= (oldFlightData.lightBits2 ^ newFlightData.lightBits2) != 0;
lightChanged |= (oldFlightData.lightBits3 ^ newFlightData.lightBits3) != 0;
lightChanged |= (oldFlightData.hsiBits ^ newFlightData.hsiBits) != 0;
lightChanged |= oldFlightData.speedBrake != newFlightData.speedBrake;
lightChanged |= oldFlightData.rpm != newFlightData.rpm;
lightChanged |= (oldFlightData.blinkBits ^ newFlightData.blinkBits) != 0;
lightChanged |= (oldFlightData.powerBits ^ newFlightData.powerBits) != 0;
lightChanged |= oldFlightData.tacanInfo != newFlightData.tacanInfo;
lightChanged |= oldFlightData.navMode != newFlightData.navMode;
lightChanged |= (oldFlightData.cmdsMode ^ newFlightData.cmdsMode) != 0;
lightChanged |= (oldFlightData.altBits ^ newFlightData.altBits) != 0;
if (lightChanged)
{
raiseFlightDataLightsChanged(oldFlightData, newFlightData);
}
}
}
oldFlightData = newFlightData;
}
private static void UpdateHSI(IHorizontalSituationIndicator hsi, IEHSI ehsi, HsiBits hsibits, FlightData fromFalcon)
{
hsi.InstrumentState.OffFlag = ((hsibits & HsiBits.HSI_OFF) == HsiBits.HSI_OFF) && !Extractor.State.OptionsFormIsShowing;
hsi.InstrumentState.MagneticHeadingDegrees = (360 + (fromFalcon.yaw / Common.Math.Constants.RADIANS_PER_DEGREE)) % 360;
ehsi.InstrumentState.NoDataFlag = ((hsibits & HsiBits.HSI_OFF) == HsiBits.HSI_OFF) && !Extractor.State.OptionsFormIsShowing;;
ehsi.InstrumentState.NoPowerFlag = ((fromFalcon.powerBits & (int)PowerBits.BusPowerBattery) != (int)PowerBits.BusPowerBattery) && !Extractor.State.OptionsFormIsShowing;
ehsi.InstrumentState.MagneticHeadingDegrees = (360 + (fromFalcon.yaw / Common.Math.Constants.RADIANS_PER_DEGREE)) % 360;
}
public void Adapt(IFuelFlow fuelFlow, FlightData flightData)
{
fuelFlow.InstrumentState.FuelFlowPoundsPerHour = flightData.fuelFlow;
}
public void UpdateRendererStatesFromFlightData(
IDictionary <InstrumentType, IInstrument> instruments,
FlightData flightData,
TerrainDB terrainDB,
Action updateEHSIBrightnessLabelVisibility,
F4TexSharedMem.IReader texSharedmemReader)
{
if (flightData == null || (Extractor.State.NetworkMode != NetworkMode.Client && !Extractor.State.SimRunning))
{
flightData = new FlightData {
hsiBits = Int32.MaxValue
};
}
var hsi = instruments[InstrumentType.HSI].Renderer as IHorizontalSituationIndicator;
var ehsi = instruments[InstrumentType.EHSI].Renderer as IEHSI;
var adi = instruments[InstrumentType.ADI].Renderer as IADI;
var isis = instruments[InstrumentType.ISIS].Renderer as IISIS;
if (Extractor.State.SimRunning || Extractor.State.NetworkMode == NetworkMode.Client || Extractor.State.OptionsFormIsShowing)
{
var hsibits = ((HsiBits)flightData.hsiBits);
_flightDataAdapterSet.ISIS.Adapt(instruments[InstrumentType.ISIS].Renderer as IISIS, flightData);
_flightDataAdapterSet.VVI.Adapt(instruments[InstrumentType.VVI].Renderer as IVerticalVelocityIndicator, flightData);
_flightDataAdapterSet.Altimeter.Adapt(instruments[InstrumentType.Altimeter].Renderer as IAltimeter, flightData);
_flightDataAdapterSet.AirspeedIndicator.Adapt(instruments[InstrumentType.ASI].Renderer as IAirspeedIndicator, flightData);
_flightDataAdapterSet.Compass.Adapt(instruments[InstrumentType.Compass].Renderer as ICompass, flightData);
_flightDataAdapterSet.AOAIndicator.Adapt(instruments[InstrumentType.AOAIndicator].Renderer as IAngleOfAttackIndicator, flightData);
_flightDataAdapterSet.AOAIndexer.Adapt(instruments[InstrumentType.AOAIndexer].Renderer as IAngleOfAttackIndexer, flightData);
UpdateADI(instruments[InstrumentType.ADI].Renderer as IADI, hsibits);
_flightDataAdapterSet.StandbyADI.Adapt(instruments[InstrumentType.BackupADI].Renderer as IStandbyADI, flightData);
UpdateHSI(instruments[InstrumentType.HSI].Renderer as IHorizontalSituationIndicator, instruments[InstrumentType.EHSI].Renderer as IEHSI, hsibits, flightData);
//***** UPDATE SOME COMPLEX HSI/ADI VARIABLES
if (ADIIsTurnedOff(hsibits))
{
SetADIToOffState(instruments[InstrumentType.ADI].Renderer as IADI);
SetISISToOffState(instruments[InstrumentType.ISIS].Renderer as IISIS);
}
else
{
SetADIPitchAndRoll(instruments[InstrumentType.ADI].Renderer as IADI, flightData);
SetISISPitchAndRoll(instruments[InstrumentType.ISIS].Renderer as IISIS, flightData);
//The following floating data is also crossed up in the flightData.h File:
//float AdiIlsHorPos; // Position of horizontal ILS bar ----Vertical
//float AdiIlsVerPos; // Position of vertical ILS bar-----horizontal
var commandBarsOn = ((float)(Math.Abs(Math.Round(flightData.AdiIlsHorPos, 4))) != 0.1745f);
if ((Math.Abs((flightData.AdiIlsVerPos / Common.Math.Constants.RADIANS_PER_DEGREE)) > 1.0f)
||
(Math.Abs((flightData.AdiIlsHorPos / Common.Math.Constants.RADIANS_PER_DEGREE)) > 5.0f))
{
commandBarsOn = false;
}
hsi.InstrumentState.ShowToFromFlag = true;
ehsi.InstrumentState.ShowToFromFlag = true;
//if the TOTALFLAGS flag is off, then we're most likely in NAV mode
if ((hsibits & HsiBits.TotalFlags) != HsiBits.TotalFlags)
{
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
}
//if the TO/FROM flag is showing in shared memory, then we are most likely in TACAN mode
else if ((((hsibits & HsiBits.ToTrue) == HsiBits.ToTrue)
||
((hsibits & HsiBits.FromTrue) == HsiBits.FromTrue)))
{
if (!commandBarsOn) //better make sure we're not in any ILS mode too though
{
hsi.InstrumentState.ShowToFromFlag = true;
ehsi.InstrumentState.ShowToFromFlag = true;
}
}
//if the glideslope or localizer flags on the ADI are turned on, then we must be in an ILS mode and therefore we
//know we don't need to show the HSI TO/FROM flags.
if (((hsibits & HsiBits.ADI_GS) == HsiBits.ADI_GS)
||
((hsibits & HsiBits.ADI_LOC) == HsiBits.ADI_LOC))
{
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
}
if (commandBarsOn)
{
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
}
adi.InstrumentState.ShowCommandBars = commandBarsOn;
adi.InstrumentState.GlideslopeDeviationDegrees = flightData.AdiIlsVerPos / Common.Math.Constants.RADIANS_PER_DEGREE;
adi.InstrumentState.LocalizerDeviationDegrees = flightData.AdiIlsHorPos / Common.Math.Constants.RADIANS_PER_DEGREE;
isis.InstrumentState.ShowCommandBars = commandBarsOn;
isis.InstrumentState.GlideslopeDeviationDegrees = flightData.AdiIlsVerPos / Common.Math.Constants.RADIANS_PER_DEGREE;
isis.InstrumentState.LocalizerDeviationDegrees = flightData.AdiIlsHorPos / Common.Math.Constants.RADIANS_PER_DEGREE;
}
UpdateNavigationMode(hsi, ehsi, adi, isis, flightData);
if (((hsibits & HsiBits.HSI_OFF) == HsiBits.HSI_OFF))
{
TurnOffHSI(hsi);
TurnOffEHSI(ehsi);
}
else
{
UpdateHSIFlightData(hsi, flightData, hsibits);
UpdateEHSIFlightData(ehsi, flightData, hsibits);
}
UpdateHSIAndEHSICourseDeviationAndToFromFlags(hsi, ehsi);
UpdateEHSI(updateEHSIBrightnessLabelVisibility);
_flightDataAdapterSet.HYDA.Adapt(instruments[InstrumentType.HYDA].Renderer as IHydraulicPressureGauge, flightData);
_flightDataAdapterSet.HYDB.Adapt(instruments[InstrumentType.HYDB].Renderer as IHydraulicPressureGauge, flightData);
_flightDataAdapterSet.CabinPress.Adapt(instruments[InstrumentType.CabinPress].Renderer as ICabinPressureAltitudeIndicator, flightData);
_flightDataAdapterSet.RollTrim.Adapt(instruments[InstrumentType.RollTrim].Renderer as IRollTrimIndicator, flightData);
_flightDataAdapterSet.PitchTrim.Adapt(instruments[InstrumentType.PitchTrim].Renderer as IPitchTrimIndicator, flightData);
_flightDataAdapterSet.AzimuthIndicator.Adapt(instruments[InstrumentType.AzimuthIndicator].Renderer as IAzimuthIndicator, flightData);
_flightDataAdapterSet.RWR.Adapt(instruments[InstrumentType.RWR].Renderer as IRWRRenderer, flightData);
_flightDataAdapterSet.CautionPanel.Adapt(instruments[InstrumentType.CautionPanel].Renderer as ICautionPanel, flightData);
_flightDataAdapterSet.CMDS.Adapt(instruments[InstrumentType.CMDS].Renderer as ICMDSPanel, flightData);
_flightDataAdapterSet.DED.Adapt(instruments[InstrumentType.DED].Renderer as IDataEntryDisplayPilotFaultList, flightData);
_flightDataAdapterSet.PFL.Adapt(instruments[InstrumentType.PFL].Renderer as IDataEntryDisplayPilotFaultList, flightData);
_flightDataAdapterSet.EPUFuel.Adapt(instruments[InstrumentType.EPUFuel].Renderer as IEPUFuelGauge, flightData);
_flightDataAdapterSet.FuelFlow.Adapt(instruments[InstrumentType.FuelFlow].Renderer as IFuelFlow, flightData);
_flightDataAdapterSet.FuelQuantity.Adapt(instruments[InstrumentType.FuelQuantity].Renderer as IFuelQuantityIndicator, flightData);
_flightDataAdapterSet.LandingGearLights.Adapt(instruments[InstrumentType.GearLights].Renderer as ILandingGearWheelsLights, flightData);
_flightDataAdapterSet.NWS.Adapt(instruments[InstrumentType.NWSIndexer].Renderer as INosewheelSteeringIndexer, flightData);
_flightDataAdapterSet.Speedbrake.Adapt(instruments[InstrumentType.Speedbrake].Renderer as ISpeedbrakeIndicator, flightData);
_flightDataAdapterSet.RPM1.Adapt(instruments[InstrumentType.RPM1].Renderer as ITachometer, flightData);
_flightDataAdapterSet.RPM2.Adapt(instruments[InstrumentType.RPM2].Renderer as ITachometer, flightData);
_flightDataAdapterSet.FTIT1.Adapt(instruments[InstrumentType.FTIT1].Renderer as IFanTurbineInletTemperature, flightData);
_flightDataAdapterSet.FTIT2.Adapt(instruments[InstrumentType.FTIT2].Renderer as IFanTurbineInletTemperature, flightData);
_flightDataAdapterSet.NOZ1.Adapt(instruments[InstrumentType.NOZ1].Renderer as INozzlePositionIndicator, flightData);
_flightDataAdapterSet.NOZ2.Adapt(instruments[InstrumentType.NOZ2].Renderer as INozzlePositionIndicator, flightData);
_flightDataAdapterSet.OIL1.Adapt(instruments[InstrumentType.OIL1].Renderer as IOilPressureGauge, flightData);
_flightDataAdapterSet.OIL2.Adapt(instruments[InstrumentType.OIL2].Renderer as IOilPressureGauge, flightData);
_flightDataAdapterSet.Accelerometer.Adapt(instruments[InstrumentType.Accelerometer].Renderer as IAccelerometer, flightData);
}
else //Falcon's not running
{
if (instruments[InstrumentType.VVI].Renderer is IVerticalVelocityIndicatorEU)
{
((IVerticalVelocityIndicatorEU)instruments[InstrumentType.VVI].Renderer).InstrumentState.OffFlag = true;
}
else if (instruments[InstrumentType.VVI].Renderer is IVerticalVelocityIndicatorUSA)
{
((IVerticalVelocityIndicatorUSA)instruments[InstrumentType.VVI].Renderer).InstrumentState.OffFlag = true;
}
((IAngleOfAttackIndicator)(instruments[InstrumentType.AOAIndicator].Renderer)).InstrumentState.OffFlag = true;
hsi.InstrumentState.OffFlag = true;
ehsi.InstrumentState.NoDataFlag = true;
((IADI)instruments[InstrumentType.ADI].Renderer).InstrumentState.OffFlag = true;
((IStandbyADI)instruments[InstrumentType.BackupADI].Renderer).InstrumentState.OffFlag = true;
((IAzimuthIndicator)instruments[InstrumentType.AzimuthIndicator].Renderer).InstrumentState.RWRPowerOn = false;
((IISIS)instruments[InstrumentType.ISIS].Renderer).InstrumentState.RadarAltitudeAGL = 0;
((IISIS)instruments[InstrumentType.ISIS].Renderer).InstrumentState.OffFlag = true;
updateEHSIBrightnessLabelVisibility();
}
var left = flightData.RTT_area[(int)RTT_areas.RTT_MFDLEFT * 4];
var top = flightData.RTT_area[((int)RTT_areas.RTT_MFDLEFT * 4) + 1];
var right = flightData.RTT_area[((int)RTT_areas.RTT_MFDLEFT * 4) + 2];
var bottom = flightData.RTT_area[((int)RTT_areas.RTT_MFDLEFT * 4) + 3];
var lmfdSourceRect = new Rectangle(left, top, right - left, bottom - top);
_flightDataAdapterSet.LMFD.Adapt(instruments[InstrumentType.LMFD], texSharedmemReader, lmfdSourceRect, InstrumentType.LMFD);
left = flightData.RTT_area[(int)RTT_areas.RTT_MFDRIGHT * 4];
top = flightData.RTT_area[((int)RTT_areas.RTT_MFDRIGHT * 4) + 1];
right = flightData.RTT_area[((int)RTT_areas.RTT_MFDRIGHT * 4) + 2];
bottom = flightData.RTT_area[((int)RTT_areas.RTT_MFDRIGHT * 4) + 3];
var rmfdSourceRect = new Rectangle(left, top, right - left, bottom - top);
_flightDataAdapterSet.RMFD.Adapt(instruments[InstrumentType.RMFD], texSharedmemReader, rmfdSourceRect, InstrumentType.RMFD);
left = flightData.RTT_area[(int)RTT_areas.RTT_HUD * 4];
top = flightData.RTT_area[((int)RTT_areas.RTT_HUD * 4) + 1];
right = flightData.RTT_area[((int)RTT_areas.RTT_HUD * 4) + 2];
bottom = flightData.RTT_area[((int)RTT_areas.RTT_HUD * 4) + 3];
var hudSourceRect = new Rectangle(left, top, right - left, bottom - top);
_flightDataAdapterSet.HUD.Adapt(instruments[InstrumentType.HUD], texSharedmemReader, hudSourceRect, InstrumentType.HUD);
}
private static void UpdateNavigationMode(IHorizontalSituationIndicator hsi, IEHSI ehsi, IADI adi, IISIS isis, FlightData flightData)
{
/*
* This value is called navMode and is unsigned char type with 4 possible values: ILS_TACAN = 0, and TACAN = 1,
* NAV = 2, ILS_NAV = 3
*/
byte bmsNavMode = flightData.navMode;
switch (bmsNavMode)
{
case 0: //NavModes.PlsTcn:
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.InstrumentMode = InstrumentModes.PlsTacan;
break;
case 1: //NavModes.Tcn:
hsi.InstrumentState.ShowToFromFlag = true;
ehsi.InstrumentState.ShowToFromFlag = true;
ehsi.InstrumentState.InstrumentMode = InstrumentModes.Tacan;
adi.InstrumentState.ShowCommandBars = false;
isis.InstrumentState.ShowCommandBars = false;
break;
case 2: //NavModes.Nav:
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.InstrumentMode = InstrumentModes.Nav;
adi.InstrumentState.ShowCommandBars = false;
isis.InstrumentState.ShowCommandBars = false;
break;
case 3: //NavModes.PlsNav:
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.InstrumentMode = InstrumentModes.PlsNav;
break;
}
}
private static void SetADIPitchAndRoll(IADI adi, FlightData flightData)
{
adi.InstrumentState.PitchDegrees = ((flightData.pitch / Common.Math.Constants.RADIANS_PER_DEGREE));
adi.InstrumentState.RollDegrees = ((flightData.roll / Common.Math.Constants.RADIANS_PER_DEGREE));
}
internal override void PollData()
{
if (_sharedMemory != null && _sharedMemory.IsDataAvailable)
{
_lastFlightData = (FlightData)_sharedMemory.MarshalTo(typeof(FlightData));
float altitidue = _lastFlightData.z;
if (_lastFlightData.z < 0)
{
altitidue = 99999.99f - _lastFlightData.z;
}
SetValue("Altimeter", "altitidue", new BindingValue(altitidue));
SetValue("Altimeter", "barimetric pressure", new BindingValue(29.92));
SetValue("ADI", "pitch", new BindingValue(_lastFlightData.pitch));
SetValue("ADI", "roll", new BindingValue(_lastFlightData.roll));
SetValue("ADI", "ils horizontal", new BindingValue((_lastFlightData.AdiIlsHorPos / 2.5f) - 1f));
SetValue("ADI", "ils vertical", new BindingValue((_lastFlightData.AdiIlsVerPos * 2f) - 1f));
SetValue("HSI", "bearing to beacon", new BindingValue(_lastFlightData.bearingToBeacon));
SetValue("HSI", "current heading", new BindingValue(_lastFlightData.currentHeading));
SetValue("HSI", "desired course", new BindingValue(_lastFlightData.desiredCourse));
SetValue("HSI", "desired heading", new BindingValue(_lastFlightData.desiredHeading));
float deviation = _lastFlightData.courseDeviation % 180;
SetValue("HSI", "course deviation", new BindingValue(deviation / _lastFlightData.deviationLimit));
SetValue("HSI", "distance to beacon", new BindingValue(_lastFlightData.distanceToBeacon));
SetValue("VVI", "vertical velocity", new BindingValue(_lastFlightData.zDot));
SetValue("AOA", "angle of attack", new BindingValue(_lastFlightData.alpha));
SetValue("IAS", "mach", new BindingValue(_lastFlightData.mach));
SetValue("IAS", "indicated air speed", new BindingValue(_lastFlightData.kias));
SetValue("IAS", "true air speed", new BindingValue(_lastFlightData.vt));
SetValue("General", "Gs", new BindingValue(_lastFlightData.gs));
SetValue("Engine", "nozzle position", new BindingValue(NOZ(_lastFlightData.rpm, _lastFlightData.z, _lastFlightData.fuelFlow)));
SetValue("Fuel", "internal fuel", new BindingValue(_lastFlightData.internalFuel));
SetValue("Fuel", "external fuel", new BindingValue(_lastFlightData.externalFuel));
SetValue("Engine", "fuel flow", new BindingValue(_lastFlightData.fuelFlow));
SetValue("Engine", "rpm", new BindingValue(_lastFlightData.rpm));
SetValue("Engine", "ftit", new BindingValue(Ftit(_lastFlightData.ftit, _lastFlightData.rpm)));
SetValue("Landging Gear", "position", new BindingValue(_lastFlightData.gearPos != 0d));
SetValue("General", "speed brake position", new BindingValue(_lastFlightData.speedBrake));
SetValue("General", "speed brake indicator", new BindingValue(_lastFlightData.speedBrake > 0d));
SetValue("EPU", "fuel", new BindingValue(_lastFlightData.epuFuel));
SetValue("Engine", "oil pressure", new BindingValue(_lastFlightData.oilPressure));
SetValue("CMDS", "chaff remaining", new BindingValue(_lastFlightData.ChaffCount));
SetValue("CMDS", "flares remaining", new BindingValue(_lastFlightData.FlareCount));
SetValue("Trim", "roll trim", new BindingValue(_lastFlightData.TrimRoll));
SetValue("Trim", "pitch trim", new BindingValue(_lastFlightData.TrimPitch));
SetValue("Trim", "yaw trim", new BindingValue(_lastFlightData.TrimYaw));
SetValue("Tacan", "ufc tacan chan", new BindingValue(_lastFlightData.UFCTChan));
SetValue("Tacan", "aux tacan chan", new BindingValue(_lastFlightData.AUXTChan));
ProcessHsiBits(_lastFlightData.hsiBits, _lastFlightData.desiredCourse, _lastFlightData.bearingToBeacon);
ProcessLightBits(_lastFlightData.lightBits);
ProcessLightBits2(_lastFlightData.lightBits2);
ProcessLightBits3(_lastFlightData.lightBits3);
ProcessContacts(_lastFlightData);
}
}
/* todo
* This method updates the data of a flight (especially location) and add it to
* the relevant flights list.
*/
private async Task <IEnumerable <FlightData> > UpdateAndAddFlight(DateTime relative_to,
InitialLocation currentInitial, FlightPlan currentPlan, FlightData relevantFlightData,
FlightPlan plan, IEnumerable <FlightData> relevantFlights)
{
var secondsInFlight = (relative_to - currentInitial.DateTime).TotalSeconds;
IEnumerable <Segment> planSegments = await _flightContext.SegmentItems
.Where(x => x.FlightPlanId == currentPlan.Id).ToListAsync();
var planSegmentDict = new SortedDictionary <int, Segment>();
var index = 0;
foreach (var planSegment in planSegments)
{
planSegmentDict.Add(index, planSegment);
index++;
}
FindAndUpdateLocation(relative_to, planSegmentDict,
secondsInFlight, currentInitial, relevantFlightData, plan);
relevantFlights = relevantFlights.Append(relevantFlightData);
return(relevantFlights);
}
private static bool OnGround(FlightData flightData)
{
return((flightData.lightBits3 & (int)LightBits3.OnGround) == (int)LightBits3.OnGround);
}
public void Adapt(IRollTrimIndicator rollTrimIndicator, FlightData flightData)
{
var rolltrim = flightData.TrimRoll;
rollTrimIndicator.InstrumentState.RollTrimPercent = rolltrim * 2.0f * 100.0f;
}
public DedFunctions(ISerialComm serialComm, ref AppState appState, ref IBMSReader BMSreader, ref FlightData flightData)
{
this.serialComm = serialComm;
this.appState = appState;
this.BMSreader = BMSreader;
this.BMSdata = flightData;
}
protected static async System.Threading.Tasks.Task <bool> PushToCloudahoy(string szUser, LogbookEntry le, FlightData fd, int altUnits, int speedUnits, bool fSandbox)
{
if (fd == null)
{
throw new ArgumentNullException(nameof(fd));
}
fd.AltitudeUnits = (FlightData.AltitudeUnitTypes)altUnits;
fd.SpeedUnits = (FlightData.SpeedUnitTypes)speedUnits;
return(await MyFlightbook.OAuth.CloudAhoy.CloudAhoyClient.PushCloudAhoyFlight(szUser, le, fd, fSandbox).ConfigureAwait(false));
}
public void Adapt(ILandingGearWheelsLights landingGearLights, FlightData flightData)
{
landingGearLights.InstrumentState.LeftGearDown = ((flightData.lightBits3 & (int)LightBits3.LeftGearDown) == (int)LightBits3.LeftGearDown);
landingGearLights.InstrumentState.NoseGearDown = ((flightData.lightBits3 & (int)LightBits3.NoseGearDown) == (int)LightBits3.NoseGearDown);
landingGearLights.InstrumentState.RightGearDown = ((flightData.lightBits3 & (int)LightBits3.RightGearDown) == (int)LightBits3.RightGearDown);
}
protected void SetUpMaps(FlightData fd)
{
// Set up any maps.
cmbFormat.Items[(int)DownloadFormat.KML].Enabled = cmbFormat.Items[(int)DownloadFormat.GPX].Enabled = pnlMapControls.Visible = SetUpMapManager(fd, mfbGoogleMapManager1, CurrentFlight.Route, PathLatLongArrayID);
lnkZoomToFit.NavigateUrl = mfbGoogleMapManager1.ZoomToFitScript;
}
protected abstract bool getNonNullValue(FlightData flightData);
protected void Page_Load(object sender, EventArgs e)
{
Master.SelectedTab = tabID.tabLogbook;
// Set the multi-drag handles to use the hidden controls
mhsClip.MultiHandleSliderTargets[0].ControlID = hdnClipMin.ClientID;
mhsClip.MultiHandleSliderTargets[1].ControlID = hdnClipMax.ClientID;
using (FlightData fd = new FlightData())
{
if (!IsPostBack)
{
try
{
CurrentFlightID = InitRequestedFlightID();
if (CurrentFlightID == LogbookEntryCore.idFlightNone)
{
throw new MyFlightbookException("No valid ID passed");
}
InitPassedRestriction();
int iTab = GetRequestedTabIndex();
if (AccordionCtrl.Panes[iTab].Visible)
{
AccordionCtrl.SelectedIndex = iTab;
}
LogbookEntryDisplay led = CurrentFlight = LoadFlight(CurrentFlightID);
SetUpChart(DataTableForFlightData(fd), cmbXAxis, cmbYAxis1, cmbYAxis2);
UpdateChart(fd);
UpdateRestriction();
SetUpDownload(led);
// shouldn't happen but sometimes does: GetUserAircraftByID returns null. Not quite sure why.
Aircraft ac = (new UserAircraft(led.User).GetUserAircraftByID(led.AircraftID)) ?? new Aircraft(led.AircraftID);
fmvAircraft.DataSource = new Aircraft[] { ac };
fmvAircraft.DataBind();
if (String.IsNullOrEmpty(CurrentFlight.FlightData) && TabIndexRequiresFlightData(iTab))
{
AccordionCtrl.SelectedIndex = DefaultTabIndex;
}
}
catch (MyFlightbookException ex)
{
lblPageErr.Text = ex.Message;
AccordionCtrl.Visible = mfbGoogleMapManager1.Visible = pnlMap.Visible = pnlAccordionMenuContainer.Visible = pnlFlightDesc.Visible = false;
return;
}
if (DoDirectDownload())
{
return;
}
}
else
{
UpdateChart(fd);
}
if (Restriction != null && !Restriction.IsDefault)
{
mfbFlightContextMenu.EditTargetFormatString = mfbFlightContextMenu.EditTargetFormatString + "?fq=" + HttpUtility.UrlEncode(Restriction.ToBase64CompressedJSONString());
}
mfbFlightContextMenu.Flight = CurrentFlight;
cmbAltUnits.SelectedValue = ((int)fd.AltitudeUnits).ToString(CultureInfo.InvariantCulture);
cmbSpeedUnits.SelectedValue = ((int)fd.SpeedUnits).ToString(CultureInfo.InvariantCulture);
if (!fd.HasDateTime)
{
lnkSendCloudAhoy.Visible = false;
}
SetUpMaps(fd);
if (!IsPostBack)
{
DistanceDisplay = CurrentFlight.GetPathDistanceDescription(fd.ComputePathDistance());
// Bind details - this will bind everything else.
CurrentFlight.UseHHMM = Viewer.UsesHHMM; // make sure we capture hhmm correctly.
fmvLE.DataSource = new LogbookEntryDisplay[] { CurrentFlight };
fmvLE.DataBind();
}
}
}
protected abstract bool getGearDownValue(FlightData flightData);
public async static Task <bool> PushCloudAhoyFlight(string szUsername, LogbookEntryCore flight, FlightData fd, bool fSandbox)
{
if (szUsername == null)
{
throw new ArgumentNullException(nameof(szUsername));
}
if (flight == null)
{
throw new ArgumentNullException(nameof(flight));
}
if (fd == null)
{
throw new ArgumentNullException(nameof(fd));
}
Profile pf = Profile.GetUser(szUsername);
CloudAhoyClient client = new CloudAhoyClient(fSandbox)
{
AuthState = pf.CloudAhoyToken
};
MemoryStream ms = null;
try
{
switch (flight.Telemetry.TelemetryType)
{
default:
ms = new MemoryStream();
fd.WriteGPXData(ms);
break;
case DataSourceType.FileType.GPX:
case DataSourceType.FileType.KML:
ms = new MemoryStream(Encoding.UTF8.GetBytes(flight.Telemetry.RawData));
break;
}
ms.Seek(0, SeekOrigin.Begin);
await client.PutStream(ms, flight).ConfigureAwait(false);
return(true);
}
finally
{
if (ms != null)
{
ms.Dispose();
}
}
}
private static FlightData ReadSharedMem()
{
return(_lastFlightData = _sharedMemReader.GetCurrentData());
}
public Response UpdateFlight(FlightData flightDetail)
{
var result = _repository.UpdateFlight(flightDetail);
return(result);
}
public void Adapt(IFanTurbineInletTemperature ftit2, FlightData flightData)
{
ftit2.InstrumentState.InletTemperatureDegreesCelcius = flightData.ftit2 * 100.0f;
}
public void Adapt(IOilPressureGauge oil2, FlightData flightData)
{
oil2.InstrumentState.OilPressurePercent = flightData.oilPressure2;
}
public void Adapt(INozzlePositionIndicator nozzlePositionIndicator, FlightData flightData)
{
nozzlePositionIndicator.InstrumentState.NozzlePositionPercent = flightData.nozzlePos2 * 100.0f;
}
private void ProcessContacts(FlightData flightData)
{
for (int i = 0; i < flightData.RWRsymbol.Length; i++)
{
_contacts[i].Symbol = (RadarSymbols)flightData.RWRsymbol[i];
_contacts[i].Selected = flightData.selected[i] > 0;
_contacts[i].Bearing = flightData.bearing[i] * 57.3f;
_contacts[i].RelativeBearing = (-flightData.currentHeading + _contacts[i].Bearing) % 360d;
_contacts[i].Lethality = flightData.lethality[i];
_contacts[i].MissileActivity = flightData.missileActivity[i] > 0;
_contacts[i].MissileLaunch = flightData.missileLaunch[i] > 0;
_contacts[i].NewDetection = flightData.newDetection[i] > 0;
_contacts[i].Visible = i < flightData.RwrObjectCount;
}
}
